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