lib/dbwrap/dbwrap_file.c

   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 #include "dbwrap/dbwrap.h"
  22 #include "dbwrap/dbwrap_file.h"
  23 #include "dbwrap/dbwrap_private.h"
  24 #include "lib/tdb_wrap/tdb_wrap.h"
  25
  26 struct db_file_ctx {
  27         const char *dirname;
  28
  29         /* We only support one locked record at a time -- everything else
  30          * would lead to a potential deadlock anyway! */
  31         struct db_record *locked_record;
  32 };
  33
  34 struct db_locked_file {
  35         int fd;
  36         uint8_t hash;
  37         const char *name;
  38         const char *path;
  39         struct db_file_ctx *parent;
  40 };
  41
  42 /* Copy from statcache.c... */
  43
  44 static uint32_t fsh(const uint8_t *p, int len)
  45 {
  46         uint32_t n = 0;
  47         int i;
  48         for (i=0; i<len; i++) {
  49                 n = ((n << 5) + n) ^ (uint32_t)(p[i]);
  50         }
  51         return n;
  52 }
  53
  54 static int db_locked_file_destr(struct db_locked_file *data)
  55 {
  56         if (data->parent != NULL) {
  57                 data->parent->locked_record = NULL;
  58         }
  59
  60         if (close(data->fd) != 0) {
  61                 DEBUG(3, ("close failed: %s\n", strerror(errno)));
  62                 return -1;
  63         }
  64
  65         return 0;
  66 }
  67
  68 static NTSTATUS db_file_store(struct db_record *rec, TDB_DATA data, int flag);
  69 static NTSTATUS db_file_delete(struct db_record *rec);
  70
  71 static struct db_record *db_file_fetch_locked(struct db_context *db,
  72                                               TALLOC_CTX *mem_ctx,
  73                                               TDB_DATA key)
  74 {
  75         struct db_file_ctx *ctx = talloc_get_type_abort(db->private_data,
  76                                                         struct db_file_ctx);
  77         struct db_record *result;
  78         struct db_locked_file *file;
  79         struct flock fl;
  80         SMB_STRUCT_STAT statbuf;
  81         int ret;
  82
  83         SMB_ASSERT(ctx->locked_record == NULL);
  84
  85  again:
  86         if (!(result = talloc(mem_ctx, struct db_record))) {
  87                 DEBUG(0, ("talloc failed\n"));
  88                 return NULL;
  89         }
  90
  91         if (!(file = talloc(result, struct db_locked_file))) {
  92                 DEBUG(0, ("talloc failed\n"));
  93                 TALLOC_FREE(result);
  94                 return NULL;
  95         }
  96
  97         result->private_data = file;
  98         result->store = db_file_store;
  99         result->delete_rec = db_file_delete;
 100
 101         result->key.dsize = key.dsize;
 102         result->key.dptr = (uint8_t *)talloc_memdup(result, key.dptr,
 103                                                     key.dsize);
 104         if (result->key.dptr == NULL) {
 105                 DEBUG(0, ("talloc failed\n"));
 106                 TALLOC_FREE(result);
 107                 return NULL;
 108         }
 109
 110         /* Cut to 8 bits */
 111         file->hash = fsh(key.dptr, key.dsize);
 112         file->name = hex_encode_talloc(file, (unsigned char *)key.dptr, key.dsize);
 113         if (file->name == NULL) {
 114                 DEBUG(0, ("hex_encode failed\n"));
 115                 TALLOC_FREE(result);
 116                 return NULL;
 117         }
 118
 119         file->path = talloc_asprintf(file, "%s/%2.2X/%s", ctx->dirname,
 120                                      file->hash, file->name);
 121         if (file->path == NULL) {
 122                 DEBUG(0, ("talloc_asprintf failed\n"));
 123                 TALLOC_FREE(result);
 124                 return NULL;
 125         }
 126
 127         become_root();
 128         file->fd = open(file->path, O_RDWR|O_CREAT, 0644);
 129         unbecome_root();
 130
 131         if (file->fd < 0) {
 132                 DEBUG(3, ("Could not open/create %s: %s\n",
 133                           file->path, strerror(errno)));
 134                 TALLOC_FREE(result);
 135                 return NULL;
 136         }
 137
 138         talloc_set_destructor(file, db_locked_file_destr);
 139
 140         fl.l_type = F_WRLCK;
 141         fl.l_whence = SEEK_SET;
 142         fl.l_start = 0;
 143         fl.l_len = 1;
 144         fl.l_pid = 0;
 145
 146         do {
 147                 ret = fcntl(file->fd, F_SETLKW, &fl);
 148         } while ((ret == -1) && (errno == EINTR));
 149
 150         if (ret == -1) {
 151                 DEBUG(3, ("Could not get lock on %s: %s\n",
 152                           file->path, strerror(errno)));
 153                 TALLOC_FREE(result);
 154                 return NULL;
 155         }
 156
 157         if (sys_fstat(file->fd, &statbuf, false) != 0) {
 158                 DEBUG(3, ("Could not fstat %s: %s\n",
 159                           file->path, strerror(errno)));
 160                 TALLOC_FREE(result);
 161                 return NULL;
 162         }
 163
 164         if (statbuf.st_ex_nlink == 0) {
 165                 /* Someone has deleted it under the lock, retry */
 166                 TALLOC_FREE(result);
 167                 goto again;
 168         }
 169
 170         result->value.dsize = 0;
 171         result->value.dptr = NULL;
 172
 173         if (statbuf.st_ex_size != 0) {
 174                 ssize_t read_bytes;
 175
 176                 result->value.dsize = statbuf.st_ex_size;
 177                 result->value.dptr = talloc_array(result, uint8_t,
 178                                                   statbuf.st_ex_size);
 179                 if (result->value.dptr == NULL) {
 180                         DEBUG(1, ("talloc failed\n"));
 181                         TALLOC_FREE(result);
 182                         return NULL;
 183                 }
 184
 185                 read_bytes = read_data(file->fd, (char *)result->value.dptr,
 186                                        result->value.dsize);
 187                 if (read_bytes != result->value.dsize) {
 188                         DEBUG(3, ("read_data failed: %s\n", strerror(errno)));
 189                         TALLOC_FREE(result);
 190                         return NULL;
 191                 }
 192         }
 193
 194         ctx->locked_record = result;
 195         file->parent = (struct db_file_ctx *)talloc_reference(file, ctx);
 196
 197         return result;
 198 }
 199
 200 static NTSTATUS db_file_store_root(int fd, TDB_DATA data)
 201 {
 202         if (lseek(fd, 0, SEEK_SET) != 0) {
 203                 DEBUG(0, ("lseek failed: %s\n", strerror(errno)));
 204                 return map_nt_error_from_unix(errno);
 205         }
 206
 207         if (write_data(fd, (char *)data.dptr, data.dsize) != data.dsize) {
 208                 DEBUG(3, ("write_data failed: %s\n", strerror(errno)));
 209                 return map_nt_error_from_unix(errno);
 210         }
 211
 212         if (ftruncate(fd, data.dsize) != 0) {
 213                 DEBUG(3, ("ftruncate failed: %s\n", strerror(errno)));
 214                 return map_nt_error_from_unix(errno);
 215         }
 216
 217         return NT_STATUS_OK;
 218 }
 219
 220 static NTSTATUS db_file_store(struct db_record *rec, TDB_DATA data, int flag)
 221 {
 222         struct db_locked_file *file =
 223                 talloc_get_type_abort(rec->private_data,
 224                                       struct db_locked_file);
 225         NTSTATUS status;
 226
 227         become_root();
 228         status = db_file_store_root(file->fd, data);
 229         unbecome_root();
 230
 231         return status;
 232 }
 233
 234 static NTSTATUS db_file_delete(struct db_record *rec)
 235 {
 236         struct db_locked_file *file =
 237                 talloc_get_type_abort(rec->private_data,
 238                                       struct db_locked_file);
 239         int res;
 240
 241         become_root();
 242         res = unlink(file->path);
 243         unbecome_root();
 244
 245         if (res == -1) {
 246                 DEBUG(3, ("unlink(%s) failed: %s\n", file->path,
 247                           strerror(errno)));
 248                 return map_nt_error_from_unix(errno);
 249         }
 250
 251         return NT_STATUS_OK;
 252 }
 253
 254 static int db_file_traverse(struct db_context *db,
 255                             int (*fn)(struct db_record *rec,
 256                                       void *private_data),
 257                             void *private_data)
 258 {
 259         struct db_file_ctx *ctx = talloc_get_type_abort(db->private_data,
 260                                                         struct db_file_ctx);
 261         TALLOC_CTX *mem_ctx = talloc_init("traversal %s\n", ctx->dirname);
 262
 263         int i;
 264         int count = 0;
 265
 266         for (i=0; i<256; i++) {
 267                 const char *dirname = talloc_asprintf(mem_ctx, "%s/%2.2X",
 268                                                       ctx->dirname, i);
 269                 DIR *dir;
 270                 struct dirent *dirent;
 271
 272                 if (dirname == NULL) {
 273                         DEBUG(0, ("talloc failed\n"));
 274                         TALLOC_FREE(mem_ctx);
 275                         return -1;
 276                 }
 277
 278                 dir = opendir(dirname);
 279                 if (dir == NULL) {
 280                         DEBUG(3, ("Could not open dir %s: %s\n", dirname,
 281                                   strerror(errno)));
 282                         TALLOC_FREE(mem_ctx);
 283                         return -1;
 284                 }
 285
 286                 while ((dirent = readdir(dir)) != NULL) {
 287                         DATA_BLOB keyblob;
 288                         TDB_DATA key;
 289                         struct db_record *rec;
 290
 291                         if ((dirent->d_name[0] == '.') &&
 292                             ((dirent->d_name[1] == '\0') ||
 293                              ((dirent->d_name[1] == '.') &&
 294                               (dirent->d_name[2] == '\0')))) {
 295                                 continue;
 296                         }
 297
 298                         keyblob = strhex_to_data_blob(mem_ctx, dirent->d_name);
 299                         if (keyblob.data == NULL) {
 300                                 DEBUG(5, ("strhex_to_data_blob failed\n"));
 301                                 continue;
 302                         }
 303
 304                         key.dptr = keyblob.data;
 305                         key.dsize = keyblob.length;
 306
 307                         if ((ctx->locked_record != NULL) &&
 308                             (key.dsize == ctx->locked_record->key.dsize) &&
 309                             (memcmp(key.dptr, ctx->locked_record->key.dptr,
 310                                     key.dsize) == 0)) {
 311                                 count += 1;
 312                                 if (fn(ctx->locked_record,
 313                                        private_data) != 0) {
 314                                         TALLOC_FREE(mem_ctx);
 315                                         closedir(dir);
 316                                         return count;
 317                                 }
 318                         }
 319
 320                         rec = db_file_fetch_locked(db, mem_ctx, key);
 321                         if (rec == NULL) {
 322                                 /* Someone might have deleted it */
 323                                 continue;
 324                         }
 325
 326                         if (rec->value.dptr == NULL) {
 327                                 TALLOC_FREE(rec);
 328                                 continue;
 329                         }
 330
 331                         count += 1;
 332
 333                         if (fn(rec, private_data) != 0) {
 334                                 TALLOC_FREE(mem_ctx);
 335                                 closedir(dir);
 336                                 return count;
 337                         }
 338                         TALLOC_FREE(rec);
 339                 }
 340
 341                 closedir(dir);
 342         }
 343
 344         TALLOC_FREE(mem_ctx);
 345         return count;
 346 }
 347
 348 struct db_context *db_open_file(TALLOC_CTX *mem_ctx,
 349                                 const char *name,
 350                                 int tdb_flags,
 351                                 int open_flags, mode_t mode)
 352 {
 353         struct db_context *result = NULL;
 354         struct db_file_ctx *ctx;
 355
 356         if (!(result = talloc_zero(mem_ctx, struct db_context))) {
 357                 DEBUG(0, ("talloc failed\n"));
 358                 return NULL;
 359         }
 360
 361         if (!(ctx = talloc(result, struct db_file_ctx))) {
 362                 DEBUG(0, ("talloc failed\n"));
 363                 TALLOC_FREE(result);
 364                 return NULL;
 365         }
 366
 367         result->private_data = ctx;
 368         result->fetch_locked = db_file_fetch_locked;
 369         result->try_fetch_locked = NULL;
 370         result->traverse = db_file_traverse;
 371         result->traverse_read = db_file_traverse;
 372         result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0);
 373         result->hash_size = 0;
 374         result->name = talloc_strdup(result, name);
 375         if (result->name == NULL) {
 376                 DEBUG(0, ("talloc failed\n"));
 377                 TALLOC_FREE(result);
 378                 return NULL;
 379         }
 380
 381         ctx->locked_record = NULL;
 382         if (!(ctx->dirname = talloc_strdup(ctx, name))) {
 383                 DEBUG(0, ("talloc failed\n"));
 384                 TALLOC_FREE(result);
 385                 return NULL;
 386         }
 387
 388         if (open_flags & O_CREAT) {
 389                 int ret, i;
 390
 391                 mode |= (mode & S_IRUSR) ? S_IXUSR : 0;
 392                 mode |= (mode & S_IRGRP) ? S_IXGRP : 0;
 393                 mode |= (mode & S_IROTH) ? S_IXOTH : 0;
 394
 395                 ret = mkdir(name, mode);
 396                 if ((ret != 0) && (errno != EEXIST)) {
 397                         DEBUG(5, ("mkdir(%s,%o) failed: %s\n", name, mode,
 398                                   strerror(errno)));
 399                         TALLOC_FREE(result);
 400                         return NULL;
 401                 }
 402
 403                 for (i=0; i<256; i++) {
 404                         char *path;
 405                         path = talloc_asprintf(result, "%s/%2.2X", name, i);
 406                         if (path == NULL) {
 407                                 DEBUG(0, ("asprintf failed\n"));
 408                                 TALLOC_FREE(result);
 409                                 return NULL;
 410                         }
 411                         ret = mkdir(path, mode);
 412                         if ((ret != 0) && (errno != EEXIST)) {
 413                                 DEBUG(5, ("mkdir(%s,%o) failed: %s\n", path,
 414                                           mode, strerror(errno)));
 415                                 TALLOC_FREE(result);
 416                                 return NULL;
 417                         }
 418                         TALLOC_FREE(path);
 419                 }
 420         }
 421
 422         return result;
 423 }