libatalk/cnid/dbd/cnid_dbd.c

   1 /*
   2  * Copyright (C) Joerg Lenneis 2003
   3  * Copyright (C) Frank Lahm 2010
   4  * All Rights Reserved.  See COPYING.
   5  */
   6
   7 #ifdef HAVE_CONFIG_H
   8 #include "config.h"
   9 #endif /* HAVE_CONFIG_H */
  10
  11 #ifdef CNID_BACKEND_DBD
  12
  13 #include <stdlib.h>
  14 #ifdef HAVE_SYS_STAT_H
  15 #include <sys/stat.h>
  16 #endif /* HAVE_SYS_STAT_H */
  17 #ifdef HAVE_SYS_UIO_H
  18 #include <sys/uio.h>
  19 #endif /* HAVE_SYS_UIO_H */
  20 #ifdef HAVE_STRINGS_H
  21 #include <strings.h>
  22 #endif
  23 #include <sys/time.h>
  24 #include <sys/un.h>
  25 #include <sys/socket.h>
  26 #include <sys/param.h>
  27 #include <errno.h>
  28 #include <netinet/in.h>
  29 #include <net/if.h>
  30 #include <netinet/tcp.h>
  31 #include <netinet/in.h>
  32 #include <arpa/inet.h>
  33 #include <errno.h>
  34 #include <netdb.h>
  35 #include <time.h>
  36
  37 #include <netatalk/endian.h>
  38 #include <atalk/logger.h>
  39 #include <atalk/adouble.h>
  40 #include <atalk/cnid.h>
  41 #include <atalk/cnid_dbd_private.h>
  42 #include <atalk/util.h>
  43
  44 #include "cnid_dbd.h"
  45
  46 #ifndef SOL_TCP
  47 #define SOL_TCP IPPROTO_TCP
  48 #endif /* ! SOL_TCP */
  49
  50 /* Wait MAX_DELAY seconds before a request to the CNID server times out */
  51 #define MAX_DELAY 20
  52 #define ONE_DELAY 5
  53
  54 static void RQST_RESET(struct cnid_dbd_rqst  *r)
  55 {
  56     memset(r, 0, sizeof(struct cnid_dbd_rqst ));
  57 }
  58
  59 static void delay(int sec)
  60 {
  61     struct timeval tv;
  62
  63     tv.tv_usec = 0;
  64     tv.tv_sec  = sec;
  65     select(0, NULL, NULL, NULL, &tv);
  66 }
  67
  68 static int tsock_getfd(const char *host, const char *port)
  69 {
  70     int sock = -1;
  71     int attr;
  72     int err;
  73     struct addrinfo hints, *servinfo, *p;
  74     int optval;
  75     socklen_t optlen = sizeof(optval);
  76
  77     /* Prepare hint for getaddrinfo */
  78     memset(&hints, 0, sizeof hints);
  79     hints.ai_family = AF_UNSPEC;
  80     hints.ai_socktype = SOCK_STREAM;
  81     hints.ai_flags = AI_NUMERICSERV;
  82
  83     if ((err = getaddrinfo(host, port, &hints, &servinfo)) != 0) {
  84         LOG(log_error, logtype_default, "tsock_getfd: getaddrinfo: CNID server %s:%s : %s\n",
  85             host, port, gai_strerror(err));
  86         return -1;
  87     }
  88
  89     /* loop through all the results and bind to the first we can */
  90     for (p = servinfo; p != NULL; p = p->ai_next) {
  91         if ((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
  92             LOG(log_info, logtype_default, "tsock_getfd: socket CNID server %s:: %s",
  93                 host, strerror(errno));
  94             continue;
  95         }
  96
  97         attr = 1;
  98         if (setsockopt(sock, SOL_TCP, TCP_NODELAY, &attr, sizeof(attr)) == -1) {
  99             LOG(log_error, logtype_cnid, "getfd: set TCP_NODELAY CNID server %s: %s",
 100                 host, strerror(errno));
 101             close(sock);
 102             sock = -1;
 103             return -1;
 104         }
 105
 106         if (setnonblock(sock, 1) != 0) {
 107             LOG(log_error, logtype_cnid, "getfd: setnonblock: %s", strerror(err));
 108             close(sock);
 109             sock = -1;
 110             return -1;
 111         }
 112
 113         if (connect(sock, p->ai_addr, p->ai_addrlen) == -1) {
 114             if (errno == EINPROGRESS) {
 115                 struct timeval tv;
 116                 tv.tv_usec = 0;
 117                 tv.tv_sec  = 5; /* give it five seconds ... */
 118                 fd_set wfds;
 119                 FD_ZERO(&wfds);
 120                 FD_SET(sock, &wfds);
 121
 122                 if ((err = select(sock + 1, NULL, &wfds, NULL, &tv)) == 0) {
 123                     /* timeout */
 124                     LOG(log_error, logtype_cnid, "getfd: select timed out for CNID server %s",
 125                         host);
 126                     close(sock);
 127                     sock = -1;
 128                     continue;
 129                 }
 130                 if (err == -1) {
 131                     /* select failed */
 132                     LOG(log_error, logtype_cnid, "getfd: select failed for CNID server %s",
 133                         host);
 134                     close(sock);
 135                     sock = -1;
 136                     continue;
 137                 }
 138
 139                 if ( ! FD_ISSET(sock, &wfds)) {
 140                     /* give up */
 141                     LOG(log_error, logtype_cnid, "getfd: socket not ready connecting to %s",
 142                         host);
 143                     close(sock);
 144                     sock = -1;
 145                     continue;
 146                 }
 147
 148                 if ((err = getsockopt(sock, SOL_SOCKET, SO_ERROR, &optval, &optlen)) != 0 || optval != 0) {
 149                     if (err != 0) {
 150                         /* somethings very wrong */
 151                         LOG(log_error, logtype_cnid, "getfd: getsockopt error with CNID server %s: %s",
 152                             host, strerror(errno));
 153                     } else {
 154                         errno = optval;
 155                         LOG(log_error, logtype_cnid, "getfd: getsockopt says: %s",
 156                             strerror(errno));
 157                     }
 158                     close(sock);
 159                     sock = -1;
 160                     continue;
 161                 }
 162             } else {
 163                 LOG(log_error, logtype_cnid, "getfd: connect CNID server %s: %s",
 164                     host, strerror(errno));
 165                 close(sock);
 166                 sock = -1;
 167                 continue;
 168             }
 169         }
 170
 171         /* We've got a socket */
 172         break;
 173     }
 174
 175     freeaddrinfo(servinfo);
 176
 177     if (p == NULL) {
 178         errno = optval;
 179         LOG(log_error, logtype_cnid, "tsock_getfd: no suitable network config from CNID server (%s:%s): %s",
 180             host, port, strerror(errno));
 181         return -1;
 182     }
 183
 184     return(sock);
 185 }
 186
 187 /*!
 188  * Write "towrite" bytes using writev on non-blocking fd
 189  *
 190  * Every short write is considered an error, transmit can handle that.
 191  *
 192  * @param fd      (r) socket fd which must be non-blocking
 193  * @param iov     (r) iovec for writev
 194  * @param towrite (r) number of bytes in all iovec elements
 195  * @param vecs    (r) number of iovecs in array
 196  *
 197  * @returns "towrite" bytes written or -1 on error
 198  */
 199 static int write_vec(int fd, struct iovec *iov, ssize_t towrite, int vecs)
 200 {
 201     ssize_t len;
 202     int slept = 0;
 203     int sleepsecs;
 204
 205     while (1) {
 206         if (((len = writev(fd, iov, vecs)) == -1 && errno == EINTR))
 207             continue;
 208
 209         if ((! slept) && len == -1 && errno == EAGAIN) {
 210             sleepsecs = 2;
 211             while ((sleepsecs = sleep(sleepsecs)));
 212             slept = 1;
 213             continue;
 214         }
 215
 216         if (len == towrite) /* wrote everything out */
 217             break;
 218
 219         if (len == -1)
 220             LOG(log_error, logtype_cnid, "write_vec: %s", strerror(errno));
 221         else
 222             LOG(log_error, logtype_cnid, "write_vec: short write: %d", len);
 223         return len;
 224     }
 225
 226     LOG(log_maxdebug, logtype_cnid, "write_vec: wrote %d bytes", len);
 227
 228     return len;
 229 }
 230
 231 /* --------------------- */
 232 static int init_tsock(CNID_private *db)
 233 {
 234     int fd;
 235     int len;
 236     struct iovec iov[2];
 237
 238     LOG(log_debug, logtype_cnid, "init_tsock: BEGIN. Opening volume '%s', CNID Server: %s/%s",
 239         db->db_dir, db->cnidserver, db->cnidport);
 240
 241     if ((fd = tsock_getfd(db->cnidserver, db->cnidport)) < 0)
 242         return -1;
 243
 244     len = strlen(db->db_dir);
 245
 246     iov[0].iov_base = &len;
 247     iov[0].iov_len  = sizeof(int);
 248
 249     iov[1].iov_base = db->db_dir;
 250     iov[1].iov_len  = len;
 251
 252     if (write_vec(fd, iov, len + sizeof(int), 2) != len + sizeof(int)) {
 253         LOG(log_error, logtype_cnid, "init_tsock: Error/short write: %s", strerror(errno));
 254         close(fd);
 255         return -1;
 256     }
 257
 258     LOG(log_debug, logtype_cnid, "init_tsock: ok");
 259
 260     return fd;
 261 }
 262
 263 /* --------------------- */
 264 static int send_packet(CNID_private *db, struct cnid_dbd_rqst *rqst)
 265 {
 266     struct iovec iov[2];
 267     size_t towrite;
 268     int vecs;
 269
 270     iov[0].iov_base = rqst;
 271     iov[0].iov_len  = sizeof(struct cnid_dbd_rqst);
 272     towrite = sizeof(struct cnid_dbd_rqst);
 273     vecs = 1;
 274
 275     if (rqst->namelen) {
 276         iov[1].iov_base = rqst->name;
 277         iov[1].iov_len  = rqst->namelen;
 278         towrite += rqst->namelen;
 279         vecs++;
 280     }
 281
 282     if (write_vec(db->fd, iov, towrite, vecs) != towrite) {
 283         LOG(log_warning, logtype_cnid, "send_packet: Error writev rqst (db_dir %s): %s",
 284             db->db_dir, strerror(errno));
 285         return -1;
 286     }
 287
 288     LOG(log_maxdebug, logtype_cnid, "send_packet: {done}");
 289     return 0;
 290 }
 291
 292 /* ------------------- */
 293 static void dbd_initstamp(struct cnid_dbd_rqst *rqst)
 294 {
 295     RQST_RESET(rqst);
 296     rqst->op = CNID_DBD_OP_GETSTAMP;
 297 }
 298
 299 /* ------------------- */
 300 static int dbd_reply_stamp(struct cnid_dbd_rply *rply)
 301 {
 302     switch (rply->result) {
 303     case CNID_DBD_RES_OK:
 304         break;
 305     case CNID_DBD_RES_NOTFOUND:
 306         return -1;
 307     case CNID_DBD_RES_ERR_DB:
 308     default:
 309         errno = CNID_ERR_DB;
 310         return -1;
 311     }
 312     return 0;
 313 }
 314
 315 /* ---------------------
 316  * send a request and get reply
 317  * assume send is non blocking
 318  * if no answer after sometime (at least MAX_DELAY secondes) return an error
 319  */
 320 static int dbd_rpc(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
 321 {
 322     ssize_t ret;
 323     char *nametmp;
 324     size_t len;
 325
 326     if (send_packet(db, rqst) < 0) {
 327         return -1;
 328     }
 329     len = rply->namelen;
 330     nametmp = rply->name;
 331
 332     ret = readt(db->fd, rply, sizeof(struct cnid_dbd_rply), 0, ONE_DELAY);
 333
 334     if (ret != sizeof(struct cnid_dbd_rply)) {
 335         LOG(log_error, logtype_cnid, "dbd_rpc: Error reading header from fd (db_dir %s): %s",
 336             db->db_dir, ret == -1 ? strerror(errno) : "closed");
 337         rply->name = nametmp;
 338         return -1;
 339     }
 340     rply->name = nametmp;
 341     if (rply->namelen && rply->namelen > len) {
 342         LOG(log_error, logtype_cnid,
 343             "dbd_rpc: Error reading name (db_dir %s): %s name too long: %d. only wanted %d, garbage?",
 344             db->db_dir, rply->name, rply->namelen, len);
 345         return -1;
 346     }
 347     if (rply->namelen && (ret = readt(db->fd, rply->name, rply->namelen, 0, ONE_DELAY)) != (ssize_t)rply->namelen) {
 348         LOG(log_error, logtype_cnid, "dbd_rpc: Error reading name from fd (db_dir %s): %s",
 349             db->db_dir, ret == -1?strerror(errno):"closed");
 350         return -1;
 351     }
 352
 353     LOG(log_maxdebug, logtype_cnid, "dbd_rpc: {done}");
 354
 355     return 0;
 356 }
 357
 358 /* -------------------- */
 359 static int transmit(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
 360 {
 361     time_t orig, t;
 362     int clean = 1; /* no errors so far - to prevent sleep on first try */
 363
 364     if (db->changed) {
 365         /* volume and db don't have the same timestamp
 366          */
 367         return -1;
 368     }
 369     while (1) {
 370         if (db->fd == -1) {
 371             struct cnid_dbd_rqst rqst_stamp;
 372             struct cnid_dbd_rply rply_stamp;
 373             char  stamp[ADEDLEN_PRIVSYN];
 374
 375             LOG(log_maxdebug, logtype_cnid, "transmit: connecting to cnid_dbd ...");
 376             if ((db->fd = init_tsock(db)) < 0) {
 377                 goto transmit_fail;
 378             }
 379             dbd_initstamp(&rqst_stamp);
 380             memset(stamp, 0, ADEDLEN_PRIVSYN);
 381             rply_stamp.name = stamp;
 382             rply_stamp.namelen = ADEDLEN_PRIVSYN;
 383
 384             if (dbd_rpc(db, &rqst_stamp, &rply_stamp) < 0)
 385                 goto transmit_fail;
 386             if (dbd_reply_stamp(&rply_stamp ) < 0)
 387                 goto transmit_fail;
 388
 389             if (db->notfirst) {
 390                 LOG(log_debug7, logtype_cnid, "transmit: reconnected to cnid_dbd, comparing database stamps...");
 391                 if (memcmp(stamp, db->stamp, ADEDLEN_PRIVSYN)) {
 392                     LOG(log_error, logtype_cnid, "transmit: ... not the same db!");
 393                     db->changed = 1;
 394                     return -1;
 395                 }
 396                 LOG(log_debug7, logtype_cnid, "transmit: ... OK.");
 397             } else { /* db->notfirst == 0 */
 398                 db->notfirst = 1;
 399                 if (db->client_stamp)
 400                     memcpy(db->client_stamp, stamp, ADEDLEN_PRIVSYN);
 401                 memcpy(db->stamp, stamp, ADEDLEN_PRIVSYN);
 402             }
 403             LOG(log_debug, logtype_cnid, "transmit: attached to '%s', stamp: '%08lx'.",
 404                 db->db_dir, *(uint64_t *)stamp);
 405         }
 406         if (!dbd_rpc(db, rqst, rply)) {
 407             LOG(log_maxdebug, logtype_cnid, "transmit: {done}");
 408             return 0;
 409         }
 410     transmit_fail:
 411         if (db->fd != -1) {
 412             close(db->fd);
 413             db->fd = -1; /* FD not valid... will need to reconnect */
 414         }
 415
 416         if (errno == ECONNREFUSED) { /* errno carefully injected in tsock_getfd */
 417             /* give up */
 418             LOG(log_error, logtype_cnid, "transmit: connection refused (db_dir %s)", db->db_dir);
 419             return -1;
 420         }
 421
 422         if (!clean) { /* don't sleep if just got disconnected by cnid server */
 423             time(&t);
 424             if (t - orig > MAX_DELAY) {
 425                 LOG(log_error, logtype_cnid, "transmit: Request to dbd daemon (db_dir %s) timed out.", db->db_dir);
 426                 return -1;
 427             }
 428             /* sleep a little before retry */
 429             delay(1);
 430         } else {
 431             clean = 0; /* false... next time sleep */
 432             time(&orig);
 433         }
 434     }
 435     return -1;
 436 }
 437
 438 /* ---------------------- */
 439 static struct _cnid_db *cnid_dbd_new(const char *volpath)
 440 {
 441     struct _cnid_db *cdb;
 442
 443     if ((cdb = (struct _cnid_db *)calloc(1, sizeof(struct _cnid_db))) == NULL)
 444         return NULL;
 445
 446     if ((cdb->volpath = strdup(volpath)) == NULL) {
 447         free(cdb);
 448         return NULL;
 449     }
 450
 451     cdb->flags = CNID_FLAG_PERSISTENT | CNID_FLAG_LAZY_INIT;
 452
 453     cdb->cnid_add = cnid_dbd_add;
 454     cdb->cnid_delete = cnid_dbd_delete;
 455     cdb->cnid_get = cnid_dbd_get;
 456     cdb->cnid_lookup = cnid_dbd_lookup;
 457     cdb->cnid_nextid = NULL;
 458     cdb->cnid_resolve = cnid_dbd_resolve;
 459     cdb->cnid_getstamp = cnid_dbd_getstamp;
 460     cdb->cnid_update = cnid_dbd_update;
 461     cdb->cnid_rebuild_add = cnid_dbd_rebuild_add;
 462     cdb->cnid_close = cnid_dbd_close;
 463
 464     return cdb;
 465 }
 466
 467 /* ---------------------- */
 468 struct _cnid_db *cnid_dbd_open(struct cnid_open_args *args)
 469 {
 470     CNID_private *db = NULL;
 471     struct _cnid_db *cdb = NULL;
 472
 473     if (!args->dir) {
 474         return NULL;
 475     }
 476
 477     if ((cdb = cnid_dbd_new(args->dir)) == NULL) {
 478         LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
 479         return NULL;
 480     }
 481
 482     if ((db = (CNID_private *)calloc(1, sizeof(CNID_private))) == NULL) {
 483         LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
 484         goto cnid_dbd_open_fail;
 485     }
 486
 487     cdb->_private = db;
 488
 489     /* We keep a copy of the directory in the db structure so that we can
 490        transparently reconnect later. */
 491     strcpy(db->db_dir, args->dir);
 492     db->magic = CNID_DB_MAGIC;
 493     db->fd = -1;
 494     db->cnidserver = strdup(args->cnidserver);
 495     db->cnidport = strdup(args->cnidport);
 496
 497     LOG(log_debug, logtype_cnid, "cnid_dbd_open: Finished initializing cnid dbd module for volume '%s'", db->db_dir);
 498
 499     return cdb;
 500
 501 cnid_dbd_open_fail:
 502     if (cdb != NULL) {
 503         if (cdb->volpath != NULL) {
 504             free(cdb->volpath);
 505         }
 506         free(cdb);
 507     }
 508     if (db != NULL)
 509         free(db);
 510
 511     return NULL;
 512 }
 513
 514 /* ---------------------- */
 515 void cnid_dbd_close(struct _cnid_db *cdb)
 516 {
 517     CNID_private *db;
 518
 519     if (!cdb) {
 520         LOG(log_error, logtype_cnid, "cnid_close called with NULL argument !");
 521         return;
 522     }
 523
 524     if ((db = cdb->_private) != NULL) {
 525         LOG(log_debug, logtype_cnid, "closing database connection for volume '%s'", db->db_dir);
 526
 527         if (db->fd >= 0)
 528             close(db->fd);
 529         free(db);
 530     }
 531
 532     free(cdb->volpath);
 533     free(cdb);
 534
 535     return;
 536 }
 537
 538 /* ---------------------- */
 539 cnid_t cnid_dbd_add(struct _cnid_db *cdb, const struct stat *st,
 540                     const cnid_t did, char *name, const size_t len,
 541                     cnid_t hint)
 542 {
 543     CNID_private *db;
 544     struct cnid_dbd_rqst rqst;
 545     struct cnid_dbd_rply rply;
 546     cnid_t id;
 547
 548     if (!cdb || !(db = cdb->_private) || !st || !name) {
 549         LOG(log_error, logtype_cnid, "cnid_add: Parameter error");
 550         errno = CNID_ERR_PARAM;
 551         return CNID_INVALID;
 552     }
 553
 554     if (len > MAXPATHLEN) {
 555         LOG(log_error, logtype_cnid, "cnid_add: Path name is too long");
 556         errno = CNID_ERR_PATH;
 557         return CNID_INVALID;
 558     }
 559
 560     RQST_RESET(&rqst);
 561     rqst.op = CNID_DBD_OP_ADD;
 562
 563     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 564         rqst.dev = st->st_dev;
 565     }
 566
 567     rqst.ino = st->st_ino;
 568     rqst.type = S_ISDIR(st->st_mode)?1:0;
 569     rqst.cnid = hint;
 570     rqst.did = did;
 571     rqst.name = name;
 572     rqst.namelen = len;
 573
 574     LOG(log_debug, logtype_cnid, "cnid_dbd_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
 575         ntohl(did), name, (long long)st->st_ino, rqst.type);
 576
 577     rply.namelen = 0;
 578     if (transmit(db, &rqst, &rply) < 0) {
 579         errno = CNID_ERR_DB;
 580         return CNID_INVALID;
 581     }
 582
 583     switch(rply.result) {
 584     case CNID_DBD_RES_OK:
 585         id = rply.cnid;
 586         LOG(log_debug, logtype_cnid, "cnid_dbd_add: got CNID: %u", ntohl(id));
 587         break;
 588     case CNID_DBD_RES_ERR_MAX:
 589         errno = CNID_ERR_MAX;
 590         id = CNID_INVALID;
 591         break;
 592     case CNID_DBD_RES_ERR_DB:
 593     case CNID_DBD_RES_ERR_DUPLCNID:
 594         errno = CNID_ERR_DB;
 595         id = CNID_INVALID;
 596         break;
 597     default:
 598         abort();
 599     }
 600
 601     return id;
 602 }
 603
 604 /* ---------------------- */
 605 cnid_t cnid_dbd_get(struct _cnid_db *cdb, const cnid_t did, char *name, const size_t len)
 606 {
 607     CNID_private *db;
 608     struct cnid_dbd_rqst rqst;
 609     struct cnid_dbd_rply rply;
 610     cnid_t id;
 611
 612     if (!cdb || !(db = cdb->_private) || !name) {
 613         LOG(log_error, logtype_cnid, "cnid_dbd_get: Parameter error");
 614         errno = CNID_ERR_PARAM;
 615         return CNID_INVALID;
 616     }
 617
 618     if (len > MAXPATHLEN) {
 619         LOG(log_error, logtype_cnid, "cnid_dbd_get: Path name is too long");
 620         errno = CNID_ERR_PATH;
 621         return CNID_INVALID;
 622     }
 623
 624     LOG(log_debug, logtype_cnid, "cnid_dbd_get: DID: %u, name: '%s'", ntohl(did), name);
 625
 626     RQST_RESET(&rqst);
 627     rqst.op = CNID_DBD_OP_GET;
 628     rqst.did = did;
 629     rqst.name = name;
 630     rqst.namelen = len;
 631
 632     rply.namelen = 0;
 633     if (transmit(db, &rqst, &rply) < 0) {
 634         errno = CNID_ERR_DB;
 635         return CNID_INVALID;
 636     }
 637
 638     switch(rply.result) {
 639     case CNID_DBD_RES_OK:
 640         id = rply.cnid;
 641         LOG(log_debug, logtype_cnid, "cnid_dbd_get: got CNID: %u", ntohl(id));
 642         break;
 643     case CNID_DBD_RES_NOTFOUND:
 644         id = CNID_INVALID;
 645         break;
 646     case CNID_DBD_RES_ERR_DB:
 647         id = CNID_INVALID;
 648         errno = CNID_ERR_DB;
 649         break;
 650     default:
 651         abort();
 652     }
 653
 654     return id;
 655 }
 656
 657 /* ---------------------- */
 658 char *cnid_dbd_resolve(struct _cnid_db *cdb, cnid_t *id, void *buffer, size_t len)
 659 {
 660     CNID_private *db;
 661     struct cnid_dbd_rqst rqst;
 662     struct cnid_dbd_rply rply;
 663     char *name;
 664
 665     if (!cdb || !(db = cdb->_private) || !id || !(*id)) {
 666         LOG(log_error, logtype_cnid, "cnid_resolve: Parameter error");
 667         errno = CNID_ERR_PARAM;
 668         return NULL;
 669     }
 670
 671     LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolving CNID: %u", ntohl(*id));
 672
 673     /* TODO: We should maybe also check len. At the moment we rely on the caller
 674        to provide a buffer that is large enough for MAXPATHLEN plus
 675        CNID_HEADER_LEN plus 1 byte, which is large enough for the maximum that
 676        can come from the database. */
 677
 678     RQST_RESET(&rqst);
 679     rqst.op = CNID_DBD_OP_RESOLVE;
 680     rqst.cnid = *id;
 681
 682     /* This mimicks the behaviour of the "regular" cnid_resolve. So far,
 683        nobody uses the content of buffer. It only provides space for the
 684        name in the caller. */
 685     rply.name = (char *)buffer + CNID_HEADER_LEN;
 686     rply.namelen = len - CNID_HEADER_LEN;
 687
 688     if (transmit(db, &rqst, &rply) < 0) {
 689         errno = CNID_ERR_DB;
 690         *id = CNID_INVALID;
 691         return NULL;
 692     }
 693
 694     switch (rply.result) {
 695     case CNID_DBD_RES_OK:
 696         *id = rply.did;
 697         name = rply.name;
 698         LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolved did: %u, name: '%s'", ntohl(*id), name);
 699         break;
 700     case CNID_DBD_RES_NOTFOUND:
 701         *id = CNID_INVALID;
 702         name = NULL;
 703         break;
 704     case CNID_DBD_RES_ERR_DB:
 705         errno = CNID_ERR_DB;
 706         *id = CNID_INVALID;
 707         name = NULL;
 708         break;
 709     default:
 710         abort();
 711     }
 712
 713     return name;
 714 }
 715
 716 /* ---------------------- */
 717 int cnid_dbd_getstamp(struct _cnid_db *cdb, void *buffer, const size_t len)
 718 {
 719     CNID_private *db;
 720
 721     if (!cdb || !(db = cdb->_private) || len != ADEDLEN_PRIVSYN) {
 722         LOG(log_error, logtype_cnid, "cnid_getstamp: Parameter error");
 723         errno = CNID_ERR_PARAM;
 724         return -1;
 725     }
 726     db->client_stamp = buffer;
 727     db->stamp_size = len;
 728     memset(buffer,0, len);
 729     return 0;
 730 }
 731
 732 /* ---------------------- */
 733 cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
 734                        char *name, const size_t len)
 735 {
 736     CNID_private *db;
 737     struct cnid_dbd_rqst rqst;
 738     struct cnid_dbd_rply rply;
 739     cnid_t id;
 740
 741     if (!cdb || !(db = cdb->_private) || !st || !name) {
 742         LOG(log_error, logtype_cnid, "cnid_lookup: Parameter error");
 743         errno = CNID_ERR_PARAM;
 744         return CNID_INVALID;
 745     }
 746
 747     if (len > MAXPATHLEN) {
 748         LOG(log_error, logtype_cnid, "cnid_lookup: Path name is too long");
 749         errno = CNID_ERR_PATH;
 750         return CNID_INVALID;
 751     }
 752
 753     RQST_RESET(&rqst);
 754     rqst.op = CNID_DBD_OP_LOOKUP;
 755
 756     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 757         rqst.dev = st->st_dev;
 758     }
 759
 760     rqst.ino = st->st_ino;
 761     rqst.type = S_ISDIR(st->st_mode)?1:0;
 762     rqst.did = did;
 763     rqst.name = name;
 764     rqst.namelen = len;
 765
 766     LOG(log_debug, logtype_cnid, "cnid_dbd_lookup: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
 767         ntohl(did), name, (long long)st->st_ino, rqst.type);
 768
 769     rply.namelen = 0;
 770     if (transmit(db, &rqst, &rply) < 0) {
 771         errno = CNID_ERR_DB;
 772         return CNID_INVALID;
 773     }
 774
 775     switch (rply.result) {
 776     case CNID_DBD_RES_OK:
 777         id = rply.cnid;
 778         LOG(log_debug, logtype_cnid, "cnid_dbd_lookup: got CNID: %u", ntohl(id));
 779         break;
 780     case CNID_DBD_RES_NOTFOUND:
 781         id = CNID_INVALID;
 782         break;
 783     case CNID_DBD_RES_ERR_DB:
 784         errno = CNID_ERR_DB;
 785         id = CNID_INVALID;
 786         break;
 787     default:
 788         abort();
 789     }
 790
 791     return id;
 792 }
 793
 794 /* ---------------------- */
 795 int cnid_dbd_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
 796                     const cnid_t did, char *name, const size_t len)
 797 {
 798     CNID_private *db;
 799     struct cnid_dbd_rqst rqst;
 800     struct cnid_dbd_rply rply;
 801
 802     if (!cdb || !(db = cdb->_private) || !id || !st || !name) {
 803         LOG(log_error, logtype_cnid, "cnid_update: Parameter error");
 804         errno = CNID_ERR_PARAM;
 805         return -1;
 806     }
 807
 808     if (len > MAXPATHLEN) {
 809         LOG(log_error, logtype_cnid, "cnid_update: Path name is too long");
 810         errno = CNID_ERR_PATH;
 811         return -1;
 812     }
 813
 814     RQST_RESET(&rqst);
 815     rqst.op = CNID_DBD_OP_UPDATE;
 816     rqst.cnid = id;
 817     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 818         rqst.dev = st->st_dev;
 819     }
 820     rqst.ino = st->st_ino;
 821     rqst.type = S_ISDIR(st->st_mode)?1:0;
 822     rqst.did = did;
 823     rqst.name = name;
 824     rqst.namelen = len;
 825
 826     LOG(log_debug, logtype_cnid, "cnid_dbd_update: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
 827         ntohl(id), name, (long long)st->st_ino, rqst.type);
 828
 829     rply.namelen = 0;
 830     if (transmit(db, &rqst, &rply) < 0) {
 831         errno = CNID_ERR_DB;
 832         return -1;
 833     }
 834
 835     switch (rply.result) {
 836     case CNID_DBD_RES_OK:
 837         LOG(log_debug, logtype_cnid, "cnid_dbd_update: updated");
 838     case CNID_DBD_RES_NOTFOUND:
 839         return 0;
 840     case CNID_DBD_RES_ERR_DB:
 841         errno = CNID_ERR_DB;
 842         return -1;
 843     default:
 844         abort();
 845     }
 846 }
 847
 848 /* ---------------------- */
 849 cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
 850                             const cnid_t did, char *name, const size_t len,
 851                             cnid_t hint)
 852 {
 853     CNID_private *db;
 854     struct cnid_dbd_rqst rqst;
 855     struct cnid_dbd_rply rply;
 856     cnid_t id;
 857
 858     if (!cdb || !(db = cdb->_private) || !st || !name || hint == CNID_INVALID) {
 859         LOG(log_error, logtype_cnid, "cnid_rebuild_add: Parameter error");
 860         errno = CNID_ERR_PARAM;
 861         return CNID_INVALID;
 862     }
 863
 864     if (len > MAXPATHLEN) {
 865         LOG(log_error, logtype_cnid, "cnid_rebuild_add: Path name is too long");
 866         errno = CNID_ERR_PATH;
 867         return CNID_INVALID;
 868     }
 869
 870     RQST_RESET(&rqst);
 871     rqst.op = CNID_DBD_OP_REBUILD_ADD;
 872
 873     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 874         rqst.dev = st->st_dev;
 875     }
 876
 877     rqst.ino = st->st_ino;
 878     rqst.type = S_ISDIR(st->st_mode)?1:0;
 879     rqst.did = did;
 880     rqst.name = name;
 881     rqst.namelen = len;
 882     rqst.cnid = hint;
 883
 884     LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir), hint: %u",
 885         ntohl(did), name, (long long)st->st_ino, rqst.type, hint);
 886
 887     if (transmit(db, &rqst, &rply) < 0) {
 888         errno = CNID_ERR_DB;
 889         return CNID_INVALID;
 890     }
 891
 892     switch(rply.result) {
 893     case CNID_DBD_RES_OK:
 894         id = rply.cnid;
 895         LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: got CNID: %u", ntohl(id));
 896         break;
 897     case CNID_DBD_RES_ERR_MAX:
 898         errno = CNID_ERR_MAX;
 899         id = CNID_INVALID;
 900         break;
 901     case CNID_DBD_RES_ERR_DB:
 902     case CNID_DBD_RES_ERR_DUPLCNID:
 903         errno = CNID_ERR_DB;
 904         id = CNID_INVALID;
 905         break;
 906     default:
 907         abort();
 908     }
 909     return id;
 910 }
 911
 912 /* ---------------------- */
 913 int cnid_dbd_delete(struct _cnid_db *cdb, const cnid_t id)
 914 {
 915     CNID_private *db;
 916     struct cnid_dbd_rqst rqst;
 917     struct cnid_dbd_rply rply;
 918
 919     if (!cdb || !(db = cdb->_private) || !id) {
 920         LOG(log_error, logtype_cnid, "cnid_delete: Parameter error");
 921         errno = CNID_ERR_PARAM;
 922         return -1;
 923     }
 924
 925     LOG(log_debug, logtype_cnid, "cnid_dbd_delete: delete CNID: %u", ntohl(id));
 926
 927     RQST_RESET(&rqst);
 928     rqst.op = CNID_DBD_OP_DELETE;
 929     rqst.cnid = id;
 930
 931     rply.namelen = 0;
 932     if (transmit(db, &rqst, &rply) < 0) {
 933         errno = CNID_ERR_DB;
 934         return -1;
 935     }
 936
 937     switch (rply.result) {
 938     case CNID_DBD_RES_OK:
 939         LOG(log_debug, logtype_cnid, "cnid_dbd_delete: deleted CNID: %u", ntohl(id));
 940     case CNID_DBD_RES_NOTFOUND:
 941         return 0;
 942     case CNID_DBD_RES_ERR_DB:
 943         errno = CNID_ERR_DB;
 944         return -1;
 945     default:
 946         abort();
 947     }
 948 }
 949
 950
 951 struct _cnid_module cnid_dbd_module = {
 952     "dbd",
 953     {NULL, NULL},
 954     cnid_dbd_open,
 955     0
 956 };
 957
 958 #endif /* CNID_DBD */
 959