libatalk/cnid/dbd/cnid_dbd.c

   1 /*
   2  * $Id: cnid_dbd.c,v 1.3 2005-05-03 14:55:13 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
 308     if (db->changed) {
 309         /* volume and db don't have the same timestamp
 310         */
 311         return -1;
 312     }
 313     time(&orig);
 314     while (1) {
 315
 316         if (db->fd == -1) {
 317             if ((db->fd = init_tsock(db)) < 0) {
 318                 time(&t);
 319                 if (t - orig > MAX_DELAY)
 320                     return -1;
 321                 continue;
 322             }
 323             if (db->notfirst) {
 324                 struct cnid_dbd_rqst rqst_stamp;
 325                 struct cnid_dbd_rply rply_stamp;
 326                 char  stamp[ADEDLEN_PRIVSYN];
 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                 if (memcmp(stamp, db->stamp, ADEDLEN_PRIVSYN)) {
 338                     LOG(log_error, logtype_cnid, "transmit: not the same db!");
 339                     db->changed = 1;
 340                     return -1;
 341                 }
 342             }
 343
 344         }
 345         if (!dbd_rpc(db, rqst, rply, silent))
 346             return 0;
 347
 348 transmit_fail:
 349         silent = 0; /* From now on dbd_rpc and subroutines called from there
 350                        will log messages if something goes wrong again */
 351         if (db->fd != -1) {
 352             close(db->fd);
 353         }
 354         time(&t);
 355         if (t - orig > MAX_DELAY) {
 356             LOG(log_error, logtype_cnid, "transmit: Request to dbd daemon (db_dir %s) timed out.", db->db_dir);
 357             return -1;
 358         }
 359
 360         /* sleep a little before retry */
 361         db->fd = -1;
 362         tv.tv_usec = 0;
 363         tv.tv_sec  = 5;
 364         select(0, NULL, NULL, NULL, &tv);
 365     }
 366     return -1;
 367 }
 368
 369 /* ---------------------- */
 370 static struct _cnid_db *cnid_dbd_new(const char *volpath)
 371 {
 372     struct _cnid_db *cdb;
 373
 374     if ((cdb = (struct _cnid_db *)calloc(1, sizeof(struct _cnid_db))) == NULL)
 375         return NULL;
 376
 377     if ((cdb->volpath = strdup(volpath)) == NULL) {
 378         free(cdb);
 379         return NULL;
 380     }
 381
 382     cdb->flags = CNID_FLAG_PERSISTENT;
 383
 384     cdb->cnid_add = cnid_dbd_add;
 385     cdb->cnid_delete = cnid_dbd_delete;
 386     cdb->cnid_get = cnid_dbd_get;
 387     cdb->cnid_lookup = cnid_dbd_lookup;
 388     cdb->cnid_nextid = NULL;
 389     cdb->cnid_resolve = cnid_dbd_resolve;
 390     cdb->cnid_getstamp = cnid_dbd_getstamp;
 391     cdb->cnid_update = cnid_dbd_update;
 392     cdb->cnid_rebuild_add = cnid_dbd_rebuild_add;
 393     cdb->cnid_close = cnid_dbd_close;
 394
 395     return cdb;
 396 }
 397
 398 /* ---------------------- */
 399 struct _cnid_db *cnid_dbd_open(const char *dir, mode_t mask _U_)
 400 {
 401     CNID_private *db = NULL;
 402     struct _cnid_db *cdb = NULL;
 403
 404     if (!dir) {
 405          return NULL;
 406     }
 407
 408     if ((cdb = cnid_dbd_new(dir)) == NULL) {
 409         LOG(log_error, logtype_default, "cnid_open: Unable to allocate memory for database");
 410         return NULL;
 411     }
 412
 413     if ((db = (CNID_private *)calloc(1, sizeof(CNID_private))) == NULL) {
 414         LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
 415         goto cnid_dbd_open_fail;
 416     }
 417
 418     cdb->_private = db;
 419
 420     /* We keep a copy of the directory in the db structure so that we can
 421        transparently reconnect later. */
 422     strcpy(db->db_dir, dir);
 423     db->magic = CNID_DB_MAGIC;
 424     db->fd = -1;
 425 #ifdef DEBUG
 426     LOG(log_info, logtype_cnid, "opening database connection to %s", db->db_dir);
 427 #endif
 428     return cdb;
 429
 430 cnid_dbd_open_fail:
 431     if (cdb != NULL) {
 432         if (cdb->volpath != NULL) {
 433             free(cdb->volpath);
 434         }
 435         free(cdb);
 436     }
 437     if (db != NULL)
 438         free(db);
 439
 440     return NULL;
 441 }
 442
 443 /* ---------------------- */
 444 void cnid_dbd_close(struct _cnid_db *cdb)
 445 {
 446     CNID_private *db;
 447
 448     if (!cdb) {
 449         LOG(log_error, logtype_afpd, "cnid_close called with NULL argument !");
 450         return;
 451     }
 452
 453     if ((db = cdb->_private) != NULL) {
 454 #ifdef DEBUG
 455         LOG(log_info, logtype_cnid, "closing database connection to %s", db->db_dir);
 456 #endif
 457         if (db->fd >= 0)
 458             close(db->fd);
 459         free(db);
 460     }
 461
 462     free(cdb->volpath);
 463     free(cdb);
 464
 465     return;
 466 }
 467
 468 /* ---------------------- */
 469 cnid_t cnid_dbd_add(struct _cnid_db *cdb, const struct stat *st,
 470                 const cnid_t did, char *name, const size_t len,
 471                 cnid_t hint _U_)
 472 {
 473     CNID_private *db;
 474     struct cnid_dbd_rqst rqst;
 475     struct cnid_dbd_rply rply;
 476     cnid_t id;
 477
 478     if (!cdb || !(db = cdb->_private) || !st || !name) {
 479         LOG(log_error, logtype_cnid, "cnid_add: Parameter error");
 480         errno = CNID_ERR_PARAM;
 481         return CNID_INVALID;
 482     }
 483
 484     if (len > MAXPATHLEN) {
 485         LOG(log_error, logtype_cnid, "cnid_add: Path name is too long");
 486         errno = CNID_ERR_PATH;
 487         return CNID_INVALID;
 488     }
 489
 490     RQST_RESET(&rqst);
 491     rqst.op = CNID_DBD_OP_ADD;
 492
 493     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 494         rqst.dev = st->st_dev;
 495     }
 496
 497     rqst.ino = st->st_ino;
 498     rqst.type = S_ISDIR(st->st_mode)?1:0;
 499     rqst.did = did;
 500     rqst.name = name;
 501     rqst.namelen = len;
 502
 503     rply.namelen = 0;
 504     if (transmit(db, &rqst, &rply) < 0) {
 505         errno = CNID_ERR_DB;
 506         return CNID_INVALID;
 507     }
 508
 509     switch(rply.result) {
 510     case CNID_DBD_RES_OK:
 511         id = rply.cnid;
 512         break;
 513     case CNID_DBD_RES_ERR_MAX:
 514         errno = CNID_ERR_MAX;
 515         id = CNID_INVALID;
 516         break;
 517     case CNID_DBD_RES_ERR_DB:
 518     case CNID_DBD_RES_ERR_DUPLCNID:
 519         errno = CNID_ERR_DB;
 520         id = CNID_INVALID;
 521         break;
 522     default:
 523         abort();
 524     }
 525     return id;
 526 }
 527
 528 /* ---------------------- */
 529 cnid_t cnid_dbd_get(struct _cnid_db *cdb, const cnid_t did, char *name, const size_t len)
 530 {
 531     CNID_private *db;
 532     struct cnid_dbd_rqst rqst;
 533     struct cnid_dbd_rply rply;
 534     cnid_t id;
 535
 536
 537     if (!cdb || !(db = cdb->_private) || !name) {
 538         LOG(log_error, logtype_cnid, "cnid_get: Parameter error");
 539         errno = CNID_ERR_PARAM;
 540         return CNID_INVALID;
 541     }
 542
 543     if (len > MAXPATHLEN) {
 544         LOG(log_error, logtype_cnid, "cnid_add: Path name is too long");
 545         errno = CNID_ERR_PATH;
 546         return CNID_INVALID;
 547     }
 548
 549     RQST_RESET(&rqst);
 550     rqst.op = CNID_DBD_OP_GET;
 551     rqst.did = did;
 552     rqst.name = name;
 553     rqst.namelen = len;
 554
 555     rply.namelen = 0;
 556     if (transmit(db, &rqst, &rply) < 0) {
 557         errno = CNID_ERR_DB;
 558         return CNID_INVALID;
 559     }
 560
 561     switch(rply.result) {
 562     case CNID_DBD_RES_OK:
 563         id = rply.cnid;
 564         break;
 565     case CNID_DBD_RES_NOTFOUND:
 566         id = CNID_INVALID;
 567         break;
 568     case CNID_DBD_RES_ERR_DB:
 569         id = CNID_INVALID;
 570         errno = CNID_ERR_DB;
 571         break;
 572     default:
 573         abort();
 574     }
 575
 576     return id;
 577 }
 578
 579 /* ---------------------- */
 580 char *cnid_dbd_resolve(struct _cnid_db *cdb, cnid_t *id, void *buffer, size_t len)
 581 {
 582     CNID_private *db;
 583     struct cnid_dbd_rqst rqst;
 584     struct cnid_dbd_rply rply;
 585     char *name;
 586
 587     if (!cdb || !(db = cdb->_private) || !id || !(*id)) {
 588         LOG(log_error, logtype_cnid, "cnid_resolve: Parameter error");
 589         errno = CNID_ERR_PARAM;
 590         return NULL;
 591     }
 592
 593     /* TODO: We should maybe also check len. At the moment we rely on the caller
 594        to provide a buffer that is large enough for MAXPATHLEN plus
 595        CNID_HEADER_LEN plus 1 byte, which is large enough for the maximum that
 596        can come from the database. */
 597
 598     RQST_RESET(&rqst);
 599     rqst.op = CNID_DBD_OP_RESOLVE;
 600     rqst.cnid = *id;
 601
 602     /* This mimicks the behaviour of the "regular" cnid_resolve. So far,
 603        nobody uses the content of buffer. It only provides space for the
 604        name in the caller. */
 605     rply.name = (char *)buffer + CNID_HEADER_LEN;
 606     rply.namelen = len - CNID_HEADER_LEN;
 607
 608     if (transmit(db, &rqst, &rply) < 0) {
 609         errno = CNID_ERR_DB;
 610         *id = CNID_INVALID;
 611         return NULL;
 612     }
 613
 614     switch (rply.result) {
 615     case CNID_DBD_RES_OK:
 616         *id = rply.did;
 617         name = rply.name;
 618         break;
 619     case CNID_DBD_RES_NOTFOUND:
 620         *id = CNID_INVALID;
 621         name = NULL;
 622         break;
 623     case CNID_DBD_RES_ERR_DB:
 624         errno = CNID_ERR_DB;
 625         *id = CNID_INVALID;
 626         name = NULL;
 627         break;
 628     default:
 629         abort();
 630     }
 631
 632     return name;
 633 }
 634
 635 /* --------------------- */
 636 static int dbd_getstamp(CNID_private *db, void *buffer, const size_t len)
 637 {
 638     struct cnid_dbd_rqst rqst;
 639     struct cnid_dbd_rply rply;
 640
 641     memset(buffer, 0, len);
 642     dbd_initstamp(&rqst);
 643
 644     rply.name = buffer;
 645     rply.namelen = len;
 646
 647     if (transmit(db, &rqst, &rply) < 0) {
 648         errno = CNID_ERR_DB;
 649         return -1;
 650     }
 651     return dbd_reply_stamp(&rply);
 652 }
 653
 654 /* ---------------------- */
 655 int cnid_dbd_getstamp(struct _cnid_db *cdb, void *buffer, const size_t len)
 656 {
 657     CNID_private *db;
 658     int ret;
 659
 660     if (!cdb || !(db = cdb->_private) || len != ADEDLEN_PRIVSYN) {
 661         LOG(log_error, logtype_cnid, "cnid_getstamp: Parameter error");
 662         errno = CNID_ERR_PARAM;
 663         return -1;
 664     }
 665     ret = dbd_getstamp(db, buffer, len);
 666     if (!ret) {
 667         db->notfirst = 1;
 668         memcpy(db->stamp, buffer, len);
 669     }
 670     return ret;
 671 }
 672
 673 /* ---------------------- */
 674 cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
 675                    char *name, const size_t len)
 676 {
 677     CNID_private *db;
 678     struct cnid_dbd_rqst rqst;
 679     struct cnid_dbd_rply rply;
 680     cnid_t id;
 681
 682     if (!cdb || !(db = cdb->_private) || !st || !name) {
 683         LOG(log_error, logtype_cnid, "cnid_lookup: Parameter error");
 684         errno = CNID_ERR_PARAM;
 685         return CNID_INVALID;
 686     }
 687
 688     if (len > MAXPATHLEN) {
 689         LOG(log_error, logtype_cnid, "cnid_lookup: Path name is too long");
 690         errno = CNID_ERR_PATH;
 691         return CNID_INVALID;
 692     }
 693
 694     RQST_RESET(&rqst);
 695     rqst.op = CNID_DBD_OP_LOOKUP;
 696
 697     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 698         rqst.dev = st->st_dev;
 699     }
 700
 701     rqst.ino = st->st_ino;
 702     rqst.type = S_ISDIR(st->st_mode)?1:0;
 703     rqst.did = did;
 704     rqst.name = name;
 705     rqst.namelen = len;
 706
 707     rply.namelen = 0;
 708     if (transmit(db, &rqst, &rply) < 0) {
 709         errno = CNID_ERR_DB;
 710         return CNID_INVALID;
 711     }
 712
 713     switch (rply.result) {
 714     case CNID_DBD_RES_OK:
 715         id = rply.cnid;
 716         break;
 717     case CNID_DBD_RES_NOTFOUND:
 718         id = CNID_INVALID;
 719         break;
 720     case CNID_DBD_RES_ERR_DB:
 721         errno = CNID_ERR_DB;
 722         id = CNID_INVALID;
 723         break;
 724     default:
 725         abort();
 726     }
 727
 728     return id;
 729 }
 730
 731 /* ---------------------- */
 732 int cnid_dbd_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
 733                 const cnid_t did, char *name, const size_t len)
 734 {
 735     CNID_private *db;
 736     struct cnid_dbd_rqst rqst;
 737     struct cnid_dbd_rply rply;
 738
 739
 740     if (!cdb || !(db = cdb->_private) || !id || !st || !name) {
 741         LOG(log_error, logtype_cnid, "cnid_update: Parameter error");
 742         errno = CNID_ERR_PARAM;
 743         return -1;
 744     }
 745
 746     if (len > MAXPATHLEN) {
 747         LOG(log_error, logtype_cnid, "cnid_update: Path name is too long");
 748         errno = CNID_ERR_PATH;
 749         return -1;
 750     }
 751
 752     RQST_RESET(&rqst);
 753     rqst.op = CNID_DBD_OP_UPDATE;
 754     rqst.cnid = id;
 755     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 756         rqst.dev = st->st_dev;
 757     }
 758     rqst.ino = st->st_ino;
 759     rqst.type = S_ISDIR(st->st_mode)?1:0;
 760     rqst.did = did;
 761     rqst.name = name;
 762     rqst.namelen = len;
 763
 764     rply.namelen = 0;
 765     if (transmit(db, &rqst, &rply) < 0) {
 766         errno = CNID_ERR_DB;
 767         return -1;
 768     }
 769
 770     switch (rply.result) {
 771     case CNID_DBD_RES_OK:
 772     case CNID_DBD_RES_NOTFOUND:
 773         return 0;
 774     case CNID_DBD_RES_ERR_DB:
 775         errno = CNID_ERR_DB;
 776         return -1;
 777     default:
 778         abort();
 779     }
 780 }
 781
 782 /* ---------------------- */
 783 cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
 784                             const cnid_t did, char *name, const size_t len,
 785                             cnid_t hint)
 786 {
 787     CNID_private *db;
 788     struct cnid_dbd_rqst rqst;
 789     struct cnid_dbd_rply rply;
 790     cnid_t id;
 791
 792     if (!cdb || !(db = cdb->_private) || !st || !name || hint == CNID_INVALID) {
 793         LOG(log_error, logtype_cnid, "cnid_rebuild_add: Parameter error");
 794         errno = CNID_ERR_PARAM;
 795         return CNID_INVALID;
 796     }
 797
 798     if (len > MAXPATHLEN) {
 799         LOG(log_error, logtype_cnid, "cnid_rebuild_add: Path name is too long");
 800         errno = CNID_ERR_PATH;
 801         return CNID_INVALID;
 802     }
 803
 804     RQST_RESET(&rqst);
 805     rqst.op = CNID_DBD_OP_REBUILD_ADD;
 806
 807     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 808         rqst.dev = st->st_dev;
 809     }
 810
 811     rqst.ino = st->st_ino;
 812     rqst.type = S_ISDIR(st->st_mode)?1:0;
 813     rqst.did = did;
 814     rqst.name = name;
 815     rqst.namelen = len;
 816     rqst.cnid = hint;
 817
 818     if (transmit(db, &rqst, &rply) < 0) {
 819         errno = CNID_ERR_DB;
 820         return CNID_INVALID;
 821     }
 822
 823     switch(rply.result) {
 824     case CNID_DBD_RES_OK:
 825         id = rply.cnid;
 826         break;
 827     case CNID_DBD_RES_ERR_MAX:
 828         errno = CNID_ERR_MAX;
 829         id = CNID_INVALID;
 830         break;
 831     case CNID_DBD_RES_ERR_DB:
 832     case CNID_DBD_RES_ERR_DUPLCNID:
 833         errno = CNID_ERR_DB;
 834         id = CNID_INVALID;
 835         break;
 836     default:
 837         abort();
 838     }
 839     return id;
 840 }
 841
 842 /* ---------------------- */
 843 int cnid_dbd_delete(struct _cnid_db *cdb, const cnid_t id)
 844 {
 845     CNID_private *db;
 846     struct cnid_dbd_rqst rqst;
 847     struct cnid_dbd_rply rply;
 848
 849
 850     if (!cdb || !(db = cdb->_private) || !id) {
 851         LOG(log_error, logtype_cnid, "cnid_delete: Parameter error");
 852         errno = CNID_ERR_PARAM;
 853         return -1;
 854     }
 855
 856     RQST_RESET(&rqst);
 857     rqst.op = CNID_DBD_OP_DELETE;
 858     rqst.cnid = id;
 859
 860     rply.namelen = 0;
 861     if (transmit(db, &rqst, &rply) < 0) {
 862         errno = CNID_ERR_DB;
 863         return -1;
 864     }
 865
 866     switch (rply.result) {
 867     case CNID_DBD_RES_OK:
 868     case CNID_DBD_RES_NOTFOUND:
 869         return 0;
 870     case CNID_DBD_RES_ERR_DB:
 871         errno = CNID_ERR_DB;
 872         return -1;
 873     default:
 874         abort();
 875     }
 876 }
 877
 878
 879 struct _cnid_module cnid_dbd_module = {
 880     "dbd",
 881     {NULL, NULL},
 882     cnid_dbd_open,
 883     0
 884 };
 885
 886 #endif /* CNID_DBD */
 887