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_find = cnid_dbd_find;
 458     cdb->cnid_nextid = NULL;
 459     cdb->cnid_resolve = cnid_dbd_resolve;
 460     cdb->cnid_getstamp = cnid_dbd_getstamp;
 461     cdb->cnid_update = cnid_dbd_update;
 462     cdb->cnid_rebuild_add = cnid_dbd_rebuild_add;
 463     cdb->cnid_close = cnid_dbd_close;
 464
 465     return cdb;
 466 }
 467
 468 /* ---------------------- */
 469 struct _cnid_db *cnid_dbd_open(struct cnid_open_args *args)
 470 {
 471     CNID_private *db = NULL;
 472     struct _cnid_db *cdb = NULL;
 473
 474     if (!args->dir) {
 475         return NULL;
 476     }
 477
 478     if ((cdb = cnid_dbd_new(args->dir)) == NULL) {
 479         LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
 480         return NULL;
 481     }
 482
 483     if ((db = (CNID_private *)calloc(1, sizeof(CNID_private))) == NULL) {
 484         LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
 485         goto cnid_dbd_open_fail;
 486     }
 487
 488     cdb->_private = db;
 489
 490     /* We keep a copy of the directory in the db structure so that we can
 491        transparently reconnect later. */
 492     strcpy(db->db_dir, args->dir);
 493     db->magic = CNID_DB_MAGIC;
 494     db->fd = -1;
 495     db->cnidserver = strdup(args->cnidserver);
 496     db->cnidport = strdup(args->cnidport);
 497
 498     LOG(log_debug, logtype_cnid, "cnid_dbd_open: Finished initializing cnid dbd module for volume '%s'", db->db_dir);
 499
 500     return cdb;
 501
 502 cnid_dbd_open_fail:
 503     if (cdb != NULL) {
 504         if (cdb->volpath != NULL) {
 505             free(cdb->volpath);
 506         }
 507         free(cdb);
 508     }
 509     if (db != NULL)
 510         free(db);
 511
 512     return NULL;
 513 }
 514
 515 /* ---------------------- */
 516 void cnid_dbd_close(struct _cnid_db *cdb)
 517 {
 518     CNID_private *db;
 519
 520     if (!cdb) {
 521         LOG(log_error, logtype_cnid, "cnid_close called with NULL argument !");
 522         return;
 523     }
 524
 525     if ((db = cdb->_private) != NULL) {
 526         LOG(log_debug, logtype_cnid, "closing database connection for volume '%s'", db->db_dir);
 527
 528         if (db->fd >= 0)
 529             close(db->fd);
 530         free(db);
 531     }
 532
 533     free(cdb->volpath);
 534     free(cdb);
 535
 536     return;
 537 }
 538
 539 /* ---------------------- */
 540 cnid_t cnid_dbd_add(struct _cnid_db *cdb, const struct stat *st,
 541                     const cnid_t did, char *name, const size_t len,
 542                     cnid_t hint)
 543 {
 544     CNID_private *db;
 545     struct cnid_dbd_rqst rqst;
 546     struct cnid_dbd_rply rply;
 547     cnid_t id;
 548
 549     if (!cdb || !(db = cdb->_private) || !st || !name) {
 550         LOG(log_error, logtype_cnid, "cnid_add: Parameter error");
 551         errno = CNID_ERR_PARAM;
 552         return CNID_INVALID;
 553     }
 554
 555     if (len > MAXPATHLEN) {
 556         LOG(log_error, logtype_cnid, "cnid_add: Path name is too long");
 557         errno = CNID_ERR_PATH;
 558         return CNID_INVALID;
 559     }
 560
 561     RQST_RESET(&rqst);
 562     rqst.op = CNID_DBD_OP_ADD;
 563
 564     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 565         rqst.dev = st->st_dev;
 566     }
 567
 568     rqst.ino = st->st_ino;
 569     rqst.type = S_ISDIR(st->st_mode)?1:0;
 570     rqst.cnid = hint;
 571     rqst.did = did;
 572     rqst.name = name;
 573     rqst.namelen = len;
 574
 575     LOG(log_debug, logtype_cnid, "cnid_dbd_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
 576         ntohl(did), name, (long long)st->st_ino, rqst.type);
 577
 578     rply.namelen = 0;
 579     if (transmit(db, &rqst, &rply) < 0) {
 580         errno = CNID_ERR_DB;
 581         return CNID_INVALID;
 582     }
 583
 584     switch(rply.result) {
 585     case CNID_DBD_RES_OK:
 586         id = rply.cnid;
 587         LOG(log_debug, logtype_cnid, "cnid_dbd_add: got CNID: %u", ntohl(id));
 588         break;
 589     case CNID_DBD_RES_ERR_MAX:
 590         errno = CNID_ERR_MAX;
 591         id = CNID_INVALID;
 592         break;
 593     case CNID_DBD_RES_ERR_DB:
 594     case CNID_DBD_RES_ERR_DUPLCNID:
 595         errno = CNID_ERR_DB;
 596         id = CNID_INVALID;
 597         break;
 598     default:
 599         abort();
 600     }
 601
 602     return id;
 603 }
 604
 605 /* ---------------------- */
 606 cnid_t cnid_dbd_get(struct _cnid_db *cdb, const cnid_t did, char *name, const size_t len)
 607 {
 608     CNID_private *db;
 609     struct cnid_dbd_rqst rqst;
 610     struct cnid_dbd_rply rply;
 611     cnid_t id;
 612
 613     if (!cdb || !(db = cdb->_private) || !name) {
 614         LOG(log_error, logtype_cnid, "cnid_dbd_get: Parameter error");
 615         errno = CNID_ERR_PARAM;
 616         return CNID_INVALID;
 617     }
 618
 619     if (len > MAXPATHLEN) {
 620         LOG(log_error, logtype_cnid, "cnid_dbd_get: Path name is too long");
 621         errno = CNID_ERR_PATH;
 622         return CNID_INVALID;
 623     }
 624
 625     LOG(log_debug, logtype_cnid, "cnid_dbd_get: DID: %u, name: '%s'", ntohl(did), name);
 626
 627     RQST_RESET(&rqst);
 628     rqst.op = CNID_DBD_OP_GET;
 629     rqst.did = did;
 630     rqst.name = name;
 631     rqst.namelen = len;
 632
 633     rply.namelen = 0;
 634     if (transmit(db, &rqst, &rply) < 0) {
 635         errno = CNID_ERR_DB;
 636         return CNID_INVALID;
 637     }
 638
 639     switch(rply.result) {
 640     case CNID_DBD_RES_OK:
 641         id = rply.cnid;
 642         LOG(log_debug, logtype_cnid, "cnid_dbd_get: got CNID: %u", ntohl(id));
 643         break;
 644     case CNID_DBD_RES_NOTFOUND:
 645         id = CNID_INVALID;
 646         break;
 647     case CNID_DBD_RES_ERR_DB:
 648         id = CNID_INVALID;
 649         errno = CNID_ERR_DB;
 650         break;
 651     default:
 652         abort();
 653     }
 654
 655     return id;
 656 }
 657
 658 /* ---------------------- */
 659 char *cnid_dbd_resolve(struct _cnid_db *cdb, cnid_t *id, void *buffer, size_t len)
 660 {
 661     CNID_private *db;
 662     struct cnid_dbd_rqst rqst;
 663     struct cnid_dbd_rply rply;
 664     char *name;
 665
 666     if (!cdb || !(db = cdb->_private) || !id || !(*id)) {
 667         LOG(log_error, logtype_cnid, "cnid_resolve: Parameter error");
 668         errno = CNID_ERR_PARAM;
 669         return NULL;
 670     }
 671
 672     LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolving CNID: %u", ntohl(*id));
 673
 674     /* TODO: We should maybe also check len. At the moment we rely on the caller
 675        to provide a buffer that is large enough for MAXPATHLEN plus
 676        CNID_HEADER_LEN plus 1 byte, which is large enough for the maximum that
 677        can come from the database. */
 678
 679     RQST_RESET(&rqst);
 680     rqst.op = CNID_DBD_OP_RESOLVE;
 681     rqst.cnid = *id;
 682
 683     /* Pass buffer to transmit so it can stuff the reply data there */
 684     rply.name = (char *)buffer;
 685     rply.namelen = 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 + CNID_NAME_OFS;
 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_find(struct _cnid_db *cdb, char *name, size_t namelen, void *buffer, size_t buflen)
 795 {
 796     CNID_private *db;
 797     struct cnid_dbd_rqst rqst;
 798     struct cnid_dbd_rply rply;
 799     int count;
 800
 801     if (!cdb || !(db = cdb->_private) || !name) {
 802         LOG(log_error, logtype_cnid, "cnid_find: Parameter error");
 803         errno = CNID_ERR_PARAM;
 804         return CNID_INVALID;
 805     }
 806
 807     if (namelen > MAXPATHLEN) {
 808         LOG(log_error, logtype_cnid, "cnid_find: Path name is too long");
 809         errno = CNID_ERR_PATH;
 810         return CNID_INVALID;
 811     }
 812
 813     LOG(log_debug, logtype_cnid, "cnid_find(\"%s\")", name);
 814
 815     RQST_RESET(&rqst);
 816     rqst.op = CNID_DBD_OP_SEARCH;
 817
 818     rqst.name = name;
 819     rqst.namelen = namelen;
 820
 821     rply.name = buffer;
 822     rply.namelen = buflen;
 823
 824     if (transmit(db, &rqst, &rply) < 0) {
 825         errno = CNID_ERR_DB;
 826         return CNID_INVALID;
 827     }
 828
 829     switch (rply.result) {
 830     case CNID_DBD_RES_OK:
 831         count = rply.namelen / sizeof(cnid_t);
 832         LOG(log_debug, logtype_cnid, "cnid_find: got %d matches", count);
 833         break;
 834     case CNID_DBD_RES_NOTFOUND:
 835         count = 0;
 836         break;
 837     case CNID_DBD_RES_ERR_DB:
 838         errno = CNID_ERR_DB;
 839         count = -1;
 840         break;
 841     default:
 842         abort();
 843     }
 844
 845     return count;
 846 }
 847
 848 /* ---------------------- */
 849 int cnid_dbd_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
 850                     const cnid_t did, char *name, const size_t len)
 851 {
 852     CNID_private *db;
 853     struct cnid_dbd_rqst rqst;
 854     struct cnid_dbd_rply rply;
 855
 856     if (!cdb || !(db = cdb->_private) || !id || !st || !name) {
 857         LOG(log_error, logtype_cnid, "cnid_update: Parameter error");
 858         errno = CNID_ERR_PARAM;
 859         return -1;
 860     }
 861
 862     if (len > MAXPATHLEN) {
 863         LOG(log_error, logtype_cnid, "cnid_update: Path name is too long");
 864         errno = CNID_ERR_PATH;
 865         return -1;
 866     }
 867
 868     RQST_RESET(&rqst);
 869     rqst.op = CNID_DBD_OP_UPDATE;
 870     rqst.cnid = id;
 871     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 872         rqst.dev = st->st_dev;
 873     }
 874     rqst.ino = st->st_ino;
 875     rqst.type = S_ISDIR(st->st_mode)?1:0;
 876     rqst.did = did;
 877     rqst.name = name;
 878     rqst.namelen = len;
 879
 880     LOG(log_debug, logtype_cnid, "cnid_dbd_update: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
 881         ntohl(id), name, (long long)st->st_ino, rqst.type);
 882
 883     rply.namelen = 0;
 884     if (transmit(db, &rqst, &rply) < 0) {
 885         errno = CNID_ERR_DB;
 886         return -1;
 887     }
 888
 889     switch (rply.result) {
 890     case CNID_DBD_RES_OK:
 891         LOG(log_debug, logtype_cnid, "cnid_dbd_update: updated");
 892     case CNID_DBD_RES_NOTFOUND:
 893         return 0;
 894     case CNID_DBD_RES_ERR_DB:
 895         errno = CNID_ERR_DB;
 896         return -1;
 897     default:
 898         abort();
 899     }
 900 }
 901
 902 /* ---------------------- */
 903 cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
 904                             const cnid_t did, char *name, const size_t len,
 905                             cnid_t hint)
 906 {
 907     CNID_private *db;
 908     struct cnid_dbd_rqst rqst;
 909     struct cnid_dbd_rply rply;
 910     cnid_t id;
 911
 912     if (!cdb || !(db = cdb->_private) || !st || !name || hint == CNID_INVALID) {
 913         LOG(log_error, logtype_cnid, "cnid_rebuild_add: Parameter error");
 914         errno = CNID_ERR_PARAM;
 915         return CNID_INVALID;
 916     }
 917
 918     if (len > MAXPATHLEN) {
 919         LOG(log_error, logtype_cnid, "cnid_rebuild_add: Path name is too long");
 920         errno = CNID_ERR_PATH;
 921         return CNID_INVALID;
 922     }
 923
 924     RQST_RESET(&rqst);
 925     rqst.op = CNID_DBD_OP_REBUILD_ADD;
 926
 927     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 928         rqst.dev = st->st_dev;
 929     }
 930
 931     rqst.ino = st->st_ino;
 932     rqst.type = S_ISDIR(st->st_mode)?1:0;
 933     rqst.did = did;
 934     rqst.name = name;
 935     rqst.namelen = len;
 936     rqst.cnid = hint;
 937
 938     LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir), hint: %u",
 939         ntohl(did), name, (long long)st->st_ino, rqst.type, hint);
 940
 941     if (transmit(db, &rqst, &rply) < 0) {
 942         errno = CNID_ERR_DB;
 943         return CNID_INVALID;
 944     }
 945
 946     switch(rply.result) {
 947     case CNID_DBD_RES_OK:
 948         id = rply.cnid;
 949         LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: got CNID: %u", ntohl(id));
 950         break;
 951     case CNID_DBD_RES_ERR_MAX:
 952         errno = CNID_ERR_MAX;
 953         id = CNID_INVALID;
 954         break;
 955     case CNID_DBD_RES_ERR_DB:
 956     case CNID_DBD_RES_ERR_DUPLCNID:
 957         errno = CNID_ERR_DB;
 958         id = CNID_INVALID;
 959         break;
 960     default:
 961         abort();
 962     }
 963     return id;
 964 }
 965
 966 /* ---------------------- */
 967 int cnid_dbd_delete(struct _cnid_db *cdb, const cnid_t id)
 968 {
 969     CNID_private *db;
 970     struct cnid_dbd_rqst rqst;
 971     struct cnid_dbd_rply rply;
 972
 973     if (!cdb || !(db = cdb->_private) || !id) {
 974         LOG(log_error, logtype_cnid, "cnid_delete: Parameter error");
 975         errno = CNID_ERR_PARAM;
 976         return -1;
 977     }
 978
 979     LOG(log_debug, logtype_cnid, "cnid_dbd_delete: delete CNID: %u", ntohl(id));
 980
 981     RQST_RESET(&rqst);
 982     rqst.op = CNID_DBD_OP_DELETE;
 983     rqst.cnid = id;
 984
 985     rply.namelen = 0;
 986     if (transmit(db, &rqst, &rply) < 0) {
 987         errno = CNID_ERR_DB;
 988         return -1;
 989     }
 990
 991     switch (rply.result) {
 992     case CNID_DBD_RES_OK:
 993         LOG(log_debug, logtype_cnid, "cnid_dbd_delete: deleted CNID: %u", ntohl(id));
 994     case CNID_DBD_RES_NOTFOUND:
 995         return 0;
 996     case CNID_DBD_RES_ERR_DB:
 997         errno = CNID_ERR_DB;
 998         return -1;
 999     default:
1000         abort();
1001     }
1002 }
1003
1004
1005 struct _cnid_module cnid_dbd_module = {
1006     "dbd",
1007     {NULL, NULL},
1008     cnid_dbd_open,
1009     0
1010 };
1011
1012 #endif /* CNID_DBD */
1013