2 * $Id: cnid_dbd.c,v 1.17 2010/03/31 09:47:32 franklahm Exp $
4 * Copyright (C) Joerg Lenneis 2003
5 * All Rights Reserved. See COPYING.
10 #endif /* HAVE_CONFIG_H */
12 #ifdef CNID_BACKEND_DBD
15 #ifdef HAVE_SYS_STAT_H
17 #endif /* HAVE_SYS_STAT_H */
20 #endif /* HAVE_SYS_UIO_H */
26 #include <sys/socket.h>
27 #include <sys/param.h>
29 #include <netinet/in.h>
31 #include <netinet/tcp.h>
32 #include <netinet/in.h>
33 #include <arpa/inet.h>
38 #include <netatalk/endian.h>
39 #include <atalk/logger.h>
40 #include <atalk/adouble.h>
41 #include <atalk/cnid.h>
43 #include <atalk/cnid_dbd_private.h>
46 #define SOL_TCP IPPROTO_TCP
47 #endif /* ! SOL_TCP */
49 static void RQST_RESET(struct cnid_dbd_rqst *r)
51 memset(r, 0, sizeof(struct cnid_dbd_rqst ));
57 /* *MUST* be < afp tickle or it's never triggered (got EINTR first) */
60 static void delay(int sec)
66 select(0, NULL, NULL, NULL, &tv);
69 static int tsock_getfd(const char *host, const char *port)
75 struct addrinfo hints, *servinfo, *p;
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", host, port, gai_strerror(err));
88 /* loop through all the results and bind to the first we can */
89 for (p = servinfo; p != NULL; p = p->ai_next) {
90 if ((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
91 LOG(log_info, logtype_default, "tsock_getfd: socket CNID server %s:: %s", host, strerror(errno));
96 if (setsockopt(sock, SOL_TCP, TCP_NODELAY, &attr, sizeof(attr)) == -1) {
97 LOG(log_error, logtype_cnid, "getfd: set TCP_NODELAY CNID server %s: %s", host, strerror(errno));
102 tv.tv_sec = SOCK_DELAY;
104 if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
105 LOG(log_error, logtype_cnid, "getfd: set SO_RCVTIMEO CNID server %s: %s", host, strerror(errno));
110 tv.tv_sec = SOCK_DELAY;
112 if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) {
113 LOG(log_error, logtype_cnid, "getfd: set SO_SNDTIMEO CNID server %s: %s", host, strerror(errno));
118 if (connect(sock, p->ai_addr, p->ai_addrlen) == -1) {
122 LOG(log_error, logtype_cnid, "getfd: connect CNID server %s: %s", host, strerror(err));
126 /* We've got a socket */
130 freeaddrinfo(servinfo);
133 LOG(log_error, logtype_cnid, "tsock_getfd: no suitable network config from CNID server %s:%s", host, port);
140 /* --------------------- */
141 static int write_vec(int fd, struct iovec *iov, size_t towrite)
146 len1 = iov[1].iov_len;
147 while (towrite > 0) {
148 if (((len = writev(fd, iov, 2)) == -1 && errno == EINTR) || !len)
151 if ((size_t)len == towrite) /* wrote everything out */
153 else if (len < 0) { /* error */
158 if (towrite > len1) { /* skip part of header */
159 iov[0].iov_base = (char *) iov[0].iov_base + len;
160 iov[0].iov_len -= len;
161 } else { /* skip to data */
162 if (iov[0].iov_len) {
163 len -= iov[0].iov_len;
166 iov[1].iov_base = (char *) iov[1].iov_base + len;
167 iov[1].iov_len -= len;
171 LOG(log_maxdebug, logtype_cnid, "write_vec: wrote %d bytes", towrite);
176 /* --------------------- */
177 static int init_tsock(CNID_private *db)
183 LOG(log_debug, logtype_cnid, "init_tsock: BEGIN. Opening volume '%s', CNID Server: %s/%s",
184 db->db_dir, db->cnidserver, db->cnidport);
186 if ((fd = tsock_getfd(db->cnidserver, db->cnidport)) < 0)
189 len = strlen(db->db_dir);
191 iov[0].iov_base = &len;
192 iov[0].iov_len = sizeof(int);
194 iov[1].iov_base = db->db_dir;
195 iov[1].iov_len = len;
197 if (write_vec(fd, iov, len + sizeof(int)) < 0) {
198 LOG(log_error, logtype_cnid, "init_tsock: Error/short write: %s", strerror(errno));
203 LOG(log_debug, logtype_cnid, "init_tsock: ok");
208 /* --------------------- */
209 static int send_packet(CNID_private *db, struct cnid_dbd_rqst *rqst)
214 if (!rqst->namelen) {
215 if (write(db->fd, rqst, sizeof(struct cnid_dbd_rqst)) != sizeof(struct cnid_dbd_rqst)) {
216 LOG(log_warning, logtype_cnid, "send_packet: Error/short write rqst (db_dir %s): %s",
217 db->db_dir, strerror(errno));
220 LOG(log_maxdebug, logtype_cnid, "send_packet: OK");
224 iov[0].iov_base = rqst;
225 iov[0].iov_len = sizeof(struct cnid_dbd_rqst);
227 iov[1].iov_base = rqst->name;
228 iov[1].iov_len = rqst->namelen;
230 towrite = sizeof(struct cnid_dbd_rqst) +rqst->namelen;
232 if (write_vec(db->fd, iov, towrite) < 0) {
233 LOG(log_warning, logtype_cnid, "send_packet: Error writev rqst (db_dir %s): %s",
234 db->db_dir, strerror(errno));
238 LOG(log_maxdebug, logtype_cnid, "send_packet: {done}");
242 /* ------------------- */
243 static void dbd_initstamp(struct cnid_dbd_rqst *rqst)
246 rqst->op = CNID_DBD_OP_GETSTAMP;
249 /* ------------------- */
250 static int dbd_reply_stamp(struct cnid_dbd_rply *rply)
252 switch (rply->result) {
253 case CNID_DBD_RES_OK:
255 case CNID_DBD_RES_NOTFOUND:
257 case CNID_DBD_RES_ERR_DB:
265 /* ------------------- */
266 static ssize_t dbd_read(int socket, void *data, const size_t length)
272 while (stored < length) {
273 len = read(socket, (u_int8_t *) data + stored, length - stored);
287 /* ---------------------
288 * send a request and get reply
289 * assume send is non blocking
290 * if no answer after sometime (at least MAX_DELAY secondes) return an error
292 static int dbd_rpc(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
298 if (send_packet(db, rqst) < 0) {
302 nametmp = rply->name;
304 ret = dbd_read(db->fd, rply, sizeof(struct cnid_dbd_rply));
306 if (ret != sizeof(struct cnid_dbd_rply)) {
307 LOG(log_error, logtype_cnid, "dbd_rpc: Error reading header from fd (db_dir %s): %s",
308 db->db_dir, ret == -1?strerror(errno):"closed");
309 rply->name = nametmp;
312 rply->name = nametmp;
313 if (rply->namelen && rply->namelen > len) {
314 LOG(log_error, logtype_cnid,
315 "dbd_rpc: Error reading name (db_dir %s): %s name too long: %d. only wanted %d, garbage?",
316 db->db_dir, rply->name, rply->namelen, len);
319 if (rply->namelen && (ret = dbd_read(db->fd, rply->name, rply->namelen)) != (ssize_t)rply->namelen) {
320 LOG(log_error, logtype_cnid, "dbd_rpc: Error reading name from fd (db_dir %s): %s",
321 db->db_dir, ret == -1?strerror(errno):"closed");
325 LOG(log_maxdebug, logtype_cnid, "dbd_rpc: {done}");
330 /* -------------------- */
331 static int transmit(CNID_private *db, struct cnid_dbd_rqst *rqst, struct cnid_dbd_rply *rply)
334 int clean = 1; /* no errors so far - to prevent sleep on first try */
337 /* volume and db don't have the same timestamp
343 struct cnid_dbd_rqst rqst_stamp;
344 struct cnid_dbd_rply rply_stamp;
345 char stamp[ADEDLEN_PRIVSYN];
347 LOG(log_maxdebug, logtype_cnid, "transmit: connecting to cnid_dbd ...");
348 if ((db->fd = init_tsock(db)) < 0) {
351 dbd_initstamp(&rqst_stamp);
352 memset(stamp, 0, ADEDLEN_PRIVSYN);
353 rply_stamp.name = stamp;
354 rply_stamp.namelen = ADEDLEN_PRIVSYN;
356 if (dbd_rpc(db, &rqst_stamp, &rply_stamp) < 0)
358 if (dbd_reply_stamp(&rply_stamp ) < 0)
362 LOG(log_debug7, logtype_cnid, "transmit: reconnected to cnid_dbd, comparing database stamps...");
363 if (memcmp(stamp, db->stamp, ADEDLEN_PRIVSYN)) {
364 LOG(log_error, logtype_cnid, "transmit: ... not the same db!");
368 LOG(log_debug7, logtype_cnid, "transmit: ... OK.");
372 if (db->client_stamp)
373 memcpy(db->client_stamp, stamp, ADEDLEN_PRIVSYN);
374 memcpy(db->stamp, stamp, ADEDLEN_PRIVSYN);
376 LOG(log_debug, logtype_cnid, "transmit: attached to '%s', stamp: '%08lx'.",
377 db->db_dir, *(uint64_t *)stamp);
379 if (!dbd_rpc(db, rqst, rply)) {
380 LOG(log_maxdebug, logtype_cnid, "transmit: {done}");
386 db->fd = -1; /* FD not valid... will need to reconnect */
389 if (!clean) { /* don't sleep if just got disconnected by cnid server */
391 if (t - orig > MAX_DELAY) {
392 LOG(log_error, logtype_cnid, "transmit: Request to dbd daemon (db_dir %s) timed out.", db->db_dir);
395 /* sleep a little before retry */
398 clean = 0; /* false... next time sleep */
405 /* ---------------------- */
406 static struct _cnid_db *cnid_dbd_new(const char *volpath)
408 struct _cnid_db *cdb;
410 if ((cdb = (struct _cnid_db *)calloc(1, sizeof(struct _cnid_db))) == NULL)
413 if ((cdb->volpath = strdup(volpath)) == NULL) {
418 cdb->flags = CNID_FLAG_PERSISTENT | CNID_FLAG_LAZY_INIT;
420 cdb->cnid_add = cnid_dbd_add;
421 cdb->cnid_delete = cnid_dbd_delete;
422 cdb->cnid_get = cnid_dbd_get;
423 cdb->cnid_lookup = cnid_dbd_lookup;
424 cdb->cnid_nextid = NULL;
425 cdb->cnid_resolve = cnid_dbd_resolve;
426 cdb->cnid_getstamp = cnid_dbd_getstamp;
427 cdb->cnid_update = cnid_dbd_update;
428 cdb->cnid_rebuild_add = cnid_dbd_rebuild_add;
429 cdb->cnid_close = cnid_dbd_close;
434 /* ---------------------- */
435 struct _cnid_db *cnid_dbd_open(struct cnid_open_args *args)
437 CNID_private *db = NULL;
438 struct _cnid_db *cdb = NULL;
444 if ((cdb = cnid_dbd_new(args->dir)) == NULL) {
445 LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
449 if ((db = (CNID_private *)calloc(1, sizeof(CNID_private))) == NULL) {
450 LOG(log_error, logtype_cnid, "cnid_open: Unable to allocate memory for database");
451 goto cnid_dbd_open_fail;
456 /* We keep a copy of the directory in the db structure so that we can
457 transparently reconnect later. */
458 strcpy(db->db_dir, args->dir);
459 db->magic = CNID_DB_MAGIC;
461 db->cnidserver = strdup(args->cnidserver);
462 db->cnidport = strdup(args->cnidport);
464 LOG(log_debug, logtype_cnid, "cnid_dbd_open: Finished initializing cnid dbd module for volume '%s'", db->db_dir);
470 if (cdb->volpath != NULL) {
481 /* ---------------------- */
482 void cnid_dbd_close(struct _cnid_db *cdb)
487 LOG(log_error, logtype_cnid, "cnid_close called with NULL argument !");
491 if ((db = cdb->_private) != NULL) {
492 LOG(log_debug, logtype_cnid, "closing database connection for volume '%s'", db->db_dir);
505 /* ---------------------- */
506 cnid_t cnid_dbd_add(struct _cnid_db *cdb, const struct stat *st,
507 const cnid_t did, char *name, const size_t len,
511 struct cnid_dbd_rqst rqst;
512 struct cnid_dbd_rply rply;
515 if (!cdb || !(db = cdb->_private) || !st || !name) {
516 LOG(log_error, logtype_cnid, "cnid_add: Parameter error");
517 errno = CNID_ERR_PARAM;
521 if (len > MAXPATHLEN) {
522 LOG(log_error, logtype_cnid, "cnid_add: Path name is too long");
523 errno = CNID_ERR_PATH;
528 rqst.op = CNID_DBD_OP_ADD;
530 if (!(cdb->flags & CNID_FLAG_NODEV)) {
531 rqst.dev = st->st_dev;
534 rqst.ino = st->st_ino;
535 rqst.type = S_ISDIR(st->st_mode)?1:0;
541 LOG(log_debug, logtype_cnid, "cnid_dbd_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
542 ntohl(did), name, (long long)st->st_ino, rqst.type);
545 if (transmit(db, &rqst, &rply) < 0) {
550 switch(rply.result) {
551 case CNID_DBD_RES_OK:
553 LOG(log_debug, logtype_cnid, "cnid_dbd_add: got CNID: %u", ntohl(id));
555 case CNID_DBD_RES_ERR_MAX:
556 errno = CNID_ERR_MAX;
559 case CNID_DBD_RES_ERR_DB:
560 case CNID_DBD_RES_ERR_DUPLCNID:
571 /* ---------------------- */
572 cnid_t cnid_dbd_get(struct _cnid_db *cdb, const cnid_t did, char *name, const size_t len)
575 struct cnid_dbd_rqst rqst;
576 struct cnid_dbd_rply rply;
579 if (!cdb || !(db = cdb->_private) || !name) {
580 LOG(log_error, logtype_cnid, "cnid_dbd_get: Parameter error");
581 errno = CNID_ERR_PARAM;
585 if (len > MAXPATHLEN) {
586 LOG(log_error, logtype_cnid, "cnid_dbd_get: Path name is too long");
587 errno = CNID_ERR_PATH;
591 LOG(log_debug, logtype_cnid, "cnid_dbd_get: DID: %u, name: '%s'", ntohl(did), name);
594 rqst.op = CNID_DBD_OP_GET;
600 if (transmit(db, &rqst, &rply) < 0) {
605 switch(rply.result) {
606 case CNID_DBD_RES_OK:
608 LOG(log_debug, logtype_cnid, "cnid_dbd_get: got CNID: %u", ntohl(id));
610 case CNID_DBD_RES_NOTFOUND:
613 case CNID_DBD_RES_ERR_DB:
624 /* ---------------------- */
625 char *cnid_dbd_resolve(struct _cnid_db *cdb, cnid_t *id, void *buffer, size_t len)
628 struct cnid_dbd_rqst rqst;
629 struct cnid_dbd_rply rply;
632 if (!cdb || !(db = cdb->_private) || !id || !(*id)) {
633 LOG(log_error, logtype_cnid, "cnid_resolve: Parameter error");
634 errno = CNID_ERR_PARAM;
638 LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolving CNID: %u", ntohl(*id));
640 /* TODO: We should maybe also check len. At the moment we rely on the caller
641 to provide a buffer that is large enough for MAXPATHLEN plus
642 CNID_HEADER_LEN plus 1 byte, which is large enough for the maximum that
643 can come from the database. */
646 rqst.op = CNID_DBD_OP_RESOLVE;
649 /* This mimicks the behaviour of the "regular" cnid_resolve. So far,
650 nobody uses the content of buffer. It only provides space for the
651 name in the caller. */
652 rply.name = (char *)buffer + CNID_HEADER_LEN;
653 rply.namelen = len - CNID_HEADER_LEN;
655 if (transmit(db, &rqst, &rply) < 0) {
661 switch (rply.result) {
662 case CNID_DBD_RES_OK:
665 LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolved did: %u, name: '%s'", ntohl(*id), name);
667 case CNID_DBD_RES_NOTFOUND:
671 case CNID_DBD_RES_ERR_DB:
683 /* ---------------------- */
684 int cnid_dbd_getstamp(struct _cnid_db *cdb, void *buffer, const size_t len)
688 if (!cdb || !(db = cdb->_private) || len != ADEDLEN_PRIVSYN) {
689 LOG(log_error, logtype_cnid, "cnid_getstamp: Parameter error");
690 errno = CNID_ERR_PARAM;
693 db->client_stamp = buffer;
694 db->stamp_size = len;
695 memset(buffer,0, len);
699 /* ---------------------- */
700 cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
701 char *name, const size_t len)
704 struct cnid_dbd_rqst rqst;
705 struct cnid_dbd_rply rply;
708 if (!cdb || !(db = cdb->_private) || !st || !name) {
709 LOG(log_error, logtype_cnid, "cnid_lookup: Parameter error");
710 errno = CNID_ERR_PARAM;
714 if (len > MAXPATHLEN) {
715 LOG(log_error, logtype_cnid, "cnid_lookup: Path name is too long");
716 errno = CNID_ERR_PATH;
721 rqst.op = CNID_DBD_OP_LOOKUP;
723 if (!(cdb->flags & CNID_FLAG_NODEV)) {
724 rqst.dev = st->st_dev;
727 rqst.ino = st->st_ino;
728 rqst.type = S_ISDIR(st->st_mode)?1:0;
733 LOG(log_debug, logtype_cnid, "cnid_dbd_lookup: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
734 ntohl(did), name, (long long)st->st_ino, rqst.type);
737 if (transmit(db, &rqst, &rply) < 0) {
742 switch (rply.result) {
743 case CNID_DBD_RES_OK:
745 LOG(log_debug, logtype_cnid, "cnid_dbd_lookup: got CNID: %u", ntohl(id));
747 case CNID_DBD_RES_NOTFOUND:
750 case CNID_DBD_RES_ERR_DB:
761 /* ---------------------- */
762 int cnid_dbd_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
763 const cnid_t did, char *name, const size_t len)
766 struct cnid_dbd_rqst rqst;
767 struct cnid_dbd_rply rply;
769 if (!cdb || !(db = cdb->_private) || !id || !st || !name) {
770 LOG(log_error, logtype_cnid, "cnid_update: Parameter error");
771 errno = CNID_ERR_PARAM;
775 if (len > MAXPATHLEN) {
776 LOG(log_error, logtype_cnid, "cnid_update: Path name is too long");
777 errno = CNID_ERR_PATH;
782 rqst.op = CNID_DBD_OP_UPDATE;
784 if (!(cdb->flags & CNID_FLAG_NODEV)) {
785 rqst.dev = st->st_dev;
787 rqst.ino = st->st_ino;
788 rqst.type = S_ISDIR(st->st_mode)?1:0;
793 LOG(log_debug, logtype_cnid, "cnid_dbd_update: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir)",
794 ntohl(id), name, (long long)st->st_ino, rqst.type);
797 if (transmit(db, &rqst, &rply) < 0) {
802 switch (rply.result) {
803 case CNID_DBD_RES_OK:
804 LOG(log_debug, logtype_cnid, "cnid_dbd_update: updated");
805 case CNID_DBD_RES_NOTFOUND:
807 case CNID_DBD_RES_ERR_DB:
815 /* ---------------------- */
816 cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
817 const cnid_t did, char *name, const size_t len,
821 struct cnid_dbd_rqst rqst;
822 struct cnid_dbd_rply rply;
825 if (!cdb || !(db = cdb->_private) || !st || !name || hint == CNID_INVALID) {
826 LOG(log_error, logtype_cnid, "cnid_rebuild_add: Parameter error");
827 errno = CNID_ERR_PARAM;
831 if (len > MAXPATHLEN) {
832 LOG(log_error, logtype_cnid, "cnid_rebuild_add: Path name is too long");
833 errno = CNID_ERR_PATH;
838 rqst.op = CNID_DBD_OP_REBUILD_ADD;
840 if (!(cdb->flags & CNID_FLAG_NODEV)) {
841 rqst.dev = st->st_dev;
844 rqst.ino = st->st_ino;
845 rqst.type = S_ISDIR(st->st_mode)?1:0;
851 LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: CNID: %u, name: '%s', inode: 0x%llx, type: %d (0=file, 1=dir), hint: %u",
852 ntohl(did), name, (long long)st->st_ino, rqst.type, hint);
854 if (transmit(db, &rqst, &rply) < 0) {
859 switch(rply.result) {
860 case CNID_DBD_RES_OK:
862 LOG(log_debug, logtype_cnid, "cnid_dbd_rebuild_add: got CNID: %u", ntohl(id));
864 case CNID_DBD_RES_ERR_MAX:
865 errno = CNID_ERR_MAX;
868 case CNID_DBD_RES_ERR_DB:
869 case CNID_DBD_RES_ERR_DUPLCNID:
879 /* ---------------------- */
880 int cnid_dbd_delete(struct _cnid_db *cdb, const cnid_t id)
883 struct cnid_dbd_rqst rqst;
884 struct cnid_dbd_rply rply;
886 if (!cdb || !(db = cdb->_private) || !id) {
887 LOG(log_error, logtype_cnid, "cnid_delete: Parameter error");
888 errno = CNID_ERR_PARAM;
892 LOG(log_debug, logtype_cnid, "cnid_dbd_delete: delete CNID: %u", ntohl(id));
895 rqst.op = CNID_DBD_OP_DELETE;
899 if (transmit(db, &rqst, &rply) < 0) {
904 switch (rply.result) {
905 case CNID_DBD_RES_OK:
906 LOG(log_debug, logtype_cnid, "cnid_dbd_delete: deleted CNID: %u", ntohl(id));
907 case CNID_DBD_RES_NOTFOUND:
909 case CNID_DBD_RES_ERR_DB:
918 struct _cnid_module cnid_dbd_module = {
925 #endif /* CNID_DBD */