libatalk/cnid/dbd/cnid_dbd.c

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