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             adfile_ok = 1;
 642         } else {
 643
 644             if (dbd_flags & DBD_FLAGS_FORCE) {
 645                 ad_cnid = ad_forcegetid(&ad);
 646                 /* This ensures the changed stamp is written */
 647                 ad_setid( &ad, st->st_dev, st->st_ino, ad_cnid, did, stamp);
 648                 ad_flush(&ad);
 649             } else
 650                 ad_cnid = ad_getid(&ad, st->st_dev, st->st_ino, 0, stamp);
 651
 652             if (ad_cnid == 0)
 653                 dbd_log( LOGSTD, "Bad CNID in adouble file of '%s/%s'", cwdbuf, name);
 654             else
 655                 dbd_log( LOGDEBUG, "CNID from .AppleDouble file for '%s/%s': %u", cwdbuf, name, ntohl(ad_cnid));
 656             ad_close(&ad, ADFLAGS_HF);
 657         }
 658     }
 659
 660     /* Get CNID from database */
 661
 662     /* Prepare request data */
 663     memset(&rqst, 0, sizeof(struct cnid_dbd_rqst));
 664     memset(&rply, 0, sizeof(struct cnid_dbd_rply));
 665     rqst.did = did;
 666     rqst.cnid = ad_cnid;
 667     if ( ! (myvolinfo->v_flags & AFPVOL_NODEV))
 668         rqst.dev = st->st_dev;
 669     rqst.ino = st->st_ino;
 670     rqst.type = S_ISDIR(st->st_mode)?1:0;
 671     rqst.name = (char *)name;
 672     rqst.namelen = strlen(name);
 673
 674     /* Query the database */
 675     ret = dbd_lookup(dbd, &rqst, &rply, (dbd_flags & DBD_FLAGS_SCAN) ? 1 : 0);
 676     if (dbif_txn_close(dbd, ret) != 0)
 677         return CNID_INVALID;
 678     if (rply.result == CNID_DBD_RES_OK) {
 679         db_cnid = rply.cnid;
 680     } else if (rply.result == CNID_DBD_RES_NOTFOUND) {
 681         if ( ! (dbd_flags & DBD_FLAGS_FORCE))
 682             dbd_log( LOGSTD, "No CNID for '%s/%s' in database", cwdbuf, name);
 683         db_cnid = 0;
 684     } else {
 685         dbd_log( LOGSTD, "Fatal error resolving '%s/%s'", cwdbuf, name);
 686         db_cnid = 0;
 687     }
 688
 689     /* Compare results from both CNID searches */
 690     if (ad_cnid && db_cnid && (ad_cnid == db_cnid)) {
 691         /* Everything is fine */
 692         return db_cnid;
 693     } else if (ad_cnid && db_cnid && (ad_cnid != db_cnid)) {
 694         /* Mismatch, overwrite ad file with value from db */
 695         dbd_log( LOGSTD, "CNID mismatch for '%s/%s', db: %u, ad-file: %u", cwdbuf, name, ntohl(db_cnid), ntohl(ad_cnid));
 696         if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
 697             dbd_log(LOGSTD, "Updating AppleDouble file for '%s/%s' with CNID: %u from database",
 698                             cwdbuf, name, ntohl(db_cnid));
 699             ad_init(&ad, &volume);
 700             if (ad_open(&ad, name, adflags | ADFLAGS_HF | ADFLAGS_RDWR) != 0) {
 701                 dbd_log(LOGSTD, "Error opening AppleDouble file for '%s/%s': %s",
 702                         cwdbuf, name, strerror(errno));
 703                 return CNID_INVALID;
 704             }
 705             ad_setid( &ad, st->st_dev, st->st_ino, db_cnid, did, stamp);
 706             ad_flush(&ad);
 707             ad_close(&ad, ADFLAGS_HF);
 708         }
 709         return db_cnid;
 710     } else if (ad_cnid && (db_cnid == 0)) {
 711         /* in ad-file but not in db */
 712         if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
 713             /* Ensure the cnid from the ad-file is not already occupied by another file */
 714             dbd_log(LOGDEBUG, "Checking whether CNID %u from ad-file is occupied",
 715                     ntohl(ad_cnid));
 716
 717             rqst.cnid = ad_cnid;
 718             ret = dbd_resolve(dbd, &rqst, &rply);
 719             if (rply.result == CNID_DBD_RES_OK) {
 720                 /* Occupied! Choose another, update ad-file */
 721                 ret = dbd_add(dbd, &rqst, &rply, 1);
 722                 if (dbif_txn_close(dbd, ret) != 0)
 723                     return CNID_INVALID;
 724                 db_cnid = rply.cnid;
 725                 dbd_log(LOGSTD, "New CNID for '%s/%s': %u", cwdbuf, name, ntohl(db_cnid));
 726
 727                 if (ADFILE_OK && ( ! (dbd_flags & DBD_FLAGS_SCAN))) {
 728                     dbd_log(LOGSTD, "Writing CNID data for '%s/%s' to AppleDouble file",
 729                             cwdbuf, name, ntohl(db_cnid));
 730                     ad_init(&ad, &volume);
 731                     if (ad_open(&ad, name, adflags | ADFLAGS_RDWR) != 0) {
 732                         dbd_log(LOGSTD, "Error opening AppleDouble file for '%s/%s': %s",
 733                                 cwdbuf, name, strerror(errno));
 734                         return CNID_INVALID;
 735                     }
 736                     ad_setid( &ad, st->st_dev, st->st_ino, db_cnid, did, stamp);
 737                     ad_flush(&ad);
 738                     ad_close(&ad, ADFLAGS_HF);
 739                 }
 740                 return db_cnid;
 741             }
 742
 743             dbd_log(LOGDEBUG, "CNID rebuild add '%s/%s' with CNID from ad-file %u",
 744                     cwdbuf, name, ntohl(ad_cnid));
 745             rqst.cnid = ad_cnid;
 746             ret = dbd_rebuild_add(dbd, &rqst, &rply);
 747             if (dbif_txn_close(dbd, ret) != 0)
 748                 return CNID_INVALID;
 749         }
 750         return ad_cnid;
 751     } else if ((db_cnid == 0) && (ad_cnid == 0)) {
 752         /* No CNID at all, we clearly have to allocate a fresh one... */
 753         /* Note: the next test will use this new CNID too! */
 754         if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
 755             /* add to db */
 756             ret = dbd_add(dbd, &rqst, &rply, 1);
 757             if (dbif_txn_close(dbd, ret) != 0)
 758                 return CNID_INVALID;
 759             db_cnid = rply.cnid;
 760             dbd_log(LOGSTD, "New CNID for '%s/%s': %u", cwdbuf, name, ntohl(db_cnid));
 761         }
 762     }
 763
 764     if ((ad_cnid == 0) && db_cnid) {
 765         /* in db but zeroID in ad-file, write it to ad-file */
 766         if (ADFILE_OK && ! (dbd_flags & DBD_FLAGS_SCAN)) {
 767             dbd_log(LOGSTD, "Writing CNID data for '%s/%s' to AppleDouble file",
 768                     cwdbuf, name, ntohl(db_cnid));
 769             ad_init(&ad, &volume);
 770             if (ad_open(&ad, name, adflags | ADFLAGS_RDWR) != 0) {
 771                 dbd_log(LOGSTD, "Error opening AppleDouble file for '%s/%s': %s",
 772                         cwdbuf, name, strerror(errno));
 773                 return CNID_INVALID;
 774             }
 775             ad_setid( &ad, st->st_dev, st->st_ino, db_cnid, did, stamp);
 776             ad_flush(&ad);
 777             ad_close(&ad, ADFLAGS_HF);
 778         }
 779         return db_cnid;
 780     }
 781
 782     return CNID_INVALID;
 783 }
 784
 785 /*
 786   This is called recursively for all dirs.
 787   volroot=1 means we're in the volume root dir, 0 means we aren't.
 788   We use this when checking for netatalk private folders like .AppleDB.
 789   did is our parents CNID.
 790 */
 791 static int dbd_readdir(int volroot, cnid_t did)
 792 {
 793     int cwd, ret = 0, adfile_ok, addir_ok, encoding_ok;
 794     cnid_t cnid = 0;
 795     const char *name;
 796     DIR *dp;
 797     struct dirent *ep;
 798     static struct stat st;      /* Save some stack space */
 799
 800     /* Check again for .AppleDouble folder, check_adfile also checks/creates it */
 801     if ((addir_ok = check_addir(volroot)) != 0)
 802         if ( ! (dbd_flags & DBD_FLAGS_SCAN))
 803             /* Fatal on rebuild run, continue if only scanning ! */
 804             return -1;
 805
 806     /* Check AppleDouble files in AppleDouble folder, but only if it exists or could be created */
 807     if (volume.v_adouble == AD_VERSION2 && ADDIR_OK)
 808         if ((read_addir()) != 0)
 809             if ( ! (dbd_flags & DBD_FLAGS_SCAN))
 810                 /* Fatal on rebuild run, continue if only scanning ! */
 811                 return -1;
 812
 813     if ((dp = opendir (".")) == NULL) {
 814         dbd_log(LOGSTD, "Couldn't open the directory: %s",strerror(errno));
 815         return -1;
 816     }
 817
 818     while ((ep = readdir (dp))) {
 819         /* Check if we got a termination signal */
 820         if (alarmed)
 821             longjmp(jmp, 1); /* this jumps back to cmd_dbd_scanvol() */
 822
 823         /* Check if its "." or ".." */
 824         if (DIR_DOT_OR_DOTDOT(ep->d_name))
 825             continue;
 826
 827         /* Check for netatalk special folders e.g. ".AppleDB" or ".AppleDesktop" */
 828         if ((name = check_netatalk_dirs(ep->d_name)) != NULL) {
 829             if (! volroot)
 830                 dbd_log(LOGSTD, "Nested %s in %s", name, cwdbuf);
 831             continue;
 832         }
 833
 834         /* Check for special folders in volume root e.g. ".zfs" */
 835         if (volroot) {
 836             if ((name = check_special_dirs(ep->d_name)) != NULL) {
 837                 dbd_log(LOGSTD, "Ignoring special dir \"%s\"", name);
 838                 continue;
 839             }
 840         }
 841
 842         /* Skip .AppleDouble dir in this loop */
 843         if (STRCMP(ep->d_name, == , ADv2_DIRNAME))
 844             continue;
 845
 846         if ((ret = lstat(ep->d_name, &st)) < 0) {
 847             dbd_log( LOGSTD, "Lost file while reading dir '%s/%s', probably removed: %s",
 848                      cwdbuf, ep->d_name, strerror(errno));
 849             continue;
 850         }
 851
 852         switch (st.st_mode & S_IFMT) {
 853         case S_IFREG:
 854         case S_IFDIR:
 855             break;
 856         case S_IFLNK:
 857             dbd_log(LOGDEBUG, "Ignoring symlink %s/%s", cwdbuf, ep->d_name);
 858             continue;
 859         default:
 860             dbd_log(LOGSTD, "Bad filetype: %s/%s", cwdbuf, ep->d_name);
 861             if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
 862                 if ((unlink(ep->d_name)) != 0) {
 863                     dbd_log(LOGSTD, "Error removing: %s/%s: %s", cwdbuf, ep->d_name, strerror(errno));
 864                 }
 865             }
 866             continue;
 867         }
 868
 869         /**************************************************************************
 870            Statistics
 871          **************************************************************************/
 872         static unsigned long long statcount = 0;
 873         static time_t t = 0;
 874
 875         if (t == 0)
 876             t = time(NULL);
 877
 878         statcount++;
 879         if ((statcount % 10000) == 0) {
 880             if (dbd_flags & DBD_FLAGS_STATS)
 881                 dbd_log(LOGSTD, "Scanned: %10llu, time: %10llu s",
 882                         statcount, (unsigned long long)(time(NULL) - t));
 883         }
 884
 885         /**************************************************************************
 886            Tests
 887         **************************************************************************/
 888
 889         /* Check encoding */
 890         if ( -1 == (encoding_ok = check_name_encoding(ep->d_name)) ) {
 891             /* If its a file: skipp all other tests now ! */
 892             /* For dirs we could try to get a CNID for it and recurse, but currently I prefer not to */
 893             continue;
 894         }
 895
 896         /* Check for appledouble file, create if missing, but only if we have addir */
 897         adfile_ok = -1;
 898         if (ADDIR_OK)
 899             adfile_ok = check_adfile(ep->d_name, &st);
 900
 901         if ( ! nocniddb) {
 902             /* Check CNIDs */
 903             cnid = check_cnid(ep->d_name, did, &st, adfile_ok);
 904
 905             /* Now add this object to our rebuild dbd */
 906             if (cnid && dbd_rebuild) {
 907                 static uint count = 0;
 908                 rqst.cnid = rply.cnid;
 909                 ret = dbd_rebuild_add(dbd_rebuild, &rqst, &rply);
 910                 if (dbif_txn_close(dbd_rebuild, ret) != 0)
 911                     return -1;
 912                 if (rply.result != CNID_DBD_RES_OK) {
 913                     dbd_log( LOGSTD, "Fatal error adding CNID: %u for '%s/%s' to in-memory rebuild-db",
 914                              cnid, cwdbuf, ep->d_name);
 915                     return -1;
 916                 }
 917                 count++;
 918                 if (count == 10000) {
 919                     if (dbif_txn_checkpoint(dbd_rebuild, 0, 0, 0) < 0) {
 920                         dbd_log(LOGSTD, "Error checkpointing!");
 921                         return -1;
 922                     }
 923                     count = 0;
 924                 }
 925             }
 926         }
 927
 928         /* Check EA files */
 929         if (myvolinfo->v_vfs_ea == AFPVOL_EA_AD)
 930             check_eafiles(ep->d_name);
 931
 932         /**************************************************************************
 933           Recursion
 934         **************************************************************************/
 935         if (S_ISDIR(st.st_mode) && (cnid || nocniddb)) { /* If we have no cnid for it we cant recur */
 936             strcat(cwdbuf, "/");
 937             strcat(cwdbuf, ep->d_name);
 938             dbd_log( LOGDEBUG, "Entering directory: %s", cwdbuf);
 939             if (-1 == (cwd = open(".", O_RDONLY))) {
 940                 dbd_log( LOGSTD, "Cant open directory '%s': %s", cwdbuf, strerror(errno));
 941                 continue;
 942             }
 943             if (0 != chdir(ep->d_name)) {
 944                 dbd_log( LOGSTD, "Cant chdir to directory '%s': %s", cwdbuf, strerror(errno));
 945                 close(cwd);
 946                 continue;
 947             }
 948
 949             ret = dbd_readdir(0, cnid);
 950
 951             fchdir(cwd);
 952             close(cwd);
 953             *(strrchr(cwdbuf, '/')) = 0;
 954             if (ret < 0)
 955                 return -1;
 956         }
 957     }
 958
 959     /*
 960       Use results of previous checks
 961     */
 962
 963     closedir(dp);
 964     return ret;
 965 }
 966
 967 static int scanvol(struct volinfo *vi, dbd_flags_t flags)
 968 {
 969     /* Make this stuff accessible from all funcs easily */
 970     myvolinfo = vi;
 971     dbd_flags = flags;
 972
 973     /* Init a fake struct vol so that we can call ad_init(.., &volume) and initvol_vfs(&volume) */
 974     volume.v_adouble = vi->v_adouble;
 975     volume.v_ad_options = vi->v_flags;
 976     volume.ad_path = vi->ad_path;
 977     volume.v_vfs_ea = myvolinfo->v_vfs_ea;
 978     initvol_vfs(&volume);
 979
 980     /* Run with umask 0 */
 981     umask(0);
 982
 983     /* Remove trailing slash from volume, chdir to vol */
 984     if (myvolinfo->v_path[strlen(myvolinfo->v_path) - 1] == '/')
 985         myvolinfo->v_path[strlen(myvolinfo->v_path) - 1] = 0;
 986     strcpy(cwdbuf, myvolinfo->v_path);
 987     chdir(myvolinfo->v_path);
 988
 989     /* Start recursion */
 990     if (dbd_readdir(1, htonl(2)) < 0)  /* 2 = volumeroot CNID */
 991         return -1;
 992
 993     return 0;
 994 }
 995
 996 /*
 997   Remove all CNIDs from dbd that are not in dbd_rebuild
 998 */
 999 static void delete_orphaned_cnids(DBD *dbd, DBD *dbd_rebuild, dbd_flags_t flags)
1000 {
1001     int ret = 0, deleted = 0;
1002     cnid_t dbd_cnid = 0, rebuild_cnid = 0;
1003     struct cnid_dbd_rqst rqst;
1004     struct cnid_dbd_rply rply;
1005
1006     /* jump over rootinfo key */
1007     if ( dbif_idwalk(dbd, &dbd_cnid, 0) != 1)
1008         return;
1009     if ( dbif_idwalk(dbd_rebuild, &rebuild_cnid, 0) != 1)
1010         return;
1011
1012     /* Get first id from dbd_rebuild */
1013     if ((dbif_idwalk(dbd_rebuild, &rebuild_cnid, 0)) == -1)
1014         return;
1015
1016     /* Start main loop through dbd: get CNID from dbd */
1017     while ((dbif_idwalk(dbd, &dbd_cnid, 0)) == 1) {
1018         /* Check if we got a termination signal */
1019         if (alarmed)
1020             longjmp(jmp, 1); /* this jumps back to cmd_dbd_scanvol() */
1021
1022         if (deleted > 1000) {
1023             deleted = 0;
1024             if (dbif_txn_checkpoint(dbd, 0, 0, 0) < 0) {
1025                 dbd_log(LOGSTD, "Error checkpointing!");
1026                 goto cleanup;
1027             }
1028         }
1029
1030         /* This should be the normal case: CNID is in both dbs */
1031         if (dbd_cnid == rebuild_cnid) {
1032             /* Get next CNID from rebuild db */
1033             if ((ret = dbif_idwalk(dbd_rebuild, &rebuild_cnid, 0)) == -1) {
1034                 /* Some error */
1035                 goto cleanup;
1036             } else if (ret == 0) {
1037                 /* end of rebuild_cnid, delete all remaining CNIDs from dbd */
1038                 while ((dbif_idwalk(dbd, &dbd_cnid, 0)) == 1) {
1039                     dbd_log(LOGSTD, "Orphaned CNID in database: %u", dbd_cnid);
1040                     if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
1041                         rqst.cnid = htonl(dbd_cnid);
1042                         if ((ret = dbd_delete(dbd, &rqst, &rply, DBIF_CNID)) == -1) {
1043                             dbd_log(LOGSTD, "Error deleting CNID %u", dbd_cnid);
1044                             (void)dbif_txn_abort(dbd);
1045                             goto cleanup;
1046                         }
1047
1048                         if (dbif_txn_close(dbd, ret) != 0)
1049                             return;
1050                         deleted++;
1051                     }
1052                     /* Check if we got a termination signal */
1053                     if (alarmed)
1054                         longjmp(jmp, 1); /* this jumps back to cmd_dbd_scanvol() */
1055                 }
1056                 return;
1057             } else
1058                 /* Normal case (ret=1): continue while loop */
1059                 continue;
1060         }
1061
1062         if (dbd_cnid < rebuild_cnid) {
1063             /* CNID is orphaned -> delete */
1064             dbd_log(LOGSTD, "One orphaned CNID in database: %u.", dbd_cnid);
1065             if ( ! (dbd_flags & DBD_FLAGS_SCAN)) {
1066                 rqst.cnid = htonl(dbd_cnid);
1067                 if ((ret = dbd_delete(dbd, &rqst, &rply, DBIF_CNID)) == -1) {
1068                     dbd_log(LOGSTD, "Error deleting CNID %u", dbd_cnid);
1069                     (void)dbif_txn_abort(dbd);
1070                     goto cleanup;
1071                 }
1072                 if (dbif_txn_close(dbd, ret) != 0)
1073                     return;
1074                 deleted++;
1075             }
1076             continue;
1077         }
1078
1079         if (dbd_cnid > rebuild_cnid) {
1080             dbif_idwalk(dbd, NULL, 1); /* Close cursor */
1081             dbif_idwalk(dbd_rebuild, NULL, 1); /* Close cursor */
1082             (void)dbif_txn_close(dbd, 2);
1083             (void)dbif_txn_close(dbd_rebuild, 2);
1084             dbd_log(LOGSTD, "Ghost CNID: %u. This is fatal! Dumping rebuild db:\n", rebuild_cnid);
1085             dbif_dump(dbd_rebuild, 0);
1086             dbd_log(LOGSTD, "Send this dump and a `dbd -d ...` dump to the Netatalk Dev team!");
1087             goto cleanup;
1088         }
1089     } /* while ((dbif_idwalk(dbd, &dbd_cnid, 0)) == 1) */
1090
1091 cleanup:
1092     dbif_idwalk(dbd, NULL, 1); /* Close cursor */
1093     dbif_idwalk(dbd_rebuild, NULL, 1); /* Close cursor */
1094     return;
1095 }
1096
1097 static const char *get_tmpdb_path(void)
1098 {
1099     pid_t pid = getpid();
1100     static char path[MAXPATHLEN];
1101     snprintf(path, MAXPATHLEN, "/tmp/tmpdb-dbd.%u", pid);
1102     if (mkdir(path, 0755) != 0)
1103         return NULL;
1104     return path;
1105 }
1106
1107 /*
1108   Main func called from cmd_dbd.c
1109 */
1110 int cmd_dbd_scanvol(DBD *dbd_ref, struct volinfo *vi, dbd_flags_t flags)
1111 {
1112     int ret = 0;
1113     struct db_param db_param = { 0 };
1114     const char *tmpdb_path = NULL;
1115
1116     /* Set cachesize for in-memory rebuild db */
1117     db_param.cachesize = 64 * 1024;         /* 64 MB */
1118     db_param.maxlocks = DEFAULT_MAXLOCKS;
1119     db_param.maxlockobjs = DEFAULT_MAXLOCKOBJS;
1120     db_param.logfile_autoremove = 1;
1121
1122     /* Make it accessible for all funcs */
1123     dbd = dbd_ref;
1124
1125     /* We only support unicode volumes ! */
1126     if ( vi->v_volcharset != CH_UTF8) {
1127         dbd_log( LOGSTD, "Not a Unicode volume: %s, %u != %u", vi->v_volcodepage, vi->v_volcharset, CH_UTF8);
1128         return -1;
1129     }
1130
1131     /* Get volume stamp */
1132     dbd_getstamp(dbd, &rqst, &rply);
1133     if (rply.result != CNID_DBD_RES_OK) {
1134         ret = -1;
1135         goto exit;
1136     }
1137     memcpy(stamp, rply.name, CNID_DEV_LEN);
1138
1139     /* temporary rebuild db, used with -re rebuild to delete unused CNIDs, not used with -f */
1140     if (! nocniddb && (flags & DBD_FLAGS_EXCL) && !(flags & DBD_FLAGS_FORCE)) {
1141         tmpdb_path = get_tmpdb_path();
1142         if (NULL == (dbd_rebuild = dbif_init(tmpdb_path, "cnid2.db"))) {
1143             ret = -1;
1144             goto exit;
1145         }
1146
1147         if (dbif_env_open(dbd_rebuild,
1148                           &db_param,
1149                           DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN) < 0) {
1150             dbd_log(LOGSTD, "error opening tmp database!");
1151             goto exit;
1152         }
1153
1154         if (0 != (dbif_open(dbd_rebuild, NULL, 0))) {
1155             ret = -1;
1156             goto exit;
1157         }
1158
1159         if (0 != (dbif_copy_rootinfokey(dbd, dbd_rebuild))) {
1160             ret = -1;
1161             goto exit;
1162         }
1163     }
1164
1165     if (setjmp(jmp) != 0) {
1166         ret = 0;                /* Got signal, jump from dbd_readdir */
1167         goto exit;
1168     }
1169
1170     /* scanvol */
1171     if ( (scanvol(vi, flags)) != 0) {
1172         ret = -1;
1173         goto exit;
1174     }
1175
1176 exit:
1177     if (! nocniddb) {
1178         if (dbif_txn_close(dbd, ret == 0 ? 1 : 0) != 0)
1179             ret = -1;
1180         if (dbd_rebuild)
1181             if (dbif_txn_close(dbd_rebuild, ret == 0 ? 1 : 0) != 0)
1182                 ret = -1;
1183         if ((ret == 0) && dbd_rebuild && (flags & DBD_FLAGS_EXCL) && !(flags & DBD_FLAGS_FORCE))
1184             /* We can only do this in exclusive mode, otherwise we might delete CNIDs added from
1185                other clients in between our pass 1 and 2 */
1186             delete_orphaned_cnids(dbd, dbd_rebuild, flags);
1187     }
1188
1189     if (dbd_rebuild) {
1190         dbd_log(LOGDEBUG, "Closing tmp db");
1191         dbif_close(dbd_rebuild);
1192
1193         if (tmpdb_path) {
1194             char cmd[8 + MAXPATHLEN];
1195             snprintf(cmd, 8 + MAXPATHLEN, "rm -f %s/*", tmpdb_path);
1196             dbd_log( LOGDEBUG, "Removing temp database '%s'", tmpdb_path);
1197             system(cmd);
1198             snprintf(cmd, 8 + MAXPATHLEN, "rmdir %s", tmpdb_path);
1199             system(cmd);
1200         }
1201     }
1202     return ret;
1203 }