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