libatalk/cnid/dbd/cnid_dbd.c

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