libatalk/cnid/dbd/cnid_dbd.c

   1 /*
   2  * $Id: cnid_dbd.c,v 1.2 2005-04-28 20:50:00 bfernhomberg 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 int 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,
 530                 const int len)
 531 {
 532     CNID_private *db;
 533     struct cnid_dbd_rqst rqst;
 534     struct cnid_dbd_rply rply;
 535     cnid_t id;
 536
 537
 538     if (!cdb || !(db = cdb->_private) || !name) {
 539         LOG(log_error, logtype_cnid, "cnid_get: Parameter error");
 540         errno = CNID_ERR_PARAM;
 541         return CNID_INVALID;
 542     }
 543
 544     if (len > MAXPATHLEN) {
 545         LOG(log_error, logtype_cnid, "cnid_add: Path name is too long");
 546         errno = CNID_ERR_PATH;
 547         return CNID_INVALID;
 548     }
 549
 550     RQST_RESET(&rqst);
 551     rqst.op = CNID_DBD_OP_GET;
 552     rqst.did = did;
 553     rqst.name = name;
 554     rqst.namelen = len;
 555
 556     rply.namelen = 0;
 557     if (transmit(db, &rqst, &rply) < 0) {
 558         errno = CNID_ERR_DB;
 559         return CNID_INVALID;
 560     }
 561
 562     switch(rply.result) {
 563     case CNID_DBD_RES_OK:
 564         id = rply.cnid;
 565         break;
 566     case CNID_DBD_RES_NOTFOUND:
 567         id = CNID_INVALID;
 568         break;
 569     case CNID_DBD_RES_ERR_DB:
 570         id = CNID_INVALID;
 571         errno = CNID_ERR_DB;
 572         break;
 573     default:
 574         abort();
 575     }
 576
 577     return id;
 578 }
 579
 580 /* ---------------------- */
 581 char *cnid_dbd_resolve(struct _cnid_db *cdb, cnid_t *id, void *buffer, u_int32_t len)
 582 {
 583     CNID_private *db;
 584     struct cnid_dbd_rqst rqst;
 585     struct cnid_dbd_rply rply;
 586     char *name;
 587
 588     if (!cdb || !(db = cdb->_private) || !id || !(*id)) {
 589         LOG(log_error, logtype_cnid, "cnid_resolve: Parameter error");
 590         errno = CNID_ERR_PARAM;
 591         return NULL;
 592     }
 593
 594     /* TODO: We should maybe also check len. At the moment we rely on the caller
 595        to provide a buffer that is large enough for MAXPATHLEN plus
 596        CNID_HEADER_LEN plus 1 byte, which is large enough for the maximum that
 597        can come from the database. */
 598
 599     RQST_RESET(&rqst);
 600     rqst.op = CNID_DBD_OP_RESOLVE;
 601     rqst.cnid = *id;
 602
 603     /* This mimicks the behaviour of the "regular" cnid_resolve. So far,
 604        nobody uses the content of buffer. It only provides space for the
 605        name in the caller. */
 606     rply.name = (char *)buffer + CNID_HEADER_LEN;
 607     rply.namelen = len - CNID_HEADER_LEN;
 608
 609     if (transmit(db, &rqst, &rply) < 0) {
 610         errno = CNID_ERR_DB;
 611         *id = CNID_INVALID;
 612         return NULL;
 613     }
 614
 615     switch (rply.result) {
 616     case CNID_DBD_RES_OK:
 617         *id = rply.did;
 618         name = rply.name;
 619         break;
 620     case CNID_DBD_RES_NOTFOUND:
 621         *id = CNID_INVALID;
 622         name = NULL;
 623         break;
 624     case CNID_DBD_RES_ERR_DB:
 625         errno = CNID_ERR_DB;
 626         *id = CNID_INVALID;
 627         name = NULL;
 628         break;
 629     default:
 630         abort();
 631     }
 632
 633     return name;
 634 }
 635
 636 /* --------------------- */
 637 static int dbd_getstamp(CNID_private *db, void *buffer, const size_t len)
 638 {
 639     struct cnid_dbd_rqst rqst;
 640     struct cnid_dbd_rply rply;
 641
 642     memset(buffer, 0, len);
 643     dbd_initstamp(&rqst);
 644
 645     rply.name = buffer;
 646     rply.namelen = len;
 647
 648     if (transmit(db, &rqst, &rply) < 0) {
 649         errno = CNID_ERR_DB;
 650         return -1;
 651     }
 652     return dbd_reply_stamp(&rply);
 653 }
 654
 655 /* ---------------------- */
 656 int cnid_dbd_getstamp(struct _cnid_db *cdb, void *buffer, const int len)
 657 {
 658     CNID_private *db;
 659     int ret;
 660
 661     if (!cdb || !(db = cdb->_private) || len != ADEDLEN_PRIVSYN) {
 662         LOG(log_error, logtype_cnid, "cnid_getstamp: Parameter error");
 663         errno = CNID_ERR_PARAM;
 664         return -1;
 665     }
 666     ret = dbd_getstamp(db, buffer, len);
 667     if (!ret) {
 668         db->notfirst = 1;
 669         memcpy(db->stamp, buffer, len);
 670     }
 671     return ret;
 672 }
 673
 674 /* ---------------------- */
 675 cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
 676                    char *name, const int len)
 677 {
 678     CNID_private *db;
 679     struct cnid_dbd_rqst rqst;
 680     struct cnid_dbd_rply rply;
 681     cnid_t id;
 682
 683     if (!cdb || !(db = cdb->_private) || !st || !name) {
 684         LOG(log_error, logtype_cnid, "cnid_lookup: Parameter error");
 685         errno = CNID_ERR_PARAM;
 686         return CNID_INVALID;
 687     }
 688
 689     if (len > MAXPATHLEN) {
 690         LOG(log_error, logtype_cnid, "cnid_lookup: Path name is too long");
 691         errno = CNID_ERR_PATH;
 692         return CNID_INVALID;
 693     }
 694
 695     RQST_RESET(&rqst);
 696     rqst.op = CNID_DBD_OP_LOOKUP;
 697
 698     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 699         rqst.dev = st->st_dev;
 700     }
 701
 702     rqst.ino = st->st_ino;
 703     rqst.type = S_ISDIR(st->st_mode)?1:0;
 704     rqst.did = did;
 705     rqst.name = name;
 706     rqst.namelen = len;
 707
 708     rply.namelen = 0;
 709     if (transmit(db, &rqst, &rply) < 0) {
 710         errno = CNID_ERR_DB;
 711         return CNID_INVALID;
 712     }
 713
 714     switch (rply.result) {
 715     case CNID_DBD_RES_OK:
 716         id = rply.cnid;
 717         break;
 718     case CNID_DBD_RES_NOTFOUND:
 719         id = CNID_INVALID;
 720         break;
 721     case CNID_DBD_RES_ERR_DB:
 722         errno = CNID_ERR_DB;
 723         id = CNID_INVALID;
 724         break;
 725     default:
 726         abort();
 727     }
 728
 729     return id;
 730 }
 731
 732 /* ---------------------- */
 733 int cnid_dbd_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
 734                 const cnid_t did, char *name, const int len)
 735 {
 736     CNID_private *db;
 737     struct cnid_dbd_rqst rqst;
 738     struct cnid_dbd_rply rply;
 739
 740
 741     if (!cdb || !(db = cdb->_private) || !id || !st || !name) {
 742         LOG(log_error, logtype_cnid, "cnid_update: Parameter error");
 743         errno = CNID_ERR_PARAM;
 744         return -1;
 745     }
 746
 747     if (len > MAXPATHLEN) {
 748         LOG(log_error, logtype_cnid, "cnid_update: Path name is too long");
 749         errno = CNID_ERR_PATH;
 750         return -1;
 751     }
 752
 753     RQST_RESET(&rqst);
 754     rqst.op = CNID_DBD_OP_UPDATE;
 755     rqst.cnid = id;
 756     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 757         rqst.dev = st->st_dev;
 758     }
 759     rqst.ino = st->st_ino;
 760     rqst.type = S_ISDIR(st->st_mode)?1:0;
 761     rqst.did = did;
 762     rqst.name = name;
 763     rqst.namelen = len;
 764
 765     rply.namelen = 0;
 766     if (transmit(db, &rqst, &rply) < 0) {
 767         errno = CNID_ERR_DB;
 768         return -1;
 769     }
 770
 771     switch (rply.result) {
 772     case CNID_DBD_RES_OK:
 773     case CNID_DBD_RES_NOTFOUND:
 774         return 0;
 775     case CNID_DBD_RES_ERR_DB:
 776         errno = CNID_ERR_DB;
 777         return -1;
 778     default:
 779         abort();
 780     }
 781 }
 782
 783 /* ---------------------- */
 784 cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
 785                             const cnid_t did, const char *name, const int len,
 786                             cnid_t hint)
 787 {
 788     CNID_private *db;
 789     struct cnid_dbd_rqst rqst;
 790     struct cnid_dbd_rply rply;
 791     cnid_t id;
 792
 793     if (!cdb || !(db = cdb->_private) || !st || !name || hint == CNID_INVALID) {
 794         LOG(log_error, logtype_cnid, "cnid_rebuild_add: Parameter error");
 795         errno = CNID_ERR_PARAM;
 796         return CNID_INVALID;
 797     }
 798
 799     if (len > MAXPATHLEN) {
 800         LOG(log_error, logtype_cnid, "cnid_rebuild_add: Path name is too long");
 801         errno = CNID_ERR_PATH;
 802         return CNID_INVALID;
 803     }
 804
 805     RQST_RESET(&rqst);
 806     rqst.op = CNID_DBD_OP_REBUILD_ADD;
 807
 808     if (!(cdb->flags & CNID_FLAG_NODEV)) {
 809         rqst.dev = st->st_dev;
 810     }
 811
 812     rqst.ino = st->st_ino;
 813     rqst.type = S_ISDIR(st->st_mode)?1:0;
 814     rqst.did = did;
 815     rqst.name = name;
 816     rqst.namelen = len;
 817     rqst.cnid = hint;
 818
 819     if (transmit(db, &rqst, &rply) < 0) {
 820         errno = CNID_ERR_DB;
 821         return CNID_INVALID;
 822     }
 823
 824     switch(rply.result) {
 825     case CNID_DBD_RES_OK:
 826         id = rply.cnid;
 827         break;
 828     case CNID_DBD_RES_ERR_MAX:
 829         errno = CNID_ERR_MAX;
 830         id = CNID_INVALID;
 831         break;
 832     case CNID_DBD_RES_ERR_DB:
 833     case CNID_DBD_RES_ERR_DUPLCNID:
 834         errno = CNID_ERR_DB;
 835         id = CNID_INVALID;
 836         break;
 837     default:
 838         abort();
 839     }
 840     return id;
 841 }
 842
 843 /* ---------------------- */
 844 int cnid_dbd_delete(struct _cnid_db *cdb, const cnid_t id)
 845 {
 846     CNID_private *db;
 847     struct cnid_dbd_rqst rqst;
 848     struct cnid_dbd_rply rply;
 849
 850
 851     if (!cdb || !(db = cdb->_private) || !id) {
 852         LOG(log_error, logtype_cnid, "cnid_delete: Parameter error");
 853         errno = CNID_ERR_PARAM;
 854         return -1;
 855     }
 856
 857     RQST_RESET(&rqst);
 858     rqst.op = CNID_DBD_OP_DELETE;
 859     rqst.cnid = id;
 860
 861     rply.namelen = 0;
 862     if (transmit(db, &rqst, &rply) < 0) {
 863         errno = CNID_ERR_DB;
 864         return -1;
 865     }
 866
 867     switch (rply.result) {
 868     case CNID_DBD_RES_OK:
 869     case CNID_DBD_RES_NOTFOUND:
 870         return 0;
 871     case CNID_DBD_RES_ERR_DB:
 872         errno = CNID_ERR_DB;
 873         return -1;
 874     default:
 875         abort();
 876     }
 877 }
 878
 879
 880 struct _cnid_module cnid_dbd_module = {
 881     "dbd",
 882     {NULL, NULL},
 883     cnid_dbd_open,
 884     0
 885 };
 886
 887 #endif /* CNID_DBD */
 888