libatalk/cnid/dbd/cnid_dbd.c

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