libatalk/cnid/dbd/cnid_dbd.c

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