libatalk/cnid/dbd/cnid_dbd.c

   1 /*
   2  * $Id: cnid_dbd.c,v 1.17 2010-03-31 09:47:32 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 #define MAX_DELAY 10
  56
  57 /* *MUST* be < afp tickle or it's never triggered (got EINTR first) */
  58 #define SOCK_DELAY 11
  59
  60 static void delay(int sec)
  61 {
  62     struct timeval tv;
  63
  64     tv.tv_usec = 0;
  65     tv.tv_sec  = sec;
  66     select(0, NULL, NULL, NULL, &tv);
  67 }
  68
  69 static int tsock_getfd(const char *host, const char *port)
  70 {
  71     int sock = -1;
  72     struct timeval tv;
  73     int attr;
  74     int err;
  75     struct addrinfo hints, *servinfo, *p;
  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", host, port, gai_strerror(err));
  85         return -1;
  86     }
  87
  88     /* loop through all the results and bind to the first we can */
  89     for (p = servinfo; p != NULL; p = p->ai_next) {
  90         if ((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
  91             LOG(log_info, logtype_default, "tsock_getfd: socket CNID server %s:: %s", host, strerror(errno));
  92                 continue;
  93         }
  94
  95         attr = 1;
  96         if (setsockopt(sock, SOL_TCP, TCP_NODELAY, &attr, sizeof(attr)) == -1) {
  97             LOG(log_error, logtype_cnid, "getfd: set TCP_NODELAY CNID server %s: %s", host, strerror(errno));
  98             close(sock);
  99             continue;
 100         }
 101
 102         tv.tv_sec = SOCK_DELAY;
 103         tv.tv_usec = 0;
 104         if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
 105             LOG(log_error, logtype_cnid, "getfd: set SO_RCVTIMEO CNID server %s: %s", host, strerror(errno));
 106             close(sock);
 107             continue;
 108         }
 109
 110         tv.tv_sec = SOCK_DELAY;
 111         tv.tv_usec = 0;
 112         if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) {
 113             LOG(log_error, logtype_cnid, "getfd: set SO_SNDTIMEO CNID server %s: %s", host, strerror(errno));
 114             close(sock);
 115             continue;
 116         }
 117
 118         if (connect(sock, p->ai_addr, p->ai_addrlen) == -1) {
 119             err = errno;
 120             close(sock);
 121             sock=-1;
 122             LOG(log_error, logtype_cnid, "getfd: connect CNID server %s: %s", host, strerror(err));
 123             continue;
 124         }
 125
 126         /* We've got a socket */
 127         break;
 128     }
 129
 130     freeaddrinfo(servinfo);
 131
 132     if (p == NULL) {
 133         LOG(log_error, logtype_cnid, "tsock_getfd: no suitable network config from CNID server %s:%s", host, port);
 134         return -1;
 135     }
 136
 137     return(sock);
 138 }
 139
 140 /* --------------------- */
 141 static int write_vec(int fd, struct iovec *iov, size_t towrite)
 142 {
 143     ssize_t len;
 144     size_t len1;
 145
 146     LOG(log_maxdebug, logtype_cnid, "write_vec: request to write %d bytes", towrite);
 147
 148     len1 =  iov[1].iov_len;
 149     while (towrite > 0) {
 150         if (((len = writev(fd, iov, 2)) == -1 && errno == EINTR) || !len)
 151             continue;
 152
 153         if ((size_t)len == towrite) /* wrote everything out */
 154             break;
 155         else if (len < 0) { /* error */
 156             return -1;
 157         }
 158
 159         towrite -= len;
 160         if (towrite > len1) { /* skip part of header */
 161             iov[0].iov_base = (char *) iov[0].iov_base + len;
 162             iov[0].iov_len -= len;
 163         } else { /* skip to data */
 164             if (iov[0].iov_len) {
 165                 len -= iov[0].iov_len;
 166                 iov[0].iov_len = 0;
 167             }
 168             iov[1].iov_base = (char *) iov[1].iov_base + len;
 169             iov[1].iov_len -= len;
 170         }
 171     }
 172
 173     LOG(log_maxdebug, logtype_cnid, "write_vec: wrote %d bytes", towrite);
 174
 175     return 0;
 176 }
 177
 178 /* --------------------- */
 179 static int init_tsock(CNID_private *db)
 180 {
 181     int fd;
 182     int len;
 183     struct iovec iov[2];
 184
 185     LOG(log_debug, logtype_cnid, "init_tsock: BEGIN. Opening volume '%s', CNID Server: %s/%s",
 186         db->db_dir, db->cnidserver, db->cnidport);
 187
 188     if ((fd = tsock_getfd(db->cnidserver, db->cnidport)) < 0)
 189         return -1;
 190
 191     len = strlen(db->db_dir);
 192
 193     iov[0].iov_base = &len;
 194     iov[0].iov_len  = sizeof(int);
 195
 196     iov[1].iov_base = db->db_dir;
 197     iov[1].iov_len  = len;
 198
 199     if (write_vec(fd, iov, len + sizeof(int)) < 0) {
 200         LOG(log_error, logtype_cnid, "init_tsock: Error/short write: %s", strerror(errno));
 201         close(fd);
 202         return -1;
 203     }
 204
 205     LOG(log_debug, logtype_cnid, "init_tsock: ok");
 206
 207     return fd;
 208 }
 209
 210 /* --------------------- */
 211 static int send_packet(CNID_private *db, struct cnid_dbd_rqst *rqst)
 212 {
 213     struct iovec iov[2];
 214     size_t towrite;
 215
 216     LOG(log_maxdebug, logtype_cnid, "send_packet: BEGIN");
 217
 218     if (!rqst->namelen) {
 219         if (write(db->fd, rqst, sizeof(struct cnid_dbd_rqst)) != sizeof(struct cnid_dbd_rqst)) {
 220             LOG(log_warning, logtype_cnid, "send_packet: Error/short write rqst (db_dir %s): %s",
 221                 db->db_dir, strerror(errno));
 222             return -1;
 223         }
 224         LOG(log_maxdebug, logtype_cnid, "send_packet: OK");
 225         return 0;
 226     }
 227
 228     iov[0].iov_base = rqst;
 229     iov[0].iov_len  = sizeof(struct cnid_dbd_rqst);
 230
 231     iov[1].iov_base = rqst->name;
 232     iov[1].iov_len  = rqst->namelen;
 233
 234     towrite = sizeof(struct cnid_dbd_rqst) +rqst->namelen;
 235
 236     if (write_vec(db->fd, iov, towrite) < 0) {
 237         LOG(log_warning, logtype_cnid, "send_packet: Error writev rqst (db_dir %s): %s",
 238             db->db_dir, strerror(errno));
 239         return -1;
 240     }
 241
 242     LOG(log_maxdebug, logtype_cnid, "send_packet: OK");
 243     return 0;
 244 }
 245
 246 /* ------------------- */
 247 static void dbd_initstamp(struct cnid_dbd_rqst *rqst)
 248 {
 249     RQST_RESET(rqst);
 250     rqst->op = CNID_DBD_OP_GETSTAMP;
 251 }
 252
 253 /* ------------------- */
 254 static int dbd_reply_stamp(struct cnid_dbd_rply *rply)
 255 {
 256     switch (rply->result) {
 257     case CNID_DBD_RES_OK:
 258         break;
 259     case CNID_DBD_RES_NOTFOUND:
 260         return -1;
 261     case CNID_DBD_RES_ERR_DB:
 262     default:
 263         errno = CNID_ERR_DB;
 264         return -1;
 265     }
 266     return 0;
 267 }
 268
 269 /* ------------------- */
 270 static ssize_t dbd_read(int socket, void *data, const size_t length)
 271 {
 272     size_t stored;
 273     ssize_t len;
 274
 275     stored = 0;
 276     while (stored < length) {
 277         len = read(socket, (u_int8_t *) data + stored, length - stored);
 278         if (len == -1) {
 279             if (errno == EINTR)
 280                 continue;
 281             return -1;
 282         }
 283         else if (len > 0)
 284             stored += len;
 285         else
 286             break;
 287     }
 288     return stored;
 289 }
 290
 291 /* ---------------------
 292  * send a request and get reply
 293  * assume send is non blocking
 294  * if no answer after sometime (at least MAX_DELAY secondes) return an error
 295  */
 296 static int dbd_rpc(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
 297 {
 298     ssize_t ret;
 299     char *nametmp;
 300     size_t len;
 301
 302     LOG(log_maxdebug, logtype_cnid, "dbd_rpc: BEGIN");
 303
 304     if (send_packet(db, rqst) < 0) {
 305         return -1;
 306     }
 307     len = rply->namelen;
 308     nametmp = rply->name;
 309
 310     ret = dbd_read(db->fd, rply, sizeof(struct cnid_dbd_rply));
 311
 312     if (ret != sizeof(struct cnid_dbd_rply)) {
 313         LOG(log_error, logtype_cnid, "dbd_rpc: Error reading header from fd (db_dir %s): %s",
 314             db->db_dir, ret == -1?strerror(errno):"closed");
 315         rply->name = nametmp;
 316         return -1;
 317     }
 318     rply->name = nametmp;
 319     if (rply->namelen && rply->namelen > len) {
 320         LOG(log_error, logtype_cnid,
 321             "dbd_rpc: Error reading name (db_dir %s): %s name too long: %d. only wanted %d, garbage?",
 322             db->db_dir, rply->name, rply->namelen, len);
 323         return -1;
 324     }
 325     if (rply->namelen && (ret = dbd_read(db->fd, rply->name, rply->namelen)) != (ssize_t)rply->namelen) {
 326         LOG(log_error, logtype_cnid, "dbd_rpc: Error reading name from fd (db_dir %s): %s",
 327             db->db_dir, ret == -1?strerror(errno):"closed");
 328         return -1;
 329     }
 330
 331     LOG(log_maxdebug, logtype_cnid, "dbd_rpc: END");
 332
 333     return 0;
 334 }
 335
 336 /* -------------------- */
 337 static int transmit(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
 338 {
 339     time_t orig, t;
 340     int clean = 1; /* no errors so far - to prevent sleep on first try */
 341
 342     LOG(log_debug7, logtype_cnid, "transmit: BEGIN");
 343
 344     if (db->changed) {
 345         /* volume and db don't have the same timestamp
 346          */
 347         return -1;
 348     }
 349     while (1) {
 350         if (db->fd == -1) {
 351             struct cnid_dbd_rqst rqst_stamp;
 352             struct cnid_dbd_rply rply_stamp;
 353             char  stamp[ADEDLEN_PRIVSYN];
 354
 355             LOG(log_debug, logtype_cnid, "transmit: connecting to cnid_dbd ...");
 356             if ((db->fd = init_tsock(db)) < 0) {
 357                 goto transmit_fail;
 358             }
 359             dbd_initstamp(&rqst_stamp);
 360             memset(stamp, 0, ADEDLEN_PRIVSYN);
 361             rply_stamp.name = stamp;
 362             rply_stamp.namelen = ADEDLEN_PRIVSYN;
 363
 364             if (dbd_rpc(db, &rqst_stamp, &rply_stamp) < 0)
 365                 goto transmit_fail;
 366             if (dbd_reply_stamp(&rply_stamp ) < 0)
 367                 goto transmit_fail;
 368
 369             if (db->notfirst) {
 370                 LOG(log_debug7, logtype_cnid, "transmit: reconnected to cnid_dbd, comparing database stamps...");
 371                 if (memcmp(stamp, db->stamp, ADEDLEN_PRIVSYN)) {
 372                     LOG(log_error, logtype_cnid, "transmit: ... not the same db!");
 373                     db->changed = 1;
 374                     return -1;
 375                 }
 376                 LOG(log_debug7, logtype_cnid, "transmit: ... OK.");
 377             }
 378             else {
 379                 db->notfirst = 1;
 380                 if (db->client_stamp)
 381                     memcpy(db->client_stamp, stamp, ADEDLEN_PRIVSYN);
 382                 memcpy(db->stamp, stamp, ADEDLEN_PRIVSYN);
 383             }
 384             LOG(log_debug, logtype_cnid, "transmit: succesfully attached to cnid_dbd for volume '%s' with stamp '%08lx'.",
 385                 db->db_dir, *(uint64_t *)stamp);
 386         }
 387         if (!dbd_rpc(db, rqst, rply)) {
 388             LOG(log_debug7, logtype_cnid, "transmit: END OK");
 389             return 0;
 390         }
 391     transmit_fail:
 392         if (db->fd != -1) {
 393             close(db->fd);
 394             db->fd = -1; /* FD not valid... will need to reconnect */
 395         }
 396
 397         if (!clean) { /* don't sleep if just got disconnected by cnid server */
 398             time(&t);
 399             if (t - orig > MAX_DELAY) {
 400                 LOG(log_error, logtype_cnid, "transmit: Request to dbd daemon (db_dir %s) timed out.", db->db_dir);
 401                 return -1;
 402             }
 403             /* sleep a little before retry */
 404             delay(2);
 405         } else {
 406             clean = 0; /* false... next time sleep */
 407             time(&orig);
 408         }
 409     }
 410     return -1;
 411 }
 412
 413 /* ---------------------- */
 414 static struct _cnid_db *cnid_dbd_new(const char *volpath)
 415 {
 416     struct _cnid_db *cdb;
 417
 418     if ((cdb = (struct _cnid_db *)calloc(1, sizeof(struct _cnid_db))) == NULL)
 419         return NULL;
 420
 421     if ((cdb->volpath = strdup(volpath)) == NULL) {
 422         free(cdb);
 423         return NULL;
 424     }
 425
 426     cdb->flags = CNID_FLAG_PERSISTENT | CNID_FLAG_LAZY_INIT;
 427
 428     cdb->cnid_add = cnid_dbd_add;
 429     cdb->cnid_delete = cnid_dbd_delete;
 430     cdb->cnid_get = cnid_dbd_get;
 431     cdb->cnid_lookup = cnid_dbd_lookup;
 432     cdb->cnid_nextid = NULL;
 433     cdb->cnid_resolve = cnid_dbd_resolve;
 434     cdb->cnid_getstamp = cnid_dbd_getstamp;
 435     cdb->cnid_update = cnid_dbd_update;
 436     cdb->cnid_rebuild_add = cnid_dbd_rebuild_add;
 437     cdb->cnid_close = cnid_dbd_close;
 438
 439     return cdb;
 440 }
 441
 442 /* ---------------------- */
 443 struct _cnid_db *cnid_dbd_open(struct cnid_open_args *args)
 444 {
 445     CNID_private *db = NULL;
 446     struct _cnid_db *cdb = NULL;
 447
 448     if (!args->dir) {
 449         return NULL;
 450     }
 451
 452     if ((cdb = cnid_dbd_new(args->dir)) == NULL) {
 453         LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
 454         return NULL;
 455     }
 456
 457     if ((db = (CNID_private *)calloc(1, sizeof(CNID_private))) == NULL) {
 458         LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
 459         goto cnid_dbd_open_fail;
 460     }
 461
 462     cdb->_private = db;
 463
 464     /* We keep a copy of the directory in the db structure so that we can
 465        transparently reconnect later. */
 466     strcpy(db->db_dir, args->dir);
 467     db->magic = CNID_DB_MAGIC;
 468     db->fd = -1;
 469     db->cnidserver = strdup(args->cnidserver);
 470     db->cnidport = strdup(args->cnidport);
 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