libatalk/cnid/dbd/cnid_dbd.c

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