libatalk/cnid/dbd/cnid_dbd.c

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