libatalk/cnid/dbd/cnid_dbd.c

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