source: vendor/3.6.9/source3/lib/dbwrap_file.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 9.4 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Database interface using a file per record
4 Copyright (C) Volker Lendecke 2005
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20#include "includes.h"
21
22struct db_file_ctx {
23 const char *dirname;
24
25 /* We only support one locked record at a time -- everything else
26 * would lead to a potential deadlock anyway! */
27 struct db_record *locked_record;
28};
29
30struct db_locked_file {
31 int fd;
32 uint8 hash;
33 const char *name;
34 const char *path;
35 struct db_file_ctx *parent;
36};
37
38/* Copy from statcache.c... */
39
40static uint32 fsh(const uint8 *p, int len)
41{
42 uint32 n = 0;
43 int i;
44 for (i=0; i<len; i++) {
45 n = ((n << 5) + n) ^ (uint32)(p[i]);
46 }
47 return n;
48}
49
50static int db_locked_file_destr(struct db_locked_file *data)
51{
52 if (data->parent != NULL) {
53 data->parent->locked_record = NULL;
54 }
55
56 if (close(data->fd) != 0) {
57 DEBUG(3, ("close failed: %s\n", strerror(errno)));
58 return -1;
59 }
60
61 return 0;
62}
63
64static NTSTATUS db_file_store(struct db_record *rec, TDB_DATA data, int flag);
65static NTSTATUS db_file_delete(struct db_record *rec);
66
67static struct db_record *db_file_fetch_locked(struct db_context *db,
68 TALLOC_CTX *mem_ctx,
69 TDB_DATA key)
70{
71 struct db_file_ctx *ctx = talloc_get_type_abort(db->private_data,
72 struct db_file_ctx);
73 struct db_record *result;
74 struct db_locked_file *file;
75 struct flock fl;
76 SMB_STRUCT_STAT statbuf;
77 ssize_t nread;
78 int ret;
79
80 SMB_ASSERT(ctx->locked_record == NULL);
81
82 again:
83 if (!(result = TALLOC_P(mem_ctx, struct db_record))) {
84 DEBUG(0, ("talloc failed\n"));
85 return NULL;
86 }
87
88 if (!(file = TALLOC_P(result, struct db_locked_file))) {
89 DEBUG(0, ("talloc failed\n"));
90 TALLOC_FREE(result);
91 return NULL;
92 }
93
94 result->private_data = file;
95 result->store = db_file_store;
96 result->delete_rec = db_file_delete;
97
98 result->key.dsize = key.dsize;
99 result->key.dptr = (uint8 *)talloc_memdup(result, key.dptr, key.dsize);
100 if (result->key.dptr == NULL) {
101 DEBUG(0, ("talloc failed\n"));
102 TALLOC_FREE(result);
103 return NULL;
104 }
105
106 /* Cut to 8 bits */
107 file->hash = fsh(key.dptr, key.dsize);
108 file->name = hex_encode_talloc(file, (unsigned char *)key.dptr, key.dsize);
109 if (file->name == NULL) {
110 DEBUG(0, ("hex_encode failed\n"));
111 TALLOC_FREE(result);
112 return NULL;
113 }
114
115 file->path = talloc_asprintf(file, "%s/%2.2X/%s", ctx->dirname,
116 file->hash, file->name);
117 if (file->path == NULL) {
118 DEBUG(0, ("talloc_asprintf failed\n"));
119 TALLOC_FREE(result);
120 return NULL;
121 }
122
123 become_root();
124 file->fd = open(file->path, O_RDWR|O_CREAT, 0644);
125 unbecome_root();
126
127 if (file->fd < 0) {
128 DEBUG(3, ("Could not open/create %s: %s\n",
129 file->path, strerror(errno)));
130 TALLOC_FREE(result);
131 return NULL;
132 }
133
134 talloc_set_destructor(file, db_locked_file_destr);
135
136 fl.l_type = F_WRLCK;
137 fl.l_whence = SEEK_SET;
138 fl.l_start = 0;
139 fl.l_len = 1;
140 fl.l_pid = 0;
141
142 do {
143 ret = fcntl(file->fd, F_SETLKW, &fl);
144 } while ((ret == -1) && (errno == EINTR));
145
146 if (ret == -1) {
147 DEBUG(3, ("Could not get lock on %s: %s\n",
148 file->path, strerror(errno)));
149 TALLOC_FREE(result);
150 return NULL;
151 }
152
153 if (sys_fstat(file->fd, &statbuf) != 0) {
154 DEBUG(3, ("Could not fstat %s: %s\n",
155 file->path, strerror(errno)));
156 TALLOC_FREE(result);
157 return NULL;
158 }
159
160 if (statbuf.st_nlink == 0) {
161 /* Someone has deleted it under the lock, retry */
162 TALLOC_FREE(result);
163 goto again;
164 }
165
166 result->value.dsize = 0;
167 result->value.dptr = NULL;
168
169 if (statbuf.st_size != 0) {
170 result->value.dsize = statbuf.st_size;
171 result->value.dptr = TALLOC_ARRAY(result, uint8,
172 statbuf.st_size);
173 if (result->value.dptr == NULL) {
174 DEBUG(1, ("talloc failed\n"));
175 TALLOC_FREE(result);
176 return NULL;
177 }
178
179 nread = read_data(file->fd, (char *)result->value.dptr,
180 result->value.dsize);
181 if (nread != result->value.dsize) {
182 DEBUG(3, ("read_data failed: %s\n", strerror(errno)));
183 TALLOC_FREE(result);
184 return NULL;
185 }
186 }
187
188 ctx->locked_record = result;
189 file->parent = (struct db_file_ctx *)talloc_reference(file, ctx);
190
191 return result;
192}
193
194static NTSTATUS db_file_store_root(int fd, TDB_DATA data)
195{
196 if (sys_lseek(fd, 0, SEEK_SET) != 0) {
197 DEBUG(0, ("sys_lseek failed: %s\n", strerror(errno)));
198 return map_nt_error_from_unix(errno);
199 }
200
201 if (write_data(fd, (char *)data.dptr, data.dsize) != data.dsize) {
202 DEBUG(3, ("write_data failed: %s\n", strerror(errno)));
203 return map_nt_error_from_unix(errno);
204 }
205
206 if (sys_ftruncate(fd, data.dsize) != 0) {
207 DEBUG(3, ("sys_ftruncate failed: %s\n", strerror(errno)));
208 return map_nt_error_from_unix(errno);
209 }
210
211 return NT_STATUS_OK;
212}
213
214static NTSTATUS db_file_store(struct db_record *rec, TDB_DATA data, int flag)
215{
216 struct db_locked_file *file =
217 talloc_get_type_abort(rec->private_data,
218 struct db_locked_file);
219 NTSTATUS status;
220
221 become_root();
222 status = db_file_store_root(file->fd, data);
223 unbecome_root();
224
225 return status;
226}
227
228static NTSTATUS db_file_delete(struct db_record *rec)
229{
230 struct db_locked_file *file =
231 talloc_get_type_abort(rec->private_data,
232 struct db_locked_file);
233 int res;
234
235 become_root();
236 res = unlink(file->path);
237 unbecome_root();
238
239 if (res == -1) {
240 DEBUG(3, ("unlink(%s) failed: %s\n", file->path,
241 strerror(errno)));
242 return map_nt_error_from_unix(errno);
243 }
244
245 return NT_STATUS_OK;
246}
247
248static int db_file_traverse(struct db_context *db,
249 int (*fn)(struct db_record *rec,
250 void *private_data),
251 void *private_data)
252{
253 struct db_file_ctx *ctx = talloc_get_type_abort(db->private_data,
254 struct db_file_ctx);
255 TALLOC_CTX *mem_ctx = talloc_init("traversal %s\n", ctx->dirname);
256
257 int i;
258 int count = 0;
259
260 for (i=0; i<256; i++) {
261 const char *dirname = talloc_asprintf(mem_ctx, "%s/%2.2X",
262 ctx->dirname, i);
263 DIR *dir;
264 struct dirent *dirent;
265
266 if (dirname == NULL) {
267 DEBUG(0, ("talloc failed\n"));
268 TALLOC_FREE(mem_ctx);
269 return -1;
270 }
271
272 dir = opendir(dirname);
273 if (dir == NULL) {
274 DEBUG(3, ("Could not open dir %s: %s\n", dirname,
275 strerror(errno)));
276 TALLOC_FREE(mem_ctx);
277 return -1;
278 }
279
280 while ((dirent = readdir(dir)) != NULL) {
281 DATA_BLOB keyblob;
282 TDB_DATA key;
283 struct db_record *rec;
284
285 if ((dirent->d_name[0] == '.') &&
286 ((dirent->d_name[1] == '\0') ||
287 ((dirent->d_name[1] == '.') &&
288 (dirent->d_name[2] == '\0')))) {
289 continue;
290 }
291
292 keyblob = strhex_to_data_blob(mem_ctx, dirent->d_name);
293 if (keyblob.data == NULL) {
294 DEBUG(5, ("strhex_to_data_blob failed\n"));
295 continue;
296 }
297
298 key.dptr = keyblob.data;
299 key.dsize = keyblob.length;
300
301 if ((ctx->locked_record != NULL) &&
302 (key.dsize == ctx->locked_record->key.dsize) &&
303 (memcmp(key.dptr, ctx->locked_record->key.dptr,
304 key.dsize) == 0)) {
305 count += 1;
306 if (fn(ctx->locked_record,
307 private_data) != 0) {
308 TALLOC_FREE(mem_ctx);
309 closedir(dir);
310 return count;
311 }
312 }
313
314 rec = db_file_fetch_locked(db, mem_ctx, key);
315 if (rec == NULL) {
316 /* Someone might have deleted it */
317 continue;
318 }
319
320 if (rec->value.dptr == NULL) {
321 TALLOC_FREE(rec);
322 continue;
323 }
324
325 count += 1;
326
327 if (fn(rec, private_data) != 0) {
328 TALLOC_FREE(mem_ctx);
329 closedir(dir);
330 return count;
331 }
332 TALLOC_FREE(rec);
333 }
334
335 closedir(dir);
336 }
337
338 TALLOC_FREE(mem_ctx);
339 return count;
340}
341
342struct db_context *db_open_file(TALLOC_CTX *mem_ctx,
343 struct messaging_context *msg_ctx,
344 const char *name,
345 int hash_size, int tdb_flags,
346 int open_flags, mode_t mode)
347{
348 struct db_context *result = NULL;
349 struct db_file_ctx *ctx;
350
351 if (!(result = TALLOC_ZERO_P(mem_ctx, struct db_context))) {
352 DEBUG(0, ("talloc failed\n"));
353 return NULL;
354 }
355
356 if (!(ctx = TALLOC_P(result, struct db_file_ctx))) {
357 DEBUG(0, ("talloc failed\n"));
358 TALLOC_FREE(result);
359 return NULL;
360 }
361
362 result->private_data = ctx;
363 result->fetch_locked = db_file_fetch_locked;
364 result->traverse = db_file_traverse;
365 result->traverse_read = db_file_traverse;
366 result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0);
367
368 ctx->locked_record = NULL;
369 if (!(ctx->dirname = talloc_strdup(ctx, name))) {
370 DEBUG(0, ("talloc failed\n"));
371 TALLOC_FREE(result);
372 return NULL;
373 }
374
375 if (open_flags & O_CREAT) {
376 int ret, i;
377
378 mode |= (mode & S_IRUSR) ? S_IXUSR : 0;
379 mode |= (mode & S_IRGRP) ? S_IXGRP : 0;
380 mode |= (mode & S_IROTH) ? S_IXOTH : 0;
381
382 ret = mkdir(name, mode);
383 if ((ret != 0) && (errno != EEXIST)) {
384 DEBUG(5, ("mkdir(%s,%o) failed: %s\n", name, mode,
385 strerror(errno)));
386 TALLOC_FREE(result);
387 return NULL;
388 }
389
390 for (i=0; i<256; i++) {
391 char *path;
392 path = talloc_asprintf(result, "%s/%2.2X", name, i);
393 if (path == NULL) {
394 DEBUG(0, ("asprintf failed\n"));
395 TALLOC_FREE(result);
396 return NULL;
397 }
398 ret = mkdir(path, mode);
399 if ((ret != 0) && (errno != EEXIST)) {
400 DEBUG(5, ("mkdir(%s,%o) failed: %s\n", path,
401 mode, strerror(errno)));
402 TALLOC_FREE(result);
403 return NULL;
404 }
405 TALLOC_FREE(path);
406 }
407 }
408
409 return result;
410}
Note: See TracBrowser for help on using the repository browser.