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
18 #include <sys/socket.h>
19 #include <sys/param.h>
21 #include <netinet/in.h>
23 #include <netinet/tcp.h>
24 #include <netinet/in.h>
25 #include <arpa/inet.h>
29 #include <arpa/inet.h>
31 #include <atalk/logger.h>
32 #include <atalk/adouble.h>
33 #include <atalk/cnid.h>
34 #include <atalk/cnid_dbd_private.h>
35 #include <atalk/util.h>
40 #define SOL_TCP IPPROTO_TCP
41 #endif /* ! SOL_TCP */
43 /* Wait MAX_DELAY seconds before a request to the CNID server times out */
47 static void RQST_RESET(struct cnid_dbd_rqst *r)
49 memset(r, 0, sizeof(struct cnid_dbd_rqst ));
52 static void delay(int sec)
58 select(0, NULL, NULL, NULL, &tv);
61 static int tsock_getfd(const char *host, const char *port)
66 struct addrinfo hints, *servinfo, *p;
68 socklen_t optlen = sizeof(optval);
70 /* Prepare hint for getaddrinfo */
71 memset(&hints, 0, sizeof hints);
72 hints.ai_family = AF_UNSPEC;
73 hints.ai_socktype = SOCK_STREAM;
75 hints.ai_flags = AI_NUMERICSERV;
78 if ((err = getaddrinfo(host, port, &hints, &servinfo)) != 0) {
79 LOG(log_error, logtype_default, "tsock_getfd: getaddrinfo: CNID server %s:%s : %s\n",
80 host, port, gai_strerror(err));
84 /* loop through all the results and bind to the first we can */
85 for (p = servinfo; p != NULL; p = p->ai_next) {
86 if ((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
87 LOG(log_info, logtype_default, "tsock_getfd: socket CNID server %s:: %s",
88 host, strerror(errno));
93 if (setsockopt(sock, SOL_TCP, TCP_NODELAY, &attr, sizeof(attr)) == -1) {
94 LOG(log_error, logtype_cnid, "getfd: set TCP_NODELAY CNID server %s: %s",
95 host, strerror(errno));
101 if (setnonblock(sock, 1) != 0) {
102 LOG(log_error, logtype_cnid, "getfd: setnonblock: %s", strerror(errno));
108 if (connect(sock, p->ai_addr, p->ai_addrlen) == -1) {
109 if (errno == EINPROGRESS) {
112 tv.tv_sec = 5; /* give it five seconds ... */
117 if ((err = select(sock + 1, NULL, &wfds, NULL, &tv)) == 0) {
119 LOG(log_error, logtype_cnid, "getfd: select timed out for CNID server %s",
127 LOG(log_error, logtype_cnid, "getfd: select failed for CNID server %s",
134 if ( ! FD_ISSET(sock, &wfds)) {
136 LOG(log_error, logtype_cnid, "getfd: socket not ready connecting to %s",
143 if ((err = getsockopt(sock, SOL_SOCKET, SO_ERROR, &optval, &optlen)) != 0 || optval != 0) {
145 /* somethings very wrong */
146 LOG(log_error, logtype_cnid, "getfd: getsockopt error with CNID server %s: %s",
147 host, strerror(errno));
150 LOG(log_error, logtype_cnid, "getfd: getsockopt says: %s",
158 LOG(log_error, logtype_cnid, "getfd: connect CNID server %s: %s",
159 host, strerror(errno));
166 /* We've got a socket */
170 freeaddrinfo(servinfo);
174 LOG(log_error, logtype_cnid, "tsock_getfd: no suitable network config from CNID server (%s:%s): %s",
175 host, port, strerror(errno));
183 * Write "towrite" bytes using writev on non-blocking fd
185 * Every short write is considered an error, transmit can handle that.
187 * @param fd (r) socket fd which must be non-blocking
188 * @param iov (r) iovec for writev
189 * @param towrite (r) number of bytes in all iovec elements
190 * @param vecs (r) number of iovecs in array
192 * @returns "towrite" bytes written or -1 on error
194 static int write_vec(int fd, struct iovec *iov, ssize_t towrite, int vecs)
201 if (((len = writev(fd, iov, vecs)) == -1 && errno == EINTR))
204 if ((! slept) && len == -1 && errno == EAGAIN) {
206 while ((sleepsecs = sleep(sleepsecs)));
211 if (len == towrite) /* wrote everything out */
215 LOG(log_error, logtype_cnid, "write_vec: %s", strerror(errno));
217 LOG(log_error, logtype_cnid, "write_vec: short write: %d", len);
221 LOG(log_maxdebug, logtype_cnid, "write_vec: wrote %d bytes", len);
226 /* --------------------- */
227 static int init_tsock(CNID_private *db)
233 LOG(log_debug, logtype_cnid, "init_tsock: BEGIN. Opening volume '%s', CNID Server: %s/%s",
234 db->db_dir, db->cnidserver, db->cnidport);
236 if ((fd = tsock_getfd(db->cnidserver, db->cnidport)) < 0)
239 len = strlen(db->db_dir);
241 iov[0].iov_base = &len;
242 iov[0].iov_len = sizeof(int);
244 iov[1].iov_base = db->db_dir;
245 iov[1].iov_len = len;
247 if (write_vec(fd, iov, len + sizeof(int), 2) != len + sizeof(int)) {
248 LOG(log_error, logtype_cnid, "init_tsock: Error/short write: %s", strerror(errno));
253 LOG(log_debug, logtype_cnid, "init_tsock: ok");
258 /* --------------------- */
259 static int send_packet(CNID_private *db, struct cnid_dbd_rqst *rqst)
265 iov[0].iov_base = rqst;
266 iov[0].iov_len = sizeof(struct cnid_dbd_rqst);
267 towrite = sizeof(struct cnid_dbd_rqst);
271 iov[1].iov_base = (char *)rqst->name;
272 iov[1].iov_len = rqst->namelen;
273 towrite += rqst->namelen;
277 if (write_vec(db->fd, iov, towrite, vecs) != towrite) {
278 LOG(log_warning, logtype_cnid, "send_packet: Error writev rqst (db_dir %s): %s",
279 db->db_dir, strerror(errno));
283 LOG(log_maxdebug, logtype_cnid, "send_packet: {done}");
287 /* ------------------- */
288 static void dbd_initstamp(struct cnid_dbd_rqst *rqst)
291 rqst->op = CNID_DBD_OP_GETSTAMP;
294 /* ------------------- */
295 static int dbd_reply_stamp(struct cnid_dbd_rply *rply)
297 switch (rply->result) {
298 case CNID_DBD_RES_OK:
300 case CNID_DBD_RES_NOTFOUND:
302 case CNID_DBD_RES_ERR_DB:
310 /* ---------------------
311 * send a request and get reply
312 * assume send is non blocking
313 * if no answer after sometime (at least MAX_DELAY secondes) return an error
315 static int dbd_rpc(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
321 if (send_packet(db, rqst) < 0) {
325 nametmp = rply->name;
327 ret = readt(db->fd, rply, sizeof(struct cnid_dbd_rply), 0, ONE_DELAY);
329 if (ret != sizeof(struct cnid_dbd_rply)) {
330 LOG(log_debug, logtype_cnid, "dbd_rpc: Error reading header from fd (db_dir %s): %s",
331 db->db_dir, ret == -1 ? strerror(errno) : "closed");
332 rply->name = nametmp;
335 rply->name = nametmp;
336 if (rply->namelen && rply->namelen > len) {
337 LOG(log_error, logtype_cnid,
338 "dbd_rpc: Error reading name (db_dir %s): %s name too long: %d. only wanted %d, garbage?",
339 db->db_dir, rply->name, rply->namelen, len);
342 if (rply->namelen && (ret = readt(db->fd, rply->name, rply->namelen, 0, ONE_DELAY)) != (ssize_t)rply->namelen) {
343 LOG(log_error, logtype_cnid, "dbd_rpc: Error reading name from fd (db_dir %s): %s",
344 db->db_dir, ret == -1?strerror(errno):"closed");
348 LOG(log_maxdebug, logtype_cnid, "dbd_rpc: {done}");
353 /* -------------------- */
354 static int transmit(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
357 int clean = 1; /* no errors so far - to prevent sleep on first try */
360 /* volume and db don't have the same timestamp
366 struct cnid_dbd_rqst rqst_stamp;
367 struct cnid_dbd_rply rply_stamp;
368 char stamp[ADEDLEN_PRIVSYN];
370 LOG(log_maxdebug, logtype_cnid, "transmit: connecting to cnid_dbd ...");
371 if ((db->fd = init_tsock(db)) < 0) {
374 dbd_initstamp(&rqst_stamp);
375 memset(stamp, 0, ADEDLEN_PRIVSYN);
376 rply_stamp.name = stamp;
377 rply_stamp.namelen = ADEDLEN_PRIVSYN;
379 if (dbd_rpc(db, &rqst_stamp, &rply_stamp) < 0)
381 if (dbd_reply_stamp(&rply_stamp ) < 0)
385 LOG(log_debug7, logtype_cnid, "transmit: reconnected to cnid_dbd, comparing database stamps...");
386 if (memcmp(stamp, db->stamp, ADEDLEN_PRIVSYN)) {
387 LOG(log_error, logtype_cnid, "transmit: ... not the same db!");
391 LOG(log_debug7, logtype_cnid, "transmit: ... OK.");
392 } else { /* db->notfirst == 0 */
394 if (db->client_stamp)
395 memcpy(db->client_stamp, stamp, ADEDLEN_PRIVSYN);
396 memcpy(db->stamp, stamp, ADEDLEN_PRIVSYN);
398 LOG(log_debug, logtype_cnid, "transmit: attached to '%s', stamp: '%08lx'.",
399 db->db_dir, *(uint64_t *)stamp);
401 if (!dbd_rpc(db, rqst, rply)) {
402 LOG(log_maxdebug, logtype_cnid, "transmit: {done}");
408 db->fd = -1; /* FD not valid... will need to reconnect */
411 if (errno == ECONNREFUSED) { /* errno carefully injected in tsock_getfd */
413 LOG(log_error, logtype_cnid, "transmit: connection refused (db_dir %s)", db->db_dir);
417 if (!clean) { /* don't sleep if just got disconnected by cnid server */
419 if (t - orig > MAX_DELAY) {
420 LOG(log_error, logtype_cnid, "transmit: Request to dbd daemon (db_dir %s) timed out.", db->db_dir);
423 /* sleep a little before retry */
426 clean = 0; /* false... next time sleep */
433 /* ---------------------- */
434 static struct _cnid_db *cnid_dbd_new(const char *volpath)
436 struct _cnid_db *cdb;
438 if ((cdb = (struct _cnid_db *)calloc(1, sizeof(struct _cnid_db))) == NULL)
441 if ((cdb->volpath = strdup(volpath)) == NULL) {
446 cdb->flags = CNID_FLAG_PERSISTENT | CNID_FLAG_LAZY_INIT;
448 cdb->cnid_add = cnid_dbd_add;
449 cdb->cnid_delete = cnid_dbd_delete;
450 cdb->cnid_get = cnid_dbd_get;
451 cdb->cnid_lookup = cnid_dbd_lookup;
452 cdb->cnid_find = cnid_dbd_find;
453 cdb->cnid_nextid = NULL;
454 cdb->cnid_resolve = cnid_dbd_resolve;
455 cdb->cnid_getstamp = cnid_dbd_getstamp;
456 cdb->cnid_update = cnid_dbd_update;
457 cdb->cnid_rebuild_add = cnid_dbd_rebuild_add;
458 cdb->cnid_close = cnid_dbd_close;
459 cdb->cnid_wipe = cnid_dbd_wipe;
463 /* ---------------------- */
464 struct _cnid_db *cnid_dbd_open(struct cnid_open_args *args)
466 CNID_private *db = NULL;
467 struct _cnid_db *cdb = NULL;
473 if ((cdb = cnid_dbd_new(args->dir)) == NULL) {
474 LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
478 if ((db = (CNID_private *)calloc(1, sizeof(CNID_private))) == NULL) {
479 LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
480 goto cnid_dbd_open_fail;
485 /* We keep a copy of the directory in the db structure so that we can
486 transparently reconnect later. */
487 strcpy(db->db_dir, args->dir);
488 db->magic = CNID_DB_MAGIC;
490 db->cnidserver = strdup(args->cnidserver);
491 db->cnidport = strdup(args->cnidport);
493 LOG(log_debug, logtype_cnid, "cnid_dbd_open: Finished initializing cnid dbd module for volume '%s'", db->db_dir);
499 if (cdb->volpath != NULL) {
510 /* ---------------------- */
511 void cnid_dbd_close(struct _cnid_db *cdb)
516 LOG(log_error, logtype_cnid, "cnid_close called with NULL argument !");
520 if ((db = cdb->_private) != NULL) {
521 LOG(log_debug, logtype_cnid, "closing database connection for volume '%s'", db->db_dir);
534 /* ---------------------- */
535 cnid_t cnid_dbd_add(struct _cnid_db *cdb, const struct stat *st,
536 cnid_t did, const char *name, size_t len, cnid_t hint)
539 struct cnid_dbd_rqst rqst;
540 struct cnid_dbd_rply rply;
543 if (!cdb || !(db = cdb->_private) || !st || !name) {
544 LOG(log_error, logtype_cnid, "cnid_add: Parameter error");
545 errno = CNID_ERR_PARAM;
549 if (len > MAXPATHLEN) {
550 LOG(log_error, logtype_cnid, "cnid_add: Path name is too long");
551 errno = CNID_ERR_PATH;
556 rqst.op = CNID_DBD_OP_ADD;
558 if (!(cdb->flags & CNID_FLAG_NODEV)) {
559 rqst.dev = st->st_dev;
562 rqst.ino = st->st_ino;
563 rqst.type = S_ISDIR(st->st_mode)?1:0;
569 LOG(log_debug, logtype_cnid, "cnid_dbd_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
570 ntohl(did), name, (long long)st->st_ino, rqst.type);
573 if (transmit(db, &rqst, &rply) < 0) {
578 switch(rply.result) {
579 case CNID_DBD_RES_OK:
581 LOG(log_debug, logtype_cnid, "cnid_dbd_add: got CNID: %u", ntohl(id));
583 case CNID_DBD_RES_ERR_MAX:
584 errno = CNID_ERR_MAX;
587 case CNID_DBD_RES_ERR_DB:
588 case CNID_DBD_RES_ERR_DUPLCNID:
599 /* ---------------------- */
600 cnid_t cnid_dbd_get(struct _cnid_db *cdb, cnid_t did, const char *name, size_t len)
603 struct cnid_dbd_rqst rqst;
604 struct cnid_dbd_rply rply;
607 if (!cdb || !(db = cdb->_private) || !name) {
608 LOG(log_error, logtype_cnid, "cnid_dbd_get: Parameter error");
609 errno = CNID_ERR_PARAM;
613 if (len > MAXPATHLEN) {
614 LOG(log_error, logtype_cnid, "cnid_dbd_get: Path name is too long");
615 errno = CNID_ERR_PATH;
619 LOG(log_debug, logtype_cnid, "cnid_dbd_get: DID: %u, name: '%s'", ntohl(did), name);
622 rqst.op = CNID_DBD_OP_GET;
628 if (transmit(db, &rqst, &rply) < 0) {
633 switch(rply.result) {
634 case CNID_DBD_RES_OK:
636 LOG(log_debug, logtype_cnid, "cnid_dbd_get: got CNID: %u", ntohl(id));
638 case CNID_DBD_RES_NOTFOUND:
641 case CNID_DBD_RES_ERR_DB:
652 /* ---------------------- */
653 char *cnid_dbd_resolve(struct _cnid_db *cdb, cnid_t *id, void *buffer, size_t len)
656 struct cnid_dbd_rqst rqst;
657 struct cnid_dbd_rply rply;
660 if (!cdb || !(db = cdb->_private) || !id || !(*id)) {
661 LOG(log_error, logtype_cnid, "cnid_resolve: Parameter error");
662 errno = CNID_ERR_PARAM;
666 LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolving CNID: %u", ntohl(*id));
668 /* TODO: We should maybe also check len. At the moment we rely on the caller
669 to provide a buffer that is large enough for MAXPATHLEN plus
670 CNID_HEADER_LEN plus 1 byte, which is large enough for the maximum that
671 can come from the database. */
674 rqst.op = CNID_DBD_OP_RESOLVE;
677 /* Pass buffer to transmit so it can stuff the reply data there */
678 rply.name = (char *)buffer;
681 if (transmit(db, &rqst, &rply) < 0) {
687 switch (rply.result) {
688 case CNID_DBD_RES_OK:
690 name = rply.name + CNID_NAME_OFS;
691 LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolved did: %u, name: '%s'", ntohl(*id), name);
693 case CNID_DBD_RES_NOTFOUND:
697 case CNID_DBD_RES_ERR_DB:
709 /* ---------------------- */
710 int cnid_dbd_getstamp(struct _cnid_db *cdb, void *buffer, const size_t len)
714 if (!cdb || !(db = cdb->_private) || len != ADEDLEN_PRIVSYN) {
715 LOG(log_error, logtype_cnid, "cnid_getstamp: Parameter error");
716 errno = CNID_ERR_PARAM;
719 db->client_stamp = buffer;
720 db->stamp_size = len;
721 memset(buffer,0, len);
725 /* ---------------------- */
726 cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, cnid_t did,
727 const char *name, size_t len)
730 struct cnid_dbd_rqst rqst;
731 struct cnid_dbd_rply rply;
734 if (!cdb || !(db = cdb->_private) || !st || !name) {
735 LOG(log_error, logtype_cnid, "cnid_lookup: Parameter error");
736 errno = CNID_ERR_PARAM;
740 if (len > MAXPATHLEN) {
741 LOG(log_error, logtype_cnid, "cnid_lookup: Path name is too long");
742 errno = CNID_ERR_PATH;
747 rqst.op = CNID_DBD_OP_LOOKUP;
749 if (!(cdb->flags & CNID_FLAG_NODEV)) {
750 rqst.dev = st->st_dev;
753 rqst.ino = st->st_ino;
754 rqst.type = S_ISDIR(st->st_mode)?1:0;
759 LOG(log_debug, logtype_cnid, "cnid_dbd_lookup: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
760 ntohl(did), name, (long long)st->st_ino, rqst.type);
763 if (transmit(db, &rqst, &rply) < 0) {
768 switch (rply.result) {
769 case CNID_DBD_RES_OK:
771 LOG(log_debug, logtype_cnid, "cnid_dbd_lookup: got CNID: %u", ntohl(id));
773 case CNID_DBD_RES_NOTFOUND:
776 case CNID_DBD_RES_ERR_DB:
787 /* ---------------------- */
788 int cnid_dbd_find(struct _cnid_db *cdb, const char *name, size_t namelen, void *buffer, size_t buflen)
791 struct cnid_dbd_rqst rqst;
792 struct cnid_dbd_rply rply;
795 if (!cdb || !(db = cdb->_private) || !name) {
796 LOG(log_error, logtype_cnid, "cnid_find: Parameter error");
797 errno = CNID_ERR_PARAM;
801 if (namelen > MAXPATHLEN) {
802 LOG(log_error, logtype_cnid, "cnid_find: Path name is too long");
803 errno = CNID_ERR_PATH;
807 LOG(log_debug, logtype_cnid, "cnid_find(\"%s\")", name);
810 rqst.op = CNID_DBD_OP_SEARCH;
813 rqst.namelen = namelen;
816 rply.namelen = buflen;
818 if (transmit(db, &rqst, &rply) < 0) {
823 switch (rply.result) {
824 case CNID_DBD_RES_OK:
825 count = rply.namelen / sizeof(cnid_t);
826 LOG(log_debug, logtype_cnid, "cnid_find: got %d matches", count);
828 case CNID_DBD_RES_NOTFOUND:
831 case CNID_DBD_RES_ERR_DB:
842 /* ---------------------- */
843 int cnid_dbd_update(struct _cnid_db *cdb, cnid_t id, const struct stat *st,
844 cnid_t did, const char *name, size_t len)
847 struct cnid_dbd_rqst rqst;
848 struct cnid_dbd_rply rply;
850 if (!cdb || !(db = cdb->_private) || !id || !st || !name) {
851 LOG(log_error, logtype_cnid, "cnid_update: Parameter error");
852 errno = CNID_ERR_PARAM;
856 if (len > MAXPATHLEN) {
857 LOG(log_error, logtype_cnid, "cnid_update: Path name is too long");
858 errno = CNID_ERR_PATH;
863 rqst.op = CNID_DBD_OP_UPDATE;
865 if (!(cdb->flags & CNID_FLAG_NODEV)) {
866 rqst.dev = st->st_dev;
868 rqst.ino = st->st_ino;
869 rqst.type = S_ISDIR(st->st_mode)?1:0;
874 LOG(log_debug, logtype_cnid, "cnid_dbd_update: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
875 ntohl(id), name, (long long)st->st_ino, rqst.type);
878 if (transmit(db, &rqst, &rply) < 0) {
883 switch (rply.result) {
884 case CNID_DBD_RES_OK:
885 LOG(log_debug, logtype_cnid, "cnid_dbd_update: updated");
886 case CNID_DBD_RES_NOTFOUND:
888 case CNID_DBD_RES_ERR_DB:
896 /* ---------------------- */
897 cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
898 cnid_t did, const char *name, size_t len, cnid_t hint)
901 struct cnid_dbd_rqst rqst;
902 struct cnid_dbd_rply rply;
905 if (!cdb || !(db = cdb->_private) || !st || !name || hint == CNID_INVALID) {
906 LOG(log_error, logtype_cnid, "cnid_rebuild_add: Parameter error");
907 errno = CNID_ERR_PARAM;
911 if (len > MAXPATHLEN) {
912 LOG(log_error, logtype_cnid, "cnid_rebuild_add: Path name is too long");
913 errno = CNID_ERR_PATH;
918 rqst.op = CNID_DBD_OP_REBUILD_ADD;
920 if (!(cdb->flags & CNID_FLAG_NODEV)) {
921 rqst.dev = st->st_dev;
924 rqst.ino = st->st_ino;
925 rqst.type = S_ISDIR(st->st_mode)?1:0;
931 LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir), hint: %u",
932 ntohl(did), name, (long long)st->st_ino, rqst.type, hint);
934 if (transmit(db, &rqst, &rply) < 0) {
939 switch(rply.result) {
940 case CNID_DBD_RES_OK:
942 LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: got CNID: %u", ntohl(id));
944 case CNID_DBD_RES_ERR_MAX:
945 errno = CNID_ERR_MAX;
948 case CNID_DBD_RES_ERR_DB:
949 case CNID_DBD_RES_ERR_DUPLCNID:
959 /* ---------------------- */
960 int cnid_dbd_delete(struct _cnid_db *cdb, const cnid_t id)
963 struct cnid_dbd_rqst rqst;
964 struct cnid_dbd_rply rply;
966 if (!cdb || !(db = cdb->_private) || !id) {
967 LOG(log_error, logtype_cnid, "cnid_delete: Parameter error");
968 errno = CNID_ERR_PARAM;
972 LOG(log_debug, logtype_cnid, "cnid_dbd_delete: delete CNID: %u", ntohl(id));
975 rqst.op = CNID_DBD_OP_DELETE;
979 if (transmit(db, &rqst, &rply) < 0) {
984 switch (rply.result) {
985 case CNID_DBD_RES_OK:
986 LOG(log_debug, logtype_cnid, "cnid_dbd_delete: deleted CNID: %u", ntohl(id));
987 case CNID_DBD_RES_NOTFOUND:
989 case CNID_DBD_RES_ERR_DB:
997 int cnid_dbd_wipe(struct _cnid_db *cdb)
1000 struct cnid_dbd_rqst rqst;
1001 struct cnid_dbd_rply rply;
1003 if (!cdb || !(db = cdb->_private)) {
1004 LOG(log_error, logtype_cnid, "cnid_wipe: Parameter error");
1005 errno = CNID_ERR_PARAM;
1009 LOG(log_debug, logtype_cnid, "cnid_dbd_wipe");
1012 rqst.op = CNID_DBD_OP_WIPE;
1016 if (transmit(db, &rqst, &rply) < 0) {
1017 errno = CNID_ERR_DB;
1021 if (rply.result != CNID_DBD_RES_OK) {
1022 errno = CNID_ERR_DB;
1025 LOG(log_debug, logtype_cnid, "cnid_dbd_wipe: ok");
1027 struct cnid_dbd_rqst rqst_stamp;
1028 struct cnid_dbd_rply rply_stamp;
1029 char stamp[ADEDLEN_PRIVSYN];
1031 dbd_initstamp(&rqst_stamp);
1032 memset(stamp, 0, ADEDLEN_PRIVSYN);
1033 rply_stamp.name = stamp;
1034 rply_stamp.namelen = ADEDLEN_PRIVSYN;
1036 if (dbd_rpc(db, &rqst_stamp, &rply_stamp) < 0)
1038 if (dbd_reply_stamp(&rply_stamp ) < 0)
1041 if (db->client_stamp)
1042 memcpy(db->client_stamp, stamp, ADEDLEN_PRIVSYN);
1043 memcpy(db->stamp, stamp, ADEDLEN_PRIVSYN);
1049 struct _cnid_module cnid_dbd_module = {
1056 #endif /* CNID_DBD */