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