libatalk/cnid/dbd/cnid_dbd.c

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