libatalk/cnid/dbd/cnid_dbd.c

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