etc/cnid_dbd/cmd_dbd_scanvol.c

   1 /*
   2   Copyright (c) 2009 Frank Lahm <franklahm@gmail.com>
   3
   4   This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation; either version 2 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU General Public License for more details.
  13 */
  14
  15 #ifdef HAVE_CONFIG_H
  16 #include "config.h"
  17 #endif /* HAVE_CONFIG_H */
  18
  19 #include <unistd.h>
  20 #include <stdlib.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <dirent.h>
  24 #include <fcntl.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <setjmp.h>
  28
  29 #include <atalk/adouble.h>
  30 #include <atalk/unicode.h>
  31 #include <atalk/volinfo.h>
  32 #include <atalk/cnid_dbd_private.h>
  33 #include <atalk/volume.h>
  34 #include <atalk/ea.h>
  35 #include <atalk/util.h>
  36 #include <atalk/acl.h>
  37 #include <atalk/compat.h>
  38
  39 #include "cmd_dbd.h"
  40 #include "dbif.h"
  41 #include "db_param.h"
  42 #include "dbd.h"
  43
  44 /* Some defines to ease code parsing */
  45 #define ADDIR_OK (addir_ok == 0)
  46 #define ADFILE_OK (adfile_ok == 0)
  47
  48
  49 static struct volinfo *myvolinfo;
  50 static char           cwdbuf[MAXPATHLEN+1];
  51 static DBD            *dbd;
  52 static DBD            *dbd_rebuild;
  53 static dbd_flags_t    dbd_flags;
  54 static char           stamp[CNID_DEV_LEN];
  55 static char           *netatalk_dirs[] = {
  56     ".AppleDB",
  57     ".AppleDesktop",
  58     NULL
  59 };
  60 static char           *special_dirs[] = {
  61     ".zfs",
  62     NULL
  63 };
  64 static struct cnid_dbd_rqst rqst;
  65 static struct cnid_dbd_rply rply;
  66 static jmp_buf jmp;
  67 static struct vol volume; /* fake it for ea_open */
  68 static char pname[MAXPATHLEN] = "../";
  69
  70 /*
  71   Taken form afpd/desktop.c
  72 */
  73 static char *utompath(char *upath)
  74 {
  75     static char  mpath[ MAXPATHLEN + 2]; /* for convert_charset dest_len parameter +2 */
  76     char         *m, *u;
  77     uint16_t     flags = CONV_IGNORE | CONV_UNESCAPEHEX;
  78     size_t       outlen;
  79
  80     if (!upath)
  81         return NULL;
  82
  83     m = mpath;
  84     u = upath;
  85     outlen = strlen(upath);
  86
  87     if ((myvolinfo->v_casefold & AFPVOL_UTOMUPPER))
  88         flags |= CONV_TOUPPER;
  89     else if ((myvolinfo->v_casefold & AFPVOL_UTOMLOWER))
  90         flags |= CONV_TOLOWER;
  91
  92     if ((myvolinfo->v_flags & AFPVOL_EILSEQ)) {
  93         flags |= CONV__EILSEQ;
  94     }
  95
  96     /* convert charsets */
  97     if ((size_t)-1 == ( outlen = convert_charset(myvolinfo->v_volcharset,
  98                                                  CH_UTF8_MAC,
  99                                                  myvolinfo->v_maccharset,
 100                                                  u, outlen, mpath, MAXPATHLEN, &flags)) ) {
 101         dbd_log( LOGSTD, "Conversion from %s to %s for %s failed.",
 102                  myvolinfo->v_volcodepage, myvolinfo->v_maccodepage, u);
 103         return NULL;
 104     }
 105
 106     return(m);
 107 }
 108
 109 /*
 110   Taken form afpd/desktop.c
 111 */
 112 static char *mtoupath(char *mpath)
 113 {
 114     static char  upath[ MAXPATHLEN + 2]; /* for convert_charset dest_len parameter +2 */
 115     char    *m, *u;
 116     size_t       inplen;
 117     size_t       outlen;
 118     u_int16_t    flags = 0;
 119
 120     if (!mpath)
 121         return NULL;
 122
 123     if ( *mpath == '\0' ) {
 124         return( "." );
 125     }
 126
 127     /* set conversion flags */
 128     if (!(myvolinfo->v_flags & AFPVOL_NOHEX))
 129         flags |= CONV_ESCAPEHEX;
 130     if (!(myvolinfo->v_flags & AFPVOL_USEDOTS))
 131         flags |= CONV_ESCAPEDOTS;
 132
 133     if ((myvolinfo->v_casefold & AFPVOL_MTOUUPPER))
 134         flags |= CONV_TOUPPER;
 135     else if ((myvolinfo->v_casefold & AFPVOL_MTOULOWER))
 136         flags |= CONV_TOLOWER;
 137
 138     if ((myvolinfo->v_flags & AFPVOL_EILSEQ)) {
 139         flags |= CONV__EILSEQ;
 140     }
 141
 142     m = mpath;
 143     u = upath;
 144
 145     inplen = strlen(m);
 146     outlen = MAXPATHLEN;
 147
 148     if ((size_t)-1 == (outlen = convert_charset(CH_UTF8_MAC,
 149                                                 myvolinfo->v_volcharset,
 150                                                 myvolinfo->v_maccharset,
 151                                                 m, inplen, u, outlen, &flags)) ) {
 152         dbd_log( LOGSTD, "conversion from UTF8-MAC to %s for %s failed.",
 153                  myvolinfo->v_volcodepage, mpath);
 154         return NULL;
 155     }
 156
 157     return( upath );
 158 }
 159
 160 /*
 161   Check for wrong encoding e.g. "." at the beginning is not CAP encoded (:2e) although volume is default !AFPVOL_USEDOTS.
 162   We do it by roundtripiping from volcharset to UTF8-MAC and back and then compare the result.
 163 */
 164 static int check_name_encoding(char *uname)
 165 {
 166     char *roundtripped;
 167
 168     roundtripped = mtoupath(utompath(uname));
 169     if (!roundtripped) {
 170         dbd_log( LOGSTD, "Error checking encoding for '%s/%s'", cwdbuf, uname);
 171         return -1;
 172     }
 173
 174     if ( STRCMP(uname, !=, roundtripped)) {
 175         dbd_log( LOGSTD, "Bad encoding for '%s/%s'", cwdbuf, uname);
 176         return -1;
 177     }
 178
 179     return 0;
 180 }
 181
 182 /*
 183   Check for netatalk special folders e.g. ".AppleDB" or ".AppleDesktop"
 184   Returns pointer to name or NULL.
 185 */
 186 static const char *check_netatalk_dirs(const char *name)
 187 {
 188     int c;
 189
 190     for (c=0; netatalk_dirs[c]; c++) {
 191         if ((strcmp(name, netatalk_dirs[c])) == 0)
 192             return netatalk_dirs[c];
 193     }
 194     return NULL;
 195 }
 196
 197 /*
 198   Check for special names
 199   Returns pointer to name or NULL.
 200 */
 201 static const char *check_special_dirs(const char *name)
 202 {
 203     int c;
 204
 205     for (c=0; special_dirs[c]; c++) {
 206         if ((strcmp(name, special_dirs[c])) == 0)
 207             return special_dirs[c];
 208     }
 209     return NULL;
 210 }
 211
 212 /*
 213   Check for .AppleDouble file, create if missing
 214 */
 215 static int check_adfile(const char *fname, const struct stat *st)
 216 {
 217     int ret;
 218     int adflags = ADFLAGS_HF;
 219     struct adouble ad;
 220     const char *adname;
 221
 222     if (volume.v_adouble == AD_VERSION_EA)
 223         return 0;
 224
 225     if (dbd_flags & DBD_FLAGS_CLEANUP)
 226         return 0;
 227
 228     if (S_ISREG(st->st_mode))
 229         adflags |= ADFLAGS_DIR;
 230
 231     adname = volume.ad_path(fname, adflags);
 232
 233     if ((ret = access( adname, F_OK)) != 0) {
 234         if (errno != ENOENT) {
 235             dbd_log(LOGSTD, "Access error for ad-file '%s/%s': %s",
 236                     cwdbuf, adname, strerror(errno));
 237             return -1;
 238         }
 239         /* Missing. Log and create it */
 240         dbd_log(LOGSTD, "Missing AppleDouble file '%s/%s'", cwdbuf, adname);
 241
 242         if (dbd_flags & DBD_FLAGS_SCAN)
 243             /* Scan only requested, dont change anything */
 244             return -1;
 245
 246         /* Create ad file */
 247         ad_init(&ad, &volume);
 248
 249         if ((ret = ad_open(&ad, fname, adflags | ADFLAGS_CREATE | ADFLAGS_RDWR, 0666)) != 0) {
 250             dbd_log( LOGSTD, "Error creating AppleDouble file '%s/%s': %s",
 251                      cwdbuf, adname, strerror(errno));
 252
 253             return -1;
 254         }
 255
 256         /* Set name in ad-file */
 257         ad_setname(&ad, utompath((char *)fname));
 258         ad_flush(&ad);
 259         ad_close(&ad, ADFLAGS_HF);
 260
 261         chown(adname, st->st_uid, st->st_gid);
 262         /* FIXME: should we inherit mode too here ? */
 263 #if 0
 264         chmod(adname, st->st_mode);
 265 #endif
 266     } else {
 267         ad_init(&ad, &volume);
 268         if (ad_open(&ad, fname, adflags | ADFLAGS_RDONLY) != 0) {
 269             dbd_log( LOGSTD, "Error opening AppleDouble file for '%s/%s'", cwdbuf, fname);
 270             return -1;
 271         }
 272         ad_close(&ad, ADFLAGS_HF);
 273     }
 274     return 0;
 275 }
 276
 277 /*
 278    Remove all files with file::EA* from adouble dir
 279 */
 280 static void remove_eafiles(const char *name, struct ea *ea)
 281 {
 282     DIR *dp = NULL;
 283     struct dirent *ep;
 284     char eaname[MAXPATHLEN];
 285
 286     strlcpy(eaname, name, sizeof(eaname));
 287     if (strlcat(eaname, "::EA", sizeof(eaname)) >= sizeof(eaname)) {
 288         dbd_log(LOGSTD, "name too long: '%s/%s/%s'", cwdbuf, ADv2_DIRNAME, name);
 289         return;
 290     }
 291
 292     if ((chdir(ADv2_DIRNAME)) != 0) {
 293         dbd_log(LOGSTD, "Couldn't chdir to '%s/%s': %s",
 294                 cwdbuf, ADv2_DIRNAME, strerror(errno));
 295         return;
 296     }
 297
 298     if ((dp = opendir(".")) == NULL) {
 299         dbd_log(LOGSTD, "Couldn't open the directory '%s/%s': %s",
 300                 cwdbuf, ADv2_DIRNAME, strerror(errno));
 301         goto exit;
 302     }
 303
 304     while ((ep = readdir(dp))) {
 305         if (strstr(ep->d_name, eaname) != NULL) {
 306             dbd_log(LOGSTD, "Removing EA file: '%s/%s/%s'",
 307                     cwdbuf, ADv2_DIRNAME, ep->d_name);
 308             if ((unlink(ep->d_name)) != 0) {
 309                 dbd_log(LOGSTD, "Error unlinking EA file '%s/%s/%s': %s",
 310                         cwdbuf, ADv2_DIRNAME, ep->d_name, strerror(errno));
 311             }
 312         } /* if */
 313     } /* while */
 314
 315 exit:
 316     if (dp)
 317         closedir(dp);
 318     if ((chdir("..")) != 0) {
 319         dbd_log(LOGSTD, "Couldn't chdir to '%s': %s", cwdbuf, strerror(errno));
 320         /* we can't proceed */
 321         longjmp(jmp, 1); /* this jumps back to cmd_dbd_scanvol() */
 322     }
 323 }
 324
 325 /*
 326   Check Extended Attributes files
 327 */
 328 static int check_eafiles(const char *fname)
 329 {
 330     unsigned int  count = 0;
 331     int ret = 0, remove;
 332     struct ea ea;
 333     struct stat st;
 334     char *eaname;
 335
 336     if ((ret = ea_open(&volume, fname, EA_RDWR, &ea)) != 0) {
 337         if (errno == ENOENT)
 338             return 0;
 339         dbd_log(LOGSTD, "Error calling ea_open for file: %s/%s, removing EA files", cwdbuf, fname);
 340         if ( ! (dbd_flags & DBD_FLAGS_SCAN))
 341             remove_eafiles(fname, &ea);
 342         return -1;
 343     }
 344
 345     /* Check all EAs */
 346     while (count < ea.ea_count) {
 347         dbd_log(LOGDEBUG, "EA: %s", (*ea.ea_entries)[count].ea_name);
 348         remove = 0;
 349
 350         eaname = ea_path(&ea, (*ea.ea_entries)[count].ea_name, 0);
 351
 352         if (lstat(eaname, &st) != 0) {
 353             if (errno == ENOENT)
 354                 dbd_log(LOGSTD, "Missing EA: %s/%s", cwdbuf, eaname);
 355             else
 356                 dbd_log(LOGSTD, "Bogus EA: %s/%s", cwdbuf, eaname);
 357             remove = 1;
 358         } else if (st.st_size != (*ea.ea_entries)[count].ea_size) {
 359             dbd_log(LOGSTD, "Bogus EA: %s/%s, removing it...", cwdbuf, eaname);
 360             remove = 1;
 361             if ((unlink(eaname)) != 0)
 362                 dbd_log(LOGSTD, "Error removing EA file '%s/%s': %s",
 363                         cwdbuf, eaname, strerror(errno));
 364         }
 365
 366         if (remove) {
 367             /* Be CAREFUL here! This should do what ea_delentry does. ea_close relies on it !*/
 368             free((*ea.ea_entries)[count].ea_name);
 369             (*ea.ea_entries)[count].ea_name = NULL;
 370         }
 371
 372         count++;
 373     } /* while */
 374
 375     ea_close(&ea);
 376     return ret;
 377 }
 378
 379 /*
 380   Check for .AppleDouble folder and .Parent, create if missing
 381 */
 382 static int check_addir(int volroot)
 383 {
 384     int addir_ok, adpar_ok;
 385     struct stat st;
 386     struct adouble ad;
 387     char *mname = NULL;
 388
 389     if (dbd_flags & DBD_FLAGS_CLEANUP)
 390         return 0;
 391
 392     if (volume.v_adouble == AD_VERSION_EA)
 393         return 0;
 394
 395     /* Check for ad-dir */
 396     if ( (addir_ok = access(ADv2_DIRNAME, F_OK)) != 0) {
 397         if (errno != ENOENT) {
 398             dbd_log(LOGSTD, "Access error in directory %s: %s", cwdbuf, strerror(errno));
 399             return -1;
 400         }
 401         dbd_log(LOGSTD, "Missing %s for '%s'", ADv2_DIRNAME, cwdbuf);
 402     }
 403
 404     /* Check for ".Parent" */
 405     if ( (adpar_ok = access(volume.ad_path(".", ADFLAGS_DIR), F_OK)) != 0) {
 406         if (errno != ENOENT) {
 407             dbd_log(LOGSTD, "Access error on '%s/%s': %s",
 408                     cwdbuf, volume.ad_path(".", ADFLAGS_DIR), strerror(errno));
 409             return -1;
 410         }
 411         dbd_log(LOGSTD, "Missing .AppleDouble/.Parent for '%s'", cwdbuf);
 412     }
 413
 414     /* Is one missing ? */
 415     if ((addir_ok != 0) || (adpar_ok != 0)) {
 416         /* Yes, but are we only scanning ? */
 417         if (dbd_flags & DBD_FLAGS_SCAN) {
 418             /* Yes:  missing .Parent is not a problem, but missing ad-dir
 419                causes later checking of ad-files to fail. So we have to return appropiately */
 420             if (addir_ok != 0)
 421                 return -1;
 422             else  /* (adpar_ok != 0) */
 423                 return 0;
 424         }
 425
 426         /* Create ad dir and set name */
 427         ad_init(&ad, &volume);
 428
 429         if (ad_open(&ad, ".", ADFLAGS_HF | ADFLAGS_DIR | ADFLAGS_CREATE | ADFLAGS_RDWR, 0777) != 0) {
 430             dbd_log( LOGSTD, "Error creating AppleDouble dir in %s: %s", cwdbuf, strerror(errno));
 431             return -1;
 432         }
 433
 434         /* Get basename of cwd from cwdbuf */
 435         mname = utompath(strrchr(cwdbuf, '/') + 1);
 436
 437         /* Update name in ad file */
 438         ad_setname(&ad, mname);
 439         ad_flush(&ad);
 440         ad_close(&ad, ADFLAGS_HF);
 441
 442         /* Inherit owner/group from "." to ".AppleDouble" and ".Parent" */
 443         if ((lstat(".", &st)) != 0) {
 444             dbd_log( LOGSTD, "Couldnt stat %s: %s", cwdbuf, strerror(errno));
 445             return -1;
 446         }
 447         chown(ADv2_DIRNAME, st.st_uid, st.st_gid);
 448         chown(volume.ad_path(".", ADFLAGS_DIR), st.st_uid, st.st_gid);
 449     }
 450
 451     return 0;
 452 }
 453
 454 /*
 455   Check if file cotains "::EA" and if it does check if its correspondig data fork exists.
 456   Returns:
 457   0 = name is not an EA file
 458   1 = name is an EA file and no problem was found
 459   -1 = name is an EA file and data fork is gone
 460  */
 461 static int check_eafile_in_adouble(const char *name)
 462 {
 463     int ret = 0;
 464     char *namep, *namedup = NULL;
 465
 466     /* Check if this is an AFPVOL_EA_AD vol */
 467     if (myvolinfo->v_vfs_ea == AFPVOL_EA_AD) {
 468         /* Does the filename contain "::EA" ? */
 469         namedup = strdup(name);
 470         if ((namep = strstr(namedup, "::EA")) == NULL) {
 471             ret = 0;
 472             goto ea_check_done;
 473         } else {
 474             /* File contains "::EA" so it's an EA file. Check for data file  */
 475
 476             /* Get string before "::EA" from EA filename */
 477             namep[0] = 0;
 478             strlcpy(pname + 3, namedup, sizeof(pname)); /* Prepends "../" */
 479
 480             if ((access( pname, F_OK)) == 0) {
 481                 ret = 1;
 482                 goto ea_check_done;
 483             } else {
 484                 ret = -1;
 485                 if (errno != ENOENT) {
 486                     dbd_log(LOGSTD, "Access error for file '%s/%s': %s",
 487                             cwdbuf, name, strerror(errno));
 488                     goto ea_check_done;
 489                 }
 490
 491                 /* Orphaned EA file*/
 492                 dbd_log(LOGSTD, "Orphaned Extended Attribute file '%s/%s/%s'",
 493                         cwdbuf, ADv2_DIRNAME, name);
 494
 495                 if (dbd_flags & DBD_FLAGS_SCAN)
 496                     /* Scan only requested, dont change anything */
 497                     goto ea_check_done;
 498
 499                 if ((unlink(name)) != 0) {
 500                     dbd_log(LOGSTD, "Error unlinking orphaned Extended Attribute file '%s/%s/%s'",
 501                             cwdbuf, ADv2_DIRNAME, name);
 502                 }
 503             } /* if (access) */
 504         } /* if strstr */
 505     } /* if AFPVOL_EA_AD */
 506
 507 ea_check_done:
 508     if (namedup)
 509         free(namedup);
 510
 511     return ret;
 512 }
 513
 514 /*
 515   Check files and dirs inside .AppleDouble folder:
 516   - remove orphaned files
 517   - bail on dirs
 518 */
 519 static int read_addir(void)
 520 {
 521     DIR *dp;
 522     struct dirent *ep;
 523     struct stat st;
 524
 525     if (volume.v_adouble == AD_VERSION_EA)
 526         return 0;
 527
 528     if ((chdir(ADv2_DIRNAME)) != 0) {
 529         dbd_log(LOGSTD, "Couldn't chdir to '%s/%s': %s",
 530                 cwdbuf, ADv2_DIRNAME, strerror(errno));
 531         return -1;
 532     }
 533
 534     if ((dp = opendir(".")) == NULL) {
 535         dbd_log(LOGSTD, "Couldn't open the directory '%s/%s': %s",
 536                 cwdbuf, ADv2_DIRNAME, strerror(errno));
 537         return -1;
 538     }
 539
 540     while ((ep = readdir(dp))) {
 541         /* Check if its "." or ".." */
 542         if (DIR_DOT_OR_DOTDOT(ep->d_name))
 543             continue;
 544
 545         /* Skip ".Parent" */
 546         if (STRCMP(ep->d_name, ==, ".Parent"))
 547             continue;
 548
 549         if ((lstat(ep->d_name, &st)) < 0) {
 550             dbd_log( LOGSTD, "Lost file or dir while enumeratin dir '%s/%s/%s', probably removed: %s",
 551                      cwdbuf, ADv2_DIRNAME, ep->d_name, strerror(errno));
 552             continue;
 553         }
 554
 555         /* Check for dirs */
 556         if (S_ISDIR(st.st_mode)) {
 557             dbd_log( LOGSTD, "Unexpected directory '%s' in AppleDouble dir '%s/%s'",
 558                      ep->d_name, cwdbuf, ADv2_DIRNAME);
 559             continue;
 560         }
 561
 562         /* Check if for orphaned and corrupt Extended Attributes file */
 563         if (check_eafile_in_adouble(ep->d_name) != 0)
 564             continue;
 565
 566         /* Check for data file */
 567         strcpy(pname + 3, ep->d_name);
 568         if ((access( pname, F_OK)) != 0) {
 569             if (errno != ENOENT) {
 570                 dbd_log(LOGSTD, "Access error for file '%s/%s': %s",
 571                         cwdbuf, pname, strerror(errno));
 572                 continue;
 573             }
 574             /* Orphaned ad-file*/
 575             dbd_log(LOGSTD, "Orphaned AppleDoube file '%s/%s/%s'",
 576                     cwdbuf, ADv2_DIRNAME, ep->d_name);
 577
 578             if (dbd_flags & DBD_FLAGS_SCAN)
 579                 /* Scan only requested, dont change anything */
 580                 continue;;
 581
 582             if ((unlink(ep->d_name)) != 0) {
 583                 dbd_log(LOGSTD, "Error unlinking orphaned AppleDoube file '%s/%s/%s'",
 584                         cwdbuf, ADv2_DIRNAME, ep->d_name);
 585
 586             }
 587         }
 588     }
 589
 590     if ((chdir("..")) != 0) {
 591         dbd_log(LOGSTD, "Couldn't chdir back to '%s' from AppleDouble dir: %s",
 592                 cwdbuf, strerror(errno));
 593         /* This really is EOT! */
 594         longjmp(jmp, 1); /* this jumps back to cmd_dbd_scanvol() */
 595     }
 596
 597     closedir(dp);
 598
 599     return 0;
 600 }
 601
 602 /*
 603   Check CNID for a file/dir, both from db and from ad-file.
 604   For detailed specs see intro.
 605
 606   @return Correct CNID of object or CNID_INVALID (ie 0) on error
 607 */
 608 static cnid_t check_cnid(const char *name, cnid_t did, struct stat *st, int adfile_ok)
 609 {
 610     int ret, adflags = ADFLAGS_HF;
 611     cnid_t db_cnid, ad_cnid;
 612     struct adouble ad;
 613
 614     adflags = ADFLAGS_HF | (S_ISDIR(st->st_mode) ? ADFLAGS_DIR : 0);
 615
 616     /* Force checkout every X items */
 617     static int cnidcount = 0;
 618     cnidcount++;
 619     if (cnidcount > 10000) {
 620         cnidcount = 0;
 621         if (dbif_txn_checkpoint(dbd, 0, 0, 0) < 0) {
 622             dbd_log(LOGSTD, "Error checkpointing!");
 623             return CNID_INVALID;
 624         }
 625     }
 626
 627     /* Get CNID from ad-file */
 628     ad_cnid = 0;
 629     if (ADFILE_OK) {
 630         ad_init(&ad, &volume);
 631         if (ad_open(&ad, name, adflags | ADFLAGS_RDWR) != 0) {
 632
 633             if (dbd_flags & DBD_FLAGS_CLEANUP)
 634                 return CNID_INVALID;
 635
 636             if (volume.v_adouble != AD_VERSION_EA) {
 637                 dbd_log( LOGSTD, "Error opening AppleDouble file for '%s/%s': %s", cwdbuf, name, strerror(errno));
 638                 return CNID_INVALID;
 639             }
 640             dbd_log( LOGDEBUG, "File without meta EA: \"%s/%s\"", cwdbuf, name);
 641         } else {
 642
 643             if (dbd_flags & DBD_FLAGS_FORCE) {
 644                 ad_cnid = ad_forcegetid(&ad);
 645                 /* This ensures the changed stamp is written */
 646                 ad_setid( &ad, st->st_dev, st->st_ino, ad_cnid, did, stamp);
 647                 ad_flush(&ad);
 648             } else
 649                 ad_cnid = ad_getid(&ad, st->st_dev, st->st_ino, 0, stamp);
 650
 651             if (ad_cnid == 0)
 652                 dbd_log( LOGSTD, "Bad CNID in adouble file of '%s/%s'", cwdbuf, name);
 653             else
 654                 dbd_log( LOGDEBUG, "CNID from .AppleDouble file for '%s/%s': %u", cwdbuf, name, ntohl(ad_cnid));
 655             ad_close(&ad, ADFLAGS_HF);
 656         }
 657     }
 658
 659     /* Get CNID from database */
 660
 661     /* Prepare request data */
 662     memset(&rqst, 0, sizeof(struct cnid_dbd_rqst));
 663     memset(&rply, 0, sizeof(struct cnid_dbd_rply));
 664     rqst.did = did;
 665     rqst.cnid = ad_cnid;
 666     if ( ! (myvolinfo->v_flags & AFPVOL_NODEV))
 667         rqst.dev = st->st_dev;
 668     rqst.ino = st->st_ino;
 669     rqst.type = S_ISDIR(st->st_mode)?1:0;
 670     rqst.name = (char *)name;
 671     rqst.namelen = strlen(name);
 672
 673     /* Query the database */
 674     ret = dbd_lookup(dbd, &rqst, &rply, (dbd_flags & DBD_FLAGS_SCAN) ? 1 : 0);
 675     if (dbif_txn_close(dbd, ret) != 0)
 676         return CNID_INVALID;
 677     if (rply.result == CNID_DBD_RES_OK) {
 678         db_cnid = rply.cnid;
 679     } else if (rply.result == CNID_DBD_RES_NOTFOUND) {
 680         if ( ! (dbd_flags & DBD_FLAGS_FORCE))
 681             dbd_log( LOGSTD, "No CNID for '%s/%s' in database", cwdbuf, name);
 682         db_cnid = 0;
 683     } else {
 684         dbd_log( LOGSTD, "Fatal error resolving '%s/%s'", cwdbuf, name);
 685         db_cnid = 0;
 686     }
 687
 688     /* Compare results from both CNID searches */
 689     if (ad_cnid && db_cnid && (ad_cnid == db_cnid)) {
 690         /* Everything is fine */
 691         return db_cnid;
 692     } else if (ad_cnid && db_cnid && (ad_cnid != db_cnid)) {
 693         /* Mismatch, overwrite ad file with value from db */
 694         dbd_log( LOGSTD, "CNID mismatch for '%s/%s', db: %u, ad-file: %u", cwdbuf, name, ntohl(db_cnid), ntohl(ad_cnid));
 695         if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
 696             dbd_log(LOGSTD, "Updating AppleDouble file for '%s/%s' with CNID: %u from database",
 697                             cwdbuf, name, ntohl(db_cnid));
 698             ad_init(&ad, &volume);
 699             if (ad_open(&ad, name, adflags | ADFLAGS_HF | ADFLAGS_RDWR) != 0) {
 700                 dbd_log(LOGSTD, "Error opening AppleDouble file for '%s/%s': %s",
 701                         cwdbuf, name, strerror(errno));
 702                 return CNID_INVALID;
 703             }
 704             ad_setid( &ad, st->st_dev, st->st_ino, db_cnid, did, stamp);
 705             ad_flush(&ad);
 706             ad_close(&ad, ADFLAGS_HF);
 707         }
 708         return db_cnid;
 709     } else if (ad_cnid && (db_cnid == 0)) {
 710         /* in ad-file but not in db */
 711         if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
 712             /* Ensure the cnid from the ad-file is not already occupied by another file */
 713             dbd_log(LOGDEBUG, "Checking whether CNID %u from ad-file is occupied",
 714                     ntohl(ad_cnid));
 715
 716             rqst.cnid = ad_cnid;
 717             ret = dbd_resolve(dbd, &rqst, &rply);
 718             if (rply.result == CNID_DBD_RES_OK) {
 719                 /* Occupied! Choose another, update ad-file */
 720                 ret = dbd_add(dbd, &rqst, &rply, 1);
 721                 if (dbif_txn_close(dbd, ret) != 0)
 722                     return CNID_INVALID;
 723                 db_cnid = rply.cnid;
 724                 dbd_log(LOGSTD, "New CNID for '%s/%s': %u", cwdbuf, name, ntohl(db_cnid));
 725
 726                 if (ADFILE_OK && ( ! (dbd_flags & DBD_FLAGS_SCAN))) {
 727                     dbd_log(LOGSTD, "Writing CNID data for '%s/%s' to AppleDouble file",
 728                             cwdbuf, name, ntohl(db_cnid));
 729                     ad_init(&ad, &volume);
 730                     if (ad_open(&ad, name, adflags | ADFLAGS_RDWR) != 0) {
 731                         dbd_log(LOGSTD, "Error opening AppleDouble file for '%s/%s': %s",
 732                                 cwdbuf, name, strerror(errno));
 733                         return CNID_INVALID;
 734                     }
 735                     ad_setid( &ad, st->st_dev, st->st_ino, db_cnid, did, stamp);
 736                     ad_flush(&ad);
 737                     ad_close(&ad, ADFLAGS_HF);
 738                 }
 739                 return db_cnid;
 740             }
 741
 742             dbd_log(LOGDEBUG, "CNID rebuild add '%s/%s' with CNID from ad-file %u",
 743                     cwdbuf, name, ntohl(ad_cnid));
 744             rqst.cnid = ad_cnid;
 745             ret = dbd_rebuild_add(dbd, &rqst, &rply);
 746             if (dbif_txn_close(dbd, ret) != 0)
 747                 return CNID_INVALID;
 748         }
 749         return ad_cnid;
 750     } else if ((db_cnid == 0) && (ad_cnid == 0)) {
 751         /* No CNID at all, we clearly have to allocate a fresh one... */
 752         /* Note: the next test will use this new CNID too! */
 753         if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
 754             /* add to db */
 755             ret = dbd_add(dbd, &rqst, &rply, 1);
 756             if (dbif_txn_close(dbd, ret) != 0)
 757                 return CNID_INVALID;
 758             db_cnid = rply.cnid;
 759             dbd_log(LOGSTD, "New CNID for '%s/%s': %u", cwdbuf, name, ntohl(db_cnid));
 760         }
 761     }
 762
 763     if ((ad_cnid == 0) && db_cnid) {
 764         /* in db but zeroID in ad-file, write it to ad-file */
 765         if (ADFILE_OK
 766             && (volume.v_adouble == AD_VERSION2)
 767             && ! (dbd_flags & DBD_FLAGS_SCAN)) {
 768             dbd_log(LOGSTD, "Writing CNID data for '%s/%s' to AppleDouble file",
 769                     cwdbuf, name, ntohl(db_cnid));
 770             ad_init(&ad, &volume);
 771             if (ad_open(&ad, name, adflags | ADFLAGS_RDWR) != 0) {
 772                 dbd_log(LOGSTD, "Error opening AppleDouble file for '%s/%s': %s",
 773                         cwdbuf, name, strerror(errno));
 774                 return CNID_INVALID;
 775             }
 776             ad_setid( &ad, st->st_dev, st->st_ino, db_cnid, did, stamp);
 777             ad_flush(&ad);
 778             ad_close(&ad, ADFLAGS_HF);
 779         }
 780         return db_cnid;
 781     }
 782
 783     return CNID_INVALID;
 784 }
 785
 786 /*
 787   This is called recursively for all dirs.
 788   volroot=1 means we're in the volume root dir, 0 means we aren't.
 789   We use this when checking for netatalk private folders like .AppleDB.
 790   did is our parents CNID.
 791 */
 792 static int dbd_readdir(int volroot, cnid_t did)
 793 {
 794     int cwd, ret = 0, adfile_ok, addir_ok, encoding_ok;
 795     cnid_t cnid = 0;
 796     const char *name;
 797     DIR *dp;
 798     struct dirent *ep;
 799     static struct stat st;      /* Save some stack space */
 800
 801     /* Check again for .AppleDouble folder, check_adfile also checks/creates it */
 802     if ((addir_ok = check_addir(volroot)) != 0)
 803         if ( ! (dbd_flags & DBD_FLAGS_SCAN))
 804             /* Fatal on rebuild run, continue if only scanning ! */
 805             return -1;
 806
 807     /* Check AppleDouble files in AppleDouble folder, but only if it exists or could be created */
 808     if (volume.v_adouble == AD_VERSION2 && ADDIR_OK)
 809         if ((read_addir()) != 0)
 810             if ( ! (dbd_flags & DBD_FLAGS_SCAN))
 811                 /* Fatal on rebuild run, continue if only scanning ! */
 812                 return -1;
 813
 814     if ((dp = opendir (".")) == NULL) {
 815         dbd_log(LOGSTD, "Couldn't open the directory: %s",strerror(errno));
 816         return -1;
 817     }
 818
 819     while ((ep = readdir (dp))) {
 820         /* Check if we got a termination signal */
 821         if (alarmed)
 822             longjmp(jmp, 1); /* this jumps back to cmd_dbd_scanvol() */
 823
 824         /* Check if its "." or ".." */
 825         if (DIR_DOT_OR_DOTDOT(ep->d_name))
 826             continue;
 827
 828         /* Check for netatalk special folders e.g. ".AppleDB" or ".AppleDesktop" */
 829         if ((name = check_netatalk_dirs(ep->d_name)) != NULL) {
 830             if (! volroot)
 831                 dbd_log(LOGSTD, "Nested %s in %s", name, cwdbuf);
 832             continue;
 833         }
 834
 835         /* Check for special folders in volume root e.g. ".zfs" */
 836         if (volroot) {
 837             if ((name = check_special_dirs(ep->d_name)) != NULL) {
 838                 dbd_log(LOGSTD, "Ignoring special dir \"%s\"", name);
 839                 continue;
 840             }
 841         }
 842
 843         /* Skip .AppleDouble dir in this loop */
 844         if (STRCMP(ep->d_name, == , ADv2_DIRNAME))
 845             continue;
 846
 847         if ((ret = lstat(ep->d_name, &st)) < 0) {
 848             dbd_log( LOGSTD, "Lost file while reading dir '%s/%s', probably removed: %s",
 849                      cwdbuf, ep->d_name, strerror(errno));
 850             continue;
 851         }
 852
 853         switch (st.st_mode & S_IFMT) {
 854         case S_IFREG:
 855         case S_IFDIR:
 856             break;
 857         case S_IFLNK:
 858             dbd_log(LOGDEBUG, "Ignoring symlink %s/%s", cwdbuf, ep->d_name);
 859             continue;
 860         default:
 861             dbd_log(LOGSTD, "Bad filetype: %s/%s", cwdbuf, ep->d_name);
 862             if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
 863                 if ((unlink(ep->d_name)) != 0) {
 864                     dbd_log(LOGSTD, "Error removing: %s/%s: %s", cwdbuf, ep->d_name, strerror(errno));
 865                 }
 866             }
 867             continue;
 868         }
 869
 870         /**************************************************************************
 871            Statistics
 872          **************************************************************************/
 873         static unsigned long long statcount = 0;
 874         static time_t t = 0;
 875
 876         if (t == 0)
 877             t = time(NULL);
 878
 879         statcount++;
 880         if ((statcount % 10000) == 0) {
 881             if (dbd_flags & DBD_FLAGS_STATS)
 882                 dbd_log(LOGSTD, "Scanned: %10llu, time: %10llu s",
 883                         statcount, (unsigned long long)(time(NULL) - t));
 884         }
 885
 886         /**************************************************************************
 887            Tests
 888         **************************************************************************/
 889
 890         /* Check encoding */
 891         if ( -1 == (encoding_ok = check_name_encoding(ep->d_name)) ) {
 892             /* If its a file: skipp all other tests now ! */
 893             /* For dirs we could try to get a CNID for it and recurse, but currently I prefer not to */
 894             continue;
 895         }
 896
 897         /* Check for appledouble file, create if missing, but only if we have addir */
 898         adfile_ok = -1;
 899         if (ADDIR_OK)
 900             adfile_ok = check_adfile(ep->d_name, &st);
 901
 902         if ( ! nocniddb) {
 903             /* Check CNIDs */
 904             cnid = check_cnid(ep->d_name, did, &st, adfile_ok);
 905
 906             /* Now add this object to our rebuild dbd */
 907             if (cnid && dbd_rebuild) {
 908                 static uint count = 0;
 909                 rqst.cnid = rply.cnid;
 910                 ret = dbd_rebuild_add(dbd_rebuild, &rqst, &rply);
 911                 if (dbif_txn_close(dbd_rebuild, ret) != 0)
 912                     return -1;
 913                 if (rply.result != CNID_DBD_RES_OK) {
 914                     dbd_log( LOGSTD, "Fatal error adding CNID: %u for '%s/%s' to in-memory rebuild-db",
 915                              cnid, cwdbuf, ep->d_name);
 916                     return -1;
 917                 }
 918                 count++;
 919                 if (count == 10000) {
 920                     if (dbif_txn_checkpoint(dbd_rebuild, 0, 0, 0) < 0) {
 921                         dbd_log(LOGSTD, "Error checkpointing!");
 922                         return -1;
 923                     }
 924                     count = 0;
 925                 }
 926             }
 927         }
 928
 929         /* Check EA files */
 930         if (myvolinfo->v_vfs_ea == AFPVOL_EA_AD)
 931             check_eafiles(ep->d_name);
 932
 933         /**************************************************************************
 934           Recursion
 935         **************************************************************************/
 936         if (S_ISDIR(st.st_mode) && (cnid || nocniddb)) { /* If we have no cnid for it we cant recur */
 937             strcat(cwdbuf, "/");
 938             strcat(cwdbuf, ep->d_name);
 939             dbd_log( LOGDEBUG, "Entering directory: %s", cwdbuf);
 940             if (-1 == (cwd = open(".", O_RDONLY))) {
 941                 dbd_log( LOGSTD, "Cant open directory '%s': %s", cwdbuf, strerror(errno));
 942                 continue;
 943             }
 944             if (0 != chdir(ep->d_name)) {
 945                 dbd_log( LOGSTD, "Cant chdir to directory '%s': %s", cwdbuf, strerror(errno));
 946                 close(cwd);
 947                 continue;
 948             }
 949
 950             ret = dbd_readdir(0, cnid);
 951
 952             fchdir(cwd);
 953             close(cwd);
 954             *(strrchr(cwdbuf, '/')) = 0;
 955             if (ret < 0)
 956                 return -1;
 957         }
 958     }
 959
 960     /*
 961       Use results of previous checks
 962     */
 963
 964     closedir(dp);
 965     return ret;
 966 }
 967
 968 static int scanvol(struct volinfo *vi, dbd_flags_t flags)
 969 {
 970     /* Make this stuff accessible from all funcs easily */
 971     myvolinfo = vi;
 972     dbd_flags = flags;
 973
 974     /* Init a fake struct vol so that we can call ad_init(.., &volume) and initvol_vfs(&volume) */
 975     volume.v_adouble = vi->v_adouble;
 976     volume.v_ad_options = vi->v_flags;
 977     volume.ad_path = vi->ad_path;
 978     volume.v_vfs_ea = myvolinfo->v_vfs_ea;
 979     initvol_vfs(&volume);
 980
 981     /* Run with umask 0 */
 982     umask(0);
 983
 984     /* Remove trailing slash from volume, chdir to vol */
 985     if (myvolinfo->v_path[strlen(myvolinfo->v_path) - 1] == '/')
 986         myvolinfo->v_path[strlen(myvolinfo->v_path) - 1] = 0;
 987     strcpy(cwdbuf, myvolinfo->v_path);
 988     chdir(myvolinfo->v_path);
 989
 990     /* Start recursion */
 991     if (dbd_readdir(1, htonl(2)) < 0)  /* 2 = volumeroot CNID */
 992         return -1;
 993
 994     return 0;
 995 }
 996
 997 /*
 998   Remove all CNIDs from dbd that are not in dbd_rebuild
 999 */
1000 static void delete_orphaned_cnids(DBD *dbd, DBD *dbd_rebuild, dbd_flags_t flags)
1001 {
1002     int ret = 0, deleted = 0;
1003     cnid_t dbd_cnid = 0, rebuild_cnid = 0;
1004     struct cnid_dbd_rqst rqst;
1005     struct cnid_dbd_rply rply;
1006
1007     /* jump over rootinfo key */
1008     if ( dbif_idwalk(dbd, &dbd_cnid, 0) != 1)
1009         return;
1010     if ( dbif_idwalk(dbd_rebuild, &rebuild_cnid, 0) != 1)
1011         return;
1012
1013     /* Get first id from dbd_rebuild */
1014     if ((dbif_idwalk(dbd_rebuild, &rebuild_cnid, 0)) == -1)
1015         return;
1016
1017     /* Start main loop through dbd: get CNID from dbd */
1018     while ((dbif_idwalk(dbd, &dbd_cnid, 0)) == 1) {
1019         /* Check if we got a termination signal */
1020         if (alarmed)
1021             longjmp(jmp, 1); /* this jumps back to cmd_dbd_scanvol() */
1022
1023         if (deleted > 1000) {
1024             deleted = 0;
1025             if (dbif_txn_checkpoint(dbd, 0, 0, 0) < 0) {
1026                 dbd_log(LOGSTD, "Error checkpointing!");
1027                 goto cleanup;
1028             }
1029         }
1030
1031         /* This should be the normal case: CNID is in both dbs */
1032         if (dbd_cnid == rebuild_cnid) {
1033             /* Get next CNID from rebuild db */
1034             if ((ret = dbif_idwalk(dbd_rebuild, &rebuild_cnid, 0)) == -1) {
1035                 /* Some error */
1036                 goto cleanup;
1037             } else if (ret == 0) {
1038                 /* end of rebuild_cnid, delete all remaining CNIDs from dbd */
1039                 while ((dbif_idwalk(dbd, &dbd_cnid, 0)) == 1) {
1040                     dbd_log(LOGSTD, "Orphaned CNID in database: %u", dbd_cnid);
1041                     if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
1042                         rqst.cnid = htonl(dbd_cnid);
1043                         if ((ret = dbd_delete(dbd, &rqst, &rply, DBIF_CNID)) == -1) {
1044                             dbd_log(LOGSTD, "Error deleting CNID %u", dbd_cnid);
1045                             (void)dbif_txn_abort(dbd);
1046                             goto cleanup;
1047                         }
1048
1049                         if (dbif_txn_close(dbd, ret) != 0)
1050                             return;
1051                         deleted++;
1052                     }
1053                     /* Check if we got a termination signal */
1054                     if (alarmed)
1055                         longjmp(jmp, 1); /* this jumps back to cmd_dbd_scanvol() */
1056                 }
1057                 return;
1058             } else
1059                 /* Normal case (ret=1): continue while loop */
1060                 continue;
1061         }
1062
1063         if (dbd_cnid < rebuild_cnid) {
1064             /* CNID is orphaned -> delete */
1065             dbd_log(LOGSTD, "One orphaned CNID in database: %u.", dbd_cnid);
1066             if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
1067                 rqst.cnid = htonl(dbd_cnid);
1068                 if ((ret = dbd_delete(dbd, &rqst, &rply, DBIF_CNID)) == -1) {
1069                     dbd_log(LOGSTD, "Error deleting CNID %u", dbd_cnid);
1070                     (void)dbif_txn_abort(dbd);
1071                     goto cleanup;
1072                 }
1073                 if (dbif_txn_close(dbd, ret) != 0)
1074                     return;
1075                 deleted++;
1076             }
1077             continue;
1078         }
1079
1080         if (dbd_cnid > rebuild_cnid) {
1081             dbif_idwalk(dbd, NULL, 1); /* Close cursor */
1082             dbif_idwalk(dbd_rebuild, NULL, 1); /* Close cursor */
1083             (void)dbif_txn_close(dbd, 2);
1084             (void)dbif_txn_close(dbd_rebuild, 2);
1085             dbd_log(LOGSTD, "Ghost CNID: %u. This is fatal! Dumping rebuild db:\n", rebuild_cnid);
1086             dbif_dump(dbd_rebuild, 0);
1087             dbd_log(LOGSTD, "Send this dump and a `dbd -d ...` dump to the Netatalk Dev team!");
1088             goto cleanup;
1089         }
1090     } /* while ((dbif_idwalk(dbd, &dbd_cnid, 0)) == 1) */
1091
1092 cleanup:
1093     dbif_idwalk(dbd, NULL, 1); /* Close cursor */
1094     dbif_idwalk(dbd_rebuild, NULL, 1); /* Close cursor */
1095     return;
1096 }
1097
1098 static const char *get_tmpdb_path(void)
1099 {
1100     pid_t pid = getpid();
1101     static char path[MAXPATHLEN];
1102     snprintf(path, MAXPATHLEN, "/tmp/tmpdb-dbd.%u", pid);
1103     if (mkdir(path, 0755) != 0)
1104         return NULL;
1105     return path;
1106 }
1107
1108 /*
1109   Main func called from cmd_dbd.c
1110 */
1111 int cmd_dbd_scanvol(DBD *dbd_ref, struct volinfo *vi, dbd_flags_t flags)
1112 {
1113     int ret = 0;
1114     struct db_param db_param = { 0 };
1115     const char *tmpdb_path = NULL;
1116
1117     /* Set cachesize for in-memory rebuild db */
1118     db_param.cachesize = 64 * 1024;         /* 64 MB */
1119     db_param.maxlocks = DEFAULT_MAXLOCKS;
1120     db_param.maxlockobjs = DEFAULT_MAXLOCKOBJS;
1121     db_param.logfile_autoremove = 1;
1122
1123     /* Make it accessible for all funcs */
1124     dbd = dbd_ref;
1125
1126     /* We only support unicode volumes ! */
1127     if ( vi->v_volcharset != CH_UTF8) {
1128         dbd_log( LOGSTD, "Not a Unicode volume: %s, %u != %u", vi->v_volcodepage, vi->v_volcharset, CH_UTF8);
1129         return -1;
1130     }
1131
1132     /* Get volume stamp */
1133     dbd_getstamp(dbd, &rqst, &rply);
1134     if (rply.result != CNID_DBD_RES_OK) {
1135         ret = -1;
1136         goto exit;
1137     }
1138     memcpy(stamp, rply.name, CNID_DEV_LEN);
1139
1140     /* temporary rebuild db, used with -re rebuild to delete unused CNIDs, not used with -f */
1141     if (! nocniddb && (flags & DBD_FLAGS_EXCL) && !(flags & DBD_FLAGS_FORCE)) {
1142         tmpdb_path = get_tmpdb_path();
1143         if (NULL == (dbd_rebuild = dbif_init(tmpdb_path, "cnid2.db"))) {
1144             ret = -1;
1145             goto exit;
1146         }
1147
1148         if (dbif_env_open(dbd_rebuild,
1149                           &db_param,
1150                           DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN) < 0) {
1151             dbd_log(LOGSTD, "error opening tmp database!");
1152             goto exit;
1153         }
1154
1155         if (0 != (dbif_open(dbd_rebuild, NULL, 0))) {
1156             ret = -1;
1157             goto exit;
1158         }
1159
1160         if (0 != (dbif_copy_rootinfokey(dbd, dbd_rebuild))) {
1161             ret = -1;
1162             goto exit;
1163         }
1164     }
1165
1166     if (setjmp(jmp) != 0) {
1167         ret = 0;                /* Got signal, jump from dbd_readdir */
1168         goto exit;
1169     }
1170
1171     /* scanvol */
1172     if ( (scanvol(vi, flags)) != 0) {
1173         ret = -1;
1174         goto exit;
1175     }
1176
1177 exit:
1178     if (! nocniddb) {
1179         if (dbif_txn_close(dbd, ret == 0 ? 1 : 0) != 0)
1180             ret = -1;
1181         if (dbd_rebuild)
1182             if (dbif_txn_close(dbd_rebuild, ret == 0 ? 1 : 0) != 0)
1183                 ret = -1;
1184         if ((ret == 0) && dbd_rebuild && (flags & DBD_FLAGS_EXCL) && !(flags & DBD_FLAGS_FORCE))
1185             /* We can only do this in exclusive mode, otherwise we might delete CNIDs added from
1186                other clients in between our pass 1 and 2 */
1187             delete_orphaned_cnids(dbd, dbd_rebuild, flags);
1188     }
1189
1190     if (dbd_rebuild) {
1191         dbd_log(LOGDEBUG, "Closing tmp db");
1192         dbif_close(dbd_rebuild);
1193
1194         if (tmpdb_path) {
1195             char cmd[8 + MAXPATHLEN];
1196             snprintf(cmd, 8 + MAXPATHLEN, "rm -f %s/*", tmpdb_path);
1197             dbd_log( LOGDEBUG, "Removing temp database '%s'", tmpdb_path);
1198             system(cmd);
1199             snprintf(cmd, 8 + MAXPATHLEN, "rmdir %s", tmpdb_path);
1200             system(cmd);
1201         }
1202     }
1203     return ret;
1204 }