2 * Copyright (C) Joerg Lenneis 2003
3 * Copyright (C) Frank Lahm 2010
4 * All Rights Reserved. See COPYING.
9 #endif /* HAVE_CONFIG_H */
11 #ifdef CNID_BACKEND_DBD
14 #ifdef HAVE_SYS_STAT_H
16 #endif /* HAVE_SYS_STAT_H */
19 #endif /* HAVE_SYS_UIO_H */
25 #include <sys/socket.h>
26 #include <sys/param.h>
28 #include <netinet/in.h>
30 #include <netinet/tcp.h>
31 #include <netinet/in.h>
32 #include <arpa/inet.h>
37 #include <netatalk/endian.h>
38 #include <atalk/logger.h>
39 #include <atalk/adouble.h>
40 #include <atalk/cnid.h>
41 #include <atalk/cnid_dbd_private.h>
42 #include <atalk/util.h>
47 #define SOL_TCP IPPROTO_TCP
48 #endif /* ! SOL_TCP */
50 /* Wait MAX_DELAY seconds before a request to the CNID server times out */
54 static void RQST_RESET(struct cnid_dbd_rqst *r)
56 memset(r, 0, sizeof(struct cnid_dbd_rqst ));
59 static void delay(int sec)
65 select(0, NULL, NULL, NULL, &tv);
68 static int tsock_getfd(const char *host, const char *port)
73 struct addrinfo hints, *servinfo, *p;
75 socklen_t optlen = sizeof(optval);
77 /* Prepare hint for getaddrinfo */
78 memset(&hints, 0, sizeof hints);
79 hints.ai_family = AF_UNSPEC;
80 hints.ai_socktype = SOCK_STREAM;
81 hints.ai_flags = AI_NUMERICSERV;
83 if ((err = getaddrinfo(host, port, &hints, &servinfo)) != 0) {
84 LOG(log_error, logtype_default, "tsock_getfd: getaddrinfo: CNID server %s:%s : %s\n",
85 host, port, gai_strerror(err));
89 /* loop through all the results and bind to the first we can */
90 for (p = servinfo; p != NULL; p = p->ai_next) {
91 if ((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
92 LOG(log_info, logtype_default, "tsock_getfd: socket CNID server %s:: %s",
93 host, strerror(errno));
98 if (setsockopt(sock, SOL_TCP, TCP_NODELAY, &attr, sizeof(attr)) == -1) {
99 LOG(log_error, logtype_cnid, "getfd: set TCP_NODELAY CNID server %s: %s",
100 host, strerror(errno));
106 if (setnonblock(sock, 1) != 0) {
107 LOG(log_error, logtype_cnid, "getfd: setnonblock: %s", strerror(errno));
113 if (connect(sock, p->ai_addr, p->ai_addrlen) == -1) {
114 if (errno == EINPROGRESS) {
117 tv.tv_sec = 5; /* give it five seconds ... */
122 if ((err = select(sock + 1, NULL, &wfds, NULL, &tv)) == 0) {
124 LOG(log_error, logtype_cnid, "getfd: select timed out for CNID server %s",
132 LOG(log_error, logtype_cnid, "getfd: select failed for CNID server %s",
139 if ( ! FD_ISSET(sock, &wfds)) {
141 LOG(log_error, logtype_cnid, "getfd: socket not ready connecting to %s",
148 if ((err = getsockopt(sock, SOL_SOCKET, SO_ERROR, &optval, &optlen)) != 0 || optval != 0) {
150 /* somethings very wrong */
151 LOG(log_error, logtype_cnid, "getfd: getsockopt error with CNID server %s: %s",
152 host, strerror(errno));
155 LOG(log_error, logtype_cnid, "getfd: getsockopt says: %s",
163 LOG(log_error, logtype_cnid, "getfd: connect CNID server %s: %s",
164 host, strerror(errno));
171 /* We've got a socket */
175 freeaddrinfo(servinfo);
179 LOG(log_error, logtype_cnid, "tsock_getfd: no suitable network config from CNID server (%s:%s): %s",
180 host, port, strerror(errno));
188 * Write "towrite" bytes using writev on non-blocking fd
190 * Every short write is considered an error, transmit can handle that.
192 * @param fd (r) socket fd which must be non-blocking
193 * @param iov (r) iovec for writev
194 * @param towrite (r) number of bytes in all iovec elements
195 * @param vecs (r) number of iovecs in array
197 * @returns "towrite" bytes written or -1 on error
199 static int write_vec(int fd, struct iovec *iov, ssize_t towrite, int vecs)
206 if (((len = writev(fd, iov, vecs)) == -1 && errno == EINTR))
209 if ((! slept) && len == -1 && errno == EAGAIN) {
211 while ((sleepsecs = sleep(sleepsecs)));
216 if (len == towrite) /* wrote everything out */
220 LOG(log_error, logtype_cnid, "write_vec: %s", strerror(errno));
222 LOG(log_error, logtype_cnid, "write_vec: short write: %d", len);
226 LOG(log_maxdebug, logtype_cnid, "write_vec: wrote %d bytes", len);
231 /* --------------------- */
232 static int init_tsock(CNID_private *db)
238 LOG(log_debug, logtype_cnid, "init_tsock: BEGIN. Opening volume '%s', CNID Server: %s/%s",
239 db->db_dir, db->cnidserver, db->cnidport);
241 if ((fd = tsock_getfd(db->cnidserver, db->cnidport)) < 0)
244 len = strlen(db->db_dir);
246 iov[0].iov_base = &len;
247 iov[0].iov_len = sizeof(int);
249 iov[1].iov_base = db->db_dir;
250 iov[1].iov_len = len;
252 if (write_vec(fd, iov, len + sizeof(int), 2) != len + sizeof(int)) {
253 LOG(log_error, logtype_cnid, "init_tsock: Error/short write: %s", strerror(errno));
258 LOG(log_debug, logtype_cnid, "init_tsock: ok");
263 /* --------------------- */
264 static int send_packet(CNID_private *db, struct cnid_dbd_rqst *rqst)
270 iov[0].iov_base = rqst;
271 iov[0].iov_len = sizeof(struct cnid_dbd_rqst);
272 towrite = sizeof(struct cnid_dbd_rqst);
276 iov[1].iov_base = rqst->name;
277 iov[1].iov_len = rqst->namelen;
278 towrite += rqst->namelen;
282 if (write_vec(db->fd, iov, towrite, vecs) != towrite) {
283 LOG(log_warning, logtype_cnid, "send_packet: Error writev rqst (db_dir %s): %s",
284 db->db_dir, strerror(errno));
288 LOG(log_maxdebug, logtype_cnid, "send_packet: {done}");
292 /* ------------------- */
293 static void dbd_initstamp(struct cnid_dbd_rqst *rqst)
296 rqst->op = CNID_DBD_OP_GETSTAMP;
299 /* ------------------- */
300 static int dbd_reply_stamp(struct cnid_dbd_rply *rply)
302 switch (rply->result) {
303 case CNID_DBD_RES_OK:
305 case CNID_DBD_RES_NOTFOUND:
307 case CNID_DBD_RES_ERR_DB:
315 /* ---------------------
316 * send a request and get reply
317 * assume send is non blocking
318 * if no answer after sometime (at least MAX_DELAY secondes) return an error
320 static int dbd_rpc(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
326 if (send_packet(db, rqst) < 0) {
330 nametmp = rply->name;
332 ret = readt(db->fd, rply, sizeof(struct cnid_dbd_rply), 0, ONE_DELAY);
334 if (ret != sizeof(struct cnid_dbd_rply)) {
335 LOG(log_error, logtype_cnid, "dbd_rpc: Error reading header from fd (db_dir %s): %s",
336 db->db_dir, ret == -1 ? strerror(errno) : "closed");
337 rply->name = nametmp;
340 rply->name = nametmp;
341 if (rply->namelen && rply->namelen > len) {
342 LOG(log_error, logtype_cnid,
343 "dbd_rpc: Error reading name (db_dir %s): %s name too long: %d. only wanted %d, garbage?",
344 db->db_dir, rply->name, rply->namelen, len);
347 if (rply->namelen && (ret = readt(db->fd, rply->name, rply->namelen, 0, ONE_DELAY)) != (ssize_t)rply->namelen) {
348 LOG(log_error, logtype_cnid, "dbd_rpc: Error reading name from fd (db_dir %s): %s",
349 db->db_dir, ret == -1?strerror(errno):"closed");
353 LOG(log_maxdebug, logtype_cnid, "dbd_rpc: {done}");
358 /* -------------------- */
359 static int transmit(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
362 int clean = 1; /* no errors so far - to prevent sleep on first try */
365 /* volume and db don't have the same timestamp
371 struct cnid_dbd_rqst rqst_stamp;
372 struct cnid_dbd_rply rply_stamp;
373 char stamp[ADEDLEN_PRIVSYN];
375 LOG(log_maxdebug, logtype_cnid, "transmit: connecting to cnid_dbd ...");
376 if ((db->fd = init_tsock(db)) < 0) {
379 dbd_initstamp(&rqst_stamp);
380 memset(stamp, 0, ADEDLEN_PRIVSYN);
381 rply_stamp.name = stamp;
382 rply_stamp.namelen = ADEDLEN_PRIVSYN;
384 if (dbd_rpc(db, &rqst_stamp, &rply_stamp) < 0)
386 if (dbd_reply_stamp(&rply_stamp ) < 0)
390 LOG(log_debug7, logtype_cnid, "transmit: reconnected to cnid_dbd, comparing database stamps...");
391 if (memcmp(stamp, db->stamp, ADEDLEN_PRIVSYN)) {
392 LOG(log_error, logtype_cnid, "transmit: ... not the same db!");
396 LOG(log_debug7, logtype_cnid, "transmit: ... OK.");
397 } else { /* db->notfirst == 0 */
399 if (db->client_stamp)
400 memcpy(db->client_stamp, stamp, ADEDLEN_PRIVSYN);
401 memcpy(db->stamp, stamp, ADEDLEN_PRIVSYN);
403 LOG(log_debug, logtype_cnid, "transmit: attached to '%s', stamp: '%08lx'.",
404 db->db_dir, *(uint64_t *)stamp);
406 if (!dbd_rpc(db, rqst, rply)) {
407 LOG(log_maxdebug, logtype_cnid, "transmit: {done}");
413 db->fd = -1; /* FD not valid... will need to reconnect */
416 if (errno == ECONNREFUSED) { /* errno carefully injected in tsock_getfd */
418 LOG(log_error, logtype_cnid, "transmit: connection refused (db_dir %s)", db->db_dir);
422 if (!clean) { /* don't sleep if just got disconnected by cnid server */
424 if (t - orig > MAX_DELAY) {
425 LOG(log_error, logtype_cnid, "transmit: Request to dbd daemon (db_dir %s) timed out.", db->db_dir);
428 /* sleep a little before retry */
431 clean = 0; /* false... next time sleep */
438 /* ---------------------- */
439 static struct _cnid_db *cnid_dbd_new(const char *volpath)
441 struct _cnid_db *cdb;
443 if ((cdb = (struct _cnid_db *)calloc(1, sizeof(struct _cnid_db))) == NULL)
446 if ((cdb->volpath = strdup(volpath)) == NULL) {
451 cdb->flags = CNID_FLAG_PERSISTENT | CNID_FLAG_LAZY_INIT;
453 cdb->cnid_add = cnid_dbd_add;
454 cdb->cnid_delete = cnid_dbd_delete;
455 cdb->cnid_get = cnid_dbd_get;
456 cdb->cnid_lookup = cnid_dbd_lookup;
457 cdb->cnid_find = cnid_dbd_find;
458 cdb->cnid_nextid = NULL;
459 cdb->cnid_resolve = cnid_dbd_resolve;
460 cdb->cnid_getstamp = cnid_dbd_getstamp;
461 cdb->cnid_update = cnid_dbd_update;
462 cdb->cnid_rebuild_add = cnid_dbd_rebuild_add;
463 cdb->cnid_close = cnid_dbd_close;
468 /* ---------------------- */
469 struct _cnid_db *cnid_dbd_open(struct cnid_open_args *args)
471 CNID_private *db = NULL;
472 struct _cnid_db *cdb = NULL;
478 if ((cdb = cnid_dbd_new(args->dir)) == NULL) {
479 LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
483 if ((db = (CNID_private *)calloc(1, sizeof(CNID_private))) == NULL) {
484 LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
485 goto cnid_dbd_open_fail;
490 /* We keep a copy of the directory in the db structure so that we can
491 transparently reconnect later. */
492 strcpy(db->db_dir, args->dir);
493 db->magic = CNID_DB_MAGIC;
495 db->cnidserver = strdup(args->cnidserver);
496 db->cnidport = strdup(args->cnidport);
498 LOG(log_debug, logtype_cnid, "cnid_dbd_open: Finished initializing cnid dbd module for volume '%s'", db->db_dir);
504 if (cdb->volpath != NULL) {
515 /* ---------------------- */
516 void cnid_dbd_close(struct _cnid_db *cdb)
521 LOG(log_error, logtype_cnid, "cnid_close called with NULL argument !");
525 if ((db = cdb->_private) != NULL) {
526 LOG(log_debug, logtype_cnid, "closing database connection for volume '%s'", db->db_dir);
539 /* ---------------------- */
540 cnid_t cnid_dbd_add(struct _cnid_db *cdb, const struct stat *st,
541 const cnid_t did, char *name, const size_t len,
545 struct cnid_dbd_rqst rqst;
546 struct cnid_dbd_rply rply;
549 if (!cdb || !(db = cdb->_private) || !st || !name) {
550 LOG(log_error, logtype_cnid, "cnid_add: Parameter error");
551 errno = CNID_ERR_PARAM;
555 if (len > MAXPATHLEN) {
556 LOG(log_error, logtype_cnid, "cnid_add: Path name is too long");
557 errno = CNID_ERR_PATH;
562 rqst.op = CNID_DBD_OP_ADD;
564 if (!(cdb->flags & CNID_FLAG_NODEV)) {
565 rqst.dev = st->st_dev;
568 rqst.ino = st->st_ino;
569 rqst.type = S_ISDIR(st->st_mode)?1:0;
575 LOG(log_debug, logtype_cnid, "cnid_dbd_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
576 ntohl(did), name, (long long)st->st_ino, rqst.type);
579 if (transmit(db, &rqst, &rply) < 0) {
584 switch(rply.result) {
585 case CNID_DBD_RES_OK:
587 LOG(log_debug, logtype_cnid, "cnid_dbd_add: got CNID: %u", ntohl(id));
589 case CNID_DBD_RES_ERR_MAX:
590 errno = CNID_ERR_MAX;
593 case CNID_DBD_RES_ERR_DB:
594 case CNID_DBD_RES_ERR_DUPLCNID:
605 /* ---------------------- */
606 cnid_t cnid_dbd_get(struct _cnid_db *cdb, const cnid_t did, char *name, const size_t len)
609 struct cnid_dbd_rqst rqst;
610 struct cnid_dbd_rply rply;
613 if (!cdb || !(db = cdb->_private) || !name) {
614 LOG(log_error, logtype_cnid, "cnid_dbd_get: Parameter error");
615 errno = CNID_ERR_PARAM;
619 if (len > MAXPATHLEN) {
620 LOG(log_error, logtype_cnid, "cnid_dbd_get: Path name is too long");
621 errno = CNID_ERR_PATH;
625 LOG(log_debug, logtype_cnid, "cnid_dbd_get: DID: %u, name: '%s'", ntohl(did), name);
628 rqst.op = CNID_DBD_OP_GET;
634 if (transmit(db, &rqst, &rply) < 0) {
639 switch(rply.result) {
640 case CNID_DBD_RES_OK:
642 LOG(log_debug, logtype_cnid, "cnid_dbd_get: got CNID: %u", ntohl(id));
644 case CNID_DBD_RES_NOTFOUND:
647 case CNID_DBD_RES_ERR_DB:
658 /* ---------------------- */
659 char *cnid_dbd_resolve(struct _cnid_db *cdb, cnid_t *id, void *buffer, size_t len)
662 struct cnid_dbd_rqst rqst;
663 struct cnid_dbd_rply rply;
666 if (!cdb || !(db = cdb->_private) || !id || !(*id)) {
667 LOG(log_error, logtype_cnid, "cnid_resolve: Parameter error");
668 errno = CNID_ERR_PARAM;
672 LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolving CNID: %u", ntohl(*id));
674 /* TODO: We should maybe also check len. At the moment we rely on the caller
675 to provide a buffer that is large enough for MAXPATHLEN plus
676 CNID_HEADER_LEN plus 1 byte, which is large enough for the maximum that
677 can come from the database. */
680 rqst.op = CNID_DBD_OP_RESOLVE;
683 /* Pass buffer to transmit so it can stuff the reply data there */
684 rply.name = (char *)buffer;
687 if (transmit(db, &rqst, &rply) < 0) {
693 switch (rply.result) {
694 case CNID_DBD_RES_OK:
696 name = rply.name + CNID_NAME_OFS;
697 LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolved did: %u, name: '%s'", ntohl(*id), name);
699 case CNID_DBD_RES_NOTFOUND:
703 case CNID_DBD_RES_ERR_DB:
715 /* ---------------------- */
716 int cnid_dbd_getstamp(struct _cnid_db *cdb, void *buffer, const size_t len)
720 if (!cdb || !(db = cdb->_private) || len != ADEDLEN_PRIVSYN) {
721 LOG(log_error, logtype_cnid, "cnid_getstamp: Parameter error");
722 errno = CNID_ERR_PARAM;
725 db->client_stamp = buffer;
726 db->stamp_size = len;
727 memset(buffer,0, len);
731 /* ---------------------- */
732 cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
733 char *name, const size_t len)
736 struct cnid_dbd_rqst rqst;
737 struct cnid_dbd_rply rply;
740 if (!cdb || !(db = cdb->_private) || !st || !name) {
741 LOG(log_error, logtype_cnid, "cnid_lookup: Parameter error");
742 errno = CNID_ERR_PARAM;
746 if (len > MAXPATHLEN) {
747 LOG(log_error, logtype_cnid, "cnid_lookup: Path name is too long");
748 errno = CNID_ERR_PATH;
753 rqst.op = CNID_DBD_OP_LOOKUP;
755 if (!(cdb->flags & CNID_FLAG_NODEV)) {
756 rqst.dev = st->st_dev;
759 rqst.ino = st->st_ino;
760 rqst.type = S_ISDIR(st->st_mode)?1:0;
765 LOG(log_debug, logtype_cnid, "cnid_dbd_lookup: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
766 ntohl(did), name, (long long)st->st_ino, rqst.type);
769 if (transmit(db, &rqst, &rply) < 0) {
774 switch (rply.result) {
775 case CNID_DBD_RES_OK:
777 LOG(log_debug, logtype_cnid, "cnid_dbd_lookup: got CNID: %u", ntohl(id));
779 case CNID_DBD_RES_NOTFOUND:
782 case CNID_DBD_RES_ERR_DB:
793 /* ---------------------- */
794 int cnid_dbd_find(struct _cnid_db *cdb, char *name, size_t namelen, void *buffer, size_t buflen)
797 struct cnid_dbd_rqst rqst;
798 struct cnid_dbd_rply rply;
801 if (!cdb || !(db = cdb->_private) || !name) {
802 LOG(log_error, logtype_cnid, "cnid_find: Parameter error");
803 errno = CNID_ERR_PARAM;
807 if (namelen > MAXPATHLEN) {
808 LOG(log_error, logtype_cnid, "cnid_find: Path name is too long");
809 errno = CNID_ERR_PATH;
813 LOG(log_debug, logtype_cnid, "cnid_find(\"%s\")", name);
816 rqst.op = CNID_DBD_OP_SEARCH;
819 rqst.namelen = namelen;
822 rply.namelen = buflen;
824 if (transmit(db, &rqst, &rply) < 0) {
829 switch (rply.result) {
830 case CNID_DBD_RES_OK:
831 count = rply.namelen / sizeof(cnid_t);
832 LOG(log_debug, logtype_cnid, "cnid_find: got %d matches", count);
834 case CNID_DBD_RES_NOTFOUND:
837 case CNID_DBD_RES_ERR_DB:
848 /* ---------------------- */
849 int cnid_dbd_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
850 const cnid_t did, char *name, const size_t len)
853 struct cnid_dbd_rqst rqst;
854 struct cnid_dbd_rply rply;
856 if (!cdb || !(db = cdb->_private) || !id || !st || !name) {
857 LOG(log_error, logtype_cnid, "cnid_update: Parameter error");
858 errno = CNID_ERR_PARAM;
862 if (len > MAXPATHLEN) {
863 LOG(log_error, logtype_cnid, "cnid_update: Path name is too long");
864 errno = CNID_ERR_PATH;
869 rqst.op = CNID_DBD_OP_UPDATE;
871 if (!(cdb->flags & CNID_FLAG_NODEV)) {
872 rqst.dev = st->st_dev;
874 rqst.ino = st->st_ino;
875 rqst.type = S_ISDIR(st->st_mode)?1:0;
880 LOG(log_debug, logtype_cnid, "cnid_dbd_update: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
881 ntohl(id), name, (long long)st->st_ino, rqst.type);
884 if (transmit(db, &rqst, &rply) < 0) {
889 switch (rply.result) {
890 case CNID_DBD_RES_OK:
891 LOG(log_debug, logtype_cnid, "cnid_dbd_update: updated");
892 case CNID_DBD_RES_NOTFOUND:
894 case CNID_DBD_RES_ERR_DB:
902 /* ---------------------- */
903 cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
904 const cnid_t did, char *name, const size_t len,
908 struct cnid_dbd_rqst rqst;
909 struct cnid_dbd_rply rply;
912 if (!cdb || !(db = cdb->_private) || !st || !name || hint == CNID_INVALID) {
913 LOG(log_error, logtype_cnid, "cnid_rebuild_add: Parameter error");
914 errno = CNID_ERR_PARAM;
918 if (len > MAXPATHLEN) {
919 LOG(log_error, logtype_cnid, "cnid_rebuild_add: Path name is too long");
920 errno = CNID_ERR_PATH;
925 rqst.op = CNID_DBD_OP_REBUILD_ADD;
927 if (!(cdb->flags & CNID_FLAG_NODEV)) {
928 rqst.dev = st->st_dev;
931 rqst.ino = st->st_ino;
932 rqst.type = S_ISDIR(st->st_mode)?1:0;
938 LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir), hint: %u",
939 ntohl(did), name, (long long)st->st_ino, rqst.type, hint);
941 if (transmit(db, &rqst, &rply) < 0) {
946 switch(rply.result) {
947 case CNID_DBD_RES_OK:
949 LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: got CNID: %u", ntohl(id));
951 case CNID_DBD_RES_ERR_MAX:
952 errno = CNID_ERR_MAX;
955 case CNID_DBD_RES_ERR_DB:
956 case CNID_DBD_RES_ERR_DUPLCNID:
966 /* ---------------------- */
967 int cnid_dbd_delete(struct _cnid_db *cdb, const cnid_t id)
970 struct cnid_dbd_rqst rqst;
971 struct cnid_dbd_rply rply;
973 if (!cdb || !(db = cdb->_private) || !id) {
974 LOG(log_error, logtype_cnid, "cnid_delete: Parameter error");
975 errno = CNID_ERR_PARAM;
979 LOG(log_debug, logtype_cnid, "cnid_dbd_delete: delete CNID: %u", ntohl(id));
982 rqst.op = CNID_DBD_OP_DELETE;
986 if (transmit(db, &rqst, &rply) < 0) {
991 switch (rply.result) {
992 case CNID_DBD_RES_OK:
993 LOG(log_debug, logtype_cnid, "cnid_dbd_delete: deleted CNID: %u", ntohl(id));
994 case CNID_DBD_RES_NOTFOUND:
996 case CNID_DBD_RES_ERR_DB:
1005 struct _cnid_module cnid_dbd_module = {
1012 #endif /* CNID_DBD */