libatalk/cnid/dbd/cnid_dbd.c

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