/*
- * $Id: cnid_dbd.c,v 1.17 2010/03/31 09:47:32 franklahm Exp $
- *
* Copyright (C) Joerg Lenneis 2003
+ * Copyright (C) Frank Lahm 2010
* All Rights Reserved. See COPYING.
*/
#ifdef CNID_BACKEND_DBD
#include <stdlib.h>
-#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
-#endif /* HAVE_SYS_STAT_H */
-#ifdef HAVE_SYS_UIO_H
#include <sys/uio.h>
-#endif /* HAVE_SYS_UIO_H */
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
#include <sys/time.h>
#include <sys/un.h>
#include <sys/socket.h>
#include <errno.h>
#include <netdb.h>
#include <time.h>
+#include <arpa/inet.h>
-#include <netatalk/endian.h>
#include <atalk/logger.h>
#include <atalk/adouble.h>
#include <atalk/cnid.h>
-#include "cnid_dbd.h"
#include <atalk/cnid_dbd_private.h>
+#include <atalk/util.h>
+
+#include "cnid_dbd.h"
#ifndef SOL_TCP
#define SOL_TCP IPPROTO_TCP
#endif /* ! SOL_TCP */
+/* Wait MAX_DELAY seconds before a request to the CNID server times out */
+#define MAX_DELAY 20
+#define ONE_DELAY 5
+
static void RQST_RESET(struct cnid_dbd_rqst *r)
{
memset(r, 0, sizeof(struct cnid_dbd_rqst ));
}
-/* ----------- */
-#define MAX_DELAY 10
-
-/* *MUST* be < afp tickle or it's never triggered (got EINTR first) */
-#define SOCK_DELAY 11
-
static void delay(int sec)
{
struct timeval tv;
static int tsock_getfd(const char *host, const char *port)
{
int sock = -1;
- struct timeval tv;
int attr;
int err;
struct addrinfo hints, *servinfo, *p;
+ int optval;
+ socklen_t optlen = sizeof(optval);
/* Prepare hint for getaddrinfo */
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
+#ifdef AI_NUMERICSERV
hints.ai_flags = AI_NUMERICSERV;
+#endif
if ((err = getaddrinfo(host, port, &hints, &servinfo)) != 0) {
- LOG(log_error, logtype_default, "tsock_getfd: getaddrinfo: CNID server %s:%s : %s\n", host, port, gai_strerror(err));
+ LOG(log_error, logtype_default, "tsock_getfd: getaddrinfo: CNID server %s:%s : %s\n",
+ host, port, gai_strerror(err));
return -1;
}
/* loop through all the results and bind to the first we can */
for (p = servinfo; p != NULL; p = p->ai_next) {
if ((sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
- LOG(log_info, logtype_default, "tsock_getfd: socket CNID server %s:: %s", host, strerror(errno));
- continue;
+ LOG(log_info, logtype_default, "tsock_getfd: socket CNID server %s:: %s",
+ host, strerror(errno));
+ continue;
}
attr = 1;
if (setsockopt(sock, SOL_TCP, TCP_NODELAY, &attr, sizeof(attr)) == -1) {
- LOG(log_error, logtype_cnid, "getfd: set TCP_NODELAY CNID server %s: %s", host, strerror(errno));
- close(sock);
- continue;
- }
-
- tv.tv_sec = SOCK_DELAY;
- tv.tv_usec = 0;
- if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
- LOG(log_error, logtype_cnid, "getfd: set SO_RCVTIMEO CNID server %s: %s", host, strerror(errno));
+ LOG(log_error, logtype_cnid, "getfd: set TCP_NODELAY CNID server %s: %s",
+ host, strerror(errno));
close(sock);
- continue;
+ sock = -1;
+ return -1;
}
- tv.tv_sec = SOCK_DELAY;
- tv.tv_usec = 0;
- if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) {
- LOG(log_error, logtype_cnid, "getfd: set SO_SNDTIMEO CNID server %s: %s", host, strerror(errno));
+ if (setnonblock(sock, 1) != 0) {
+ LOG(log_error, logtype_cnid, "getfd: setnonblock: %s", strerror(errno));
close(sock);
- continue;
+ sock = -1;
+ return -1;
}
-
+
if (connect(sock, p->ai_addr, p->ai_addrlen) == -1) {
- err = errno;
- close(sock);
- sock=-1;
- LOG(log_error, logtype_cnid, "getfd: connect CNID server %s: %s", host, strerror(err));
- continue;
+ if (errno == EINPROGRESS) {
+ struct timeval tv;
+ tv.tv_usec = 0;
+ tv.tv_sec = 5; /* give it five seconds ... */
+ fd_set wfds;
+ FD_ZERO(&wfds);
+ FD_SET(sock, &wfds);
+
+ if ((err = select(sock + 1, NULL, &wfds, NULL, &tv)) == 0) {
+ /* timeout */
+ LOG(log_error, logtype_cnid, "getfd: select timed out for CNID server %s",
+ host);
+ close(sock);
+ sock = -1;
+ continue;
+ }
+ if (err == -1) {
+ /* select failed */
+ LOG(log_error, logtype_cnid, "getfd: select failed for CNID server %s",
+ host);
+ close(sock);
+ sock = -1;
+ continue;
+ }
+
+ if ( ! FD_ISSET(sock, &wfds)) {
+ /* give up */
+ LOG(log_error, logtype_cnid, "getfd: socket not ready connecting to %s",
+ host);
+ close(sock);
+ sock = -1;
+ continue;
+ }
+
+ if ((err = getsockopt(sock, SOL_SOCKET, SO_ERROR, &optval, &optlen)) != 0 || optval != 0) {
+ if (err != 0) {
+ /* somethings very wrong */
+ LOG(log_error, logtype_cnid, "getfd: getsockopt error with CNID server %s: %s",
+ host, strerror(errno));
+ } else {
+ errno = optval;
+ LOG(log_error, logtype_cnid, "getfd: getsockopt says: %s",
+ strerror(errno));
+ }
+ close(sock);
+ sock = -1;
+ continue;
+ }
+ } else {
+ LOG(log_error, logtype_cnid, "getfd: connect CNID server %s: %s",
+ host, strerror(errno));
+ close(sock);
+ sock = -1;
+ continue;
+ }
}
-
+
/* We've got a socket */
break;
}
freeaddrinfo(servinfo);
if (p == NULL) {
- LOG(log_error, logtype_cnid, "tsock_getfd: no suitable network config from CNID server %s:%s", host, port);
+ errno = optval;
+ LOG(log_error, logtype_cnid, "tsock_getfd: no suitable network config from CNID server (%s:%s): %s",
+ host, port, strerror(errno));
return -1;
}
return(sock);
}
-/* --------------------- */
-static int write_vec(int fd, struct iovec *iov, size_t towrite)
+/*!
+ * Write "towrite" bytes using writev on non-blocking fd
+ *
+ * Every short write is considered an error, transmit can handle that.
+ *
+ * @param fd (r) socket fd which must be non-blocking
+ * @param iov (r) iovec for writev
+ * @param towrite (r) number of bytes in all iovec elements
+ * @param vecs (r) number of iovecs in array
+ *
+ * @returns "towrite" bytes written or -1 on error
+ */
+static int write_vec(int fd, struct iovec *iov, ssize_t towrite, int vecs)
{
ssize_t len;
- size_t len1;
+ int slept = 0;
+ int sleepsecs;
- len1 = iov[1].iov_len;
- while (towrite > 0) {
- if (((len = writev(fd, iov, 2)) == -1 && errno == EINTR) || !len)
+ while (1) {
+ if (((len = writev(fd, iov, vecs)) == -1 && errno == EINTR))
continue;
- if ((size_t)len == towrite) /* wrote everything out */
- break;
- else if (len < 0) { /* error */
- return -1;
+ if ((! slept) && len == -1 && errno == EAGAIN) {
+ sleepsecs = 2;
+ while ((sleepsecs = sleep(sleepsecs)));
+ slept = 1;
+ continue;
}
- towrite -= len;
- if (towrite > len1) { /* skip part of header */
- iov[0].iov_base = (char *) iov[0].iov_base + len;
- iov[0].iov_len -= len;
- } else { /* skip to data */
- if (iov[0].iov_len) {
- len -= iov[0].iov_len;
- iov[0].iov_len = 0;
- }
- iov[1].iov_base = (char *) iov[1].iov_base + len;
- iov[1].iov_len -= len;
- }
+ if (len == towrite) /* wrote everything out */
+ break;
+
+ if (len == -1)
+ LOG(log_error, logtype_cnid, "write_vec: %s", strerror(errno));
+ else
+ LOG(log_error, logtype_cnid, "write_vec: short write: %d", len);
+ return len;
}
- LOG(log_maxdebug, logtype_cnid, "write_vec: wrote %d bytes", towrite);
+ LOG(log_maxdebug, logtype_cnid, "write_vec: wrote %d bytes", len);
- return 0;
+ return len;
}
/* --------------------- */
int len;
struct iovec iov[2];
- LOG(log_debug, logtype_cnid, "init_tsock: BEGIN. Opening volume '%s', CNID Server: %s/%s",
+ LOG(log_debug, logtype_cnid, "init_tsock: BEGIN. Opening volume '%s', CNID Server: %s/%s",
db->db_dir, db->cnidserver, db->cnidport);
if ((fd = tsock_getfd(db->cnidserver, db->cnidport)) < 0)
iov[1].iov_base = db->db_dir;
iov[1].iov_len = len;
- if (write_vec(fd, iov, len + sizeof(int)) < 0) {
+ if (write_vec(fd, iov, len + sizeof(int), 2) != len + sizeof(int)) {
LOG(log_error, logtype_cnid, "init_tsock: Error/short write: %s", strerror(errno));
close(fd);
return -1;
{
struct iovec iov[2];
size_t towrite;
-
- if (!rqst->namelen) {
- if (write(db->fd, rqst, sizeof(struct cnid_dbd_rqst)) != sizeof(struct cnid_dbd_rqst)) {
- LOG(log_warning, logtype_cnid, "send_packet: Error/short write rqst (db_dir %s): %s",
- db->db_dir, strerror(errno));
- return -1;
- }
- LOG(log_maxdebug, logtype_cnid, "send_packet: OK");
- return 0;
- }
+ int vecs;
iov[0].iov_base = rqst;
iov[0].iov_len = sizeof(struct cnid_dbd_rqst);
+ towrite = sizeof(struct cnid_dbd_rqst);
+ vecs = 1;
- iov[1].iov_base = rqst->name;
- iov[1].iov_len = rqst->namelen;
-
- towrite = sizeof(struct cnid_dbd_rqst) +rqst->namelen;
+ if (rqst->namelen) {
+ iov[1].iov_base = (char *)rqst->name;
+ iov[1].iov_len = rqst->namelen;
+ towrite += rqst->namelen;
+ vecs++;
+ }
- if (write_vec(db->fd, iov, towrite) < 0) {
+ if (write_vec(db->fd, iov, towrite, vecs) != towrite) {
LOG(log_warning, logtype_cnid, "send_packet: Error writev rqst (db_dir %s): %s",
db->db_dir, strerror(errno));
return -1;
}
-
+
LOG(log_maxdebug, logtype_cnid, "send_packet: {done}");
return 0;
}
return 0;
}
-/* ------------------- */
-static ssize_t dbd_read(int socket, void *data, const size_t length)
-{
- size_t stored;
- ssize_t len;
-
- stored = 0;
- while (stored < length) {
- len = read(socket, (u_int8_t *) data + stored, length - stored);
- if (len == -1) {
- if (errno == EINTR)
- continue;
- return -1;
- }
- else if (len > 0)
- stored += len;
- else
- break;
- }
- return stored;
-}
-
/* ---------------------
* send a request and get reply
* assume send is non blocking
len = rply->namelen;
nametmp = rply->name;
- ret = dbd_read(db->fd, rply, sizeof(struct cnid_dbd_rply));
+ ret = readt(db->fd, rply, sizeof(struct cnid_dbd_rply), 0, ONE_DELAY);
if (ret != sizeof(struct cnid_dbd_rply)) {
- LOG(log_error, logtype_cnid, "dbd_rpc: Error reading header from fd (db_dir %s): %s",
- db->db_dir, ret == -1?strerror(errno):"closed");
+ LOG(log_debug, logtype_cnid, "dbd_rpc: Error reading header from fd (db_dir %s): %s",
+ db->db_dir, ret == -1 ? strerror(errno) : "closed");
rply->name = nametmp;
return -1;
}
db->db_dir, rply->name, rply->namelen, len);
return -1;
}
- if (rply->namelen && (ret = dbd_read(db->fd, rply->name, rply->namelen)) != (ssize_t)rply->namelen) {
+ if (rply->namelen && (ret = readt(db->fd, rply->name, rply->namelen, 0, ONE_DELAY)) != (ssize_t)rply->namelen) {
LOG(log_error, logtype_cnid, "dbd_rpc: Error reading name from fd (db_dir %s): %s",
db->db_dir, ret == -1?strerror(errno):"closed");
return -1;
return -1;
}
LOG(log_debug7, logtype_cnid, "transmit: ... OK.");
- }
- else {
+ } else { /* db->notfirst == 0 */
db->notfirst = 1;
if (db->client_stamp)
memcpy(db->client_stamp, stamp, ADEDLEN_PRIVSYN);
memcpy(db->stamp, stamp, ADEDLEN_PRIVSYN);
}
- LOG(log_debug, logtype_cnid, "transmit: attached to '%s', stamp: '%08lx'.",
+ LOG(log_debug, logtype_cnid, "transmit: attached to '%s', stamp: '%08lx'.",
db->db_dir, *(uint64_t *)stamp);
}
if (!dbd_rpc(db, rqst, rply)) {
db->fd = -1; /* FD not valid... will need to reconnect */
}
+ if (errno == ECONNREFUSED) { /* errno carefully injected in tsock_getfd */
+ /* give up */
+ LOG(log_error, logtype_cnid, "transmit: connection refused (db_dir %s)", db->db_dir);
+ return -1;
+ }
+
if (!clean) { /* don't sleep if just got disconnected by cnid server */
time(&t);
if (t - orig > MAX_DELAY) {
return -1;
}
/* sleep a little before retry */
- delay(2);
+ delay(1);
} else {
clean = 0; /* false... next time sleep */
time(&orig);
cdb->cnid_delete = cnid_dbd_delete;
cdb->cnid_get = cnid_dbd_get;
cdb->cnid_lookup = cnid_dbd_lookup;
+ cdb->cnid_find = cnid_dbd_find;
cdb->cnid_nextid = NULL;
cdb->cnid_resolve = cnid_dbd_resolve;
cdb->cnid_getstamp = cnid_dbd_getstamp;
CNID_private *db;
if (!cdb) {
- LOG(log_error, logtype_cnid, "cnid_close called with NULL argument !");
+ LOG(log_error, logtype_cnid, "cnid_close called with NULL argument!");
return;
}
/* ---------------------- */
cnid_t cnid_dbd_add(struct _cnid_db *cdb, const struct stat *st,
- const cnid_t did, char *name, const size_t len,
- cnid_t hint)
+ cnid_t did, const char *name, size_t len, cnid_t hint)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
}
/* ---------------------- */
-cnid_t cnid_dbd_get(struct _cnid_db *cdb, const cnid_t did, char *name, const size_t len)
+cnid_t cnid_dbd_get(struct _cnid_db *cdb, cnid_t did, const char *name, size_t len)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
rqst.op = CNID_DBD_OP_RESOLVE;
rqst.cnid = *id;
- /* This mimicks the behaviour of the "regular" cnid_resolve. So far,
- nobody uses the content of buffer. It only provides space for the
- name in the caller. */
- rply.name = (char *)buffer + CNID_HEADER_LEN;
- rply.namelen = len - CNID_HEADER_LEN;
+ /* Pass buffer to transmit so it can stuff the reply data there */
+ rply.name = (char *)buffer;
+ rply.namelen = len;
if (transmit(db, &rqst, &rply) < 0) {
errno = CNID_ERR_DB;
switch (rply.result) {
case CNID_DBD_RES_OK:
*id = rply.did;
- name = rply.name;
+ name = rply.name + CNID_NAME_OFS;
LOG(log_debug, logtype_cnid, "cnid_dbd_resolve: resolved did: %u, name: '%s'", ntohl(*id), name);
break;
case CNID_DBD_RES_NOTFOUND:
}
/* ---------------------- */
-cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
- char *name, const size_t len)
+cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, cnid_t did,
+ const char *name, size_t len)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
}
/* ---------------------- */
-int cnid_dbd_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
- const cnid_t did, char *name, const size_t len)
+int cnid_dbd_find(struct _cnid_db *cdb, const char *name, size_t namelen, void *buffer, size_t buflen)
+{
+ CNID_private *db;
+ struct cnid_dbd_rqst rqst;
+ struct cnid_dbd_rply rply;
+ int count;
+
+ if (!cdb || !(db = cdb->_private) || !name) {
+ LOG(log_error, logtype_cnid, "cnid_find: Parameter error");
+ errno = CNID_ERR_PARAM;
+ return CNID_INVALID;
+ }
+
+ if (namelen > MAXPATHLEN) {
+ LOG(log_error, logtype_cnid, "cnid_find: Path name is too long");
+ errno = CNID_ERR_PATH;
+ return CNID_INVALID;
+ }
+
+ LOG(log_debug, logtype_cnid, "cnid_find(\"%s\")", name);
+
+ RQST_RESET(&rqst);
+ rqst.op = CNID_DBD_OP_SEARCH;
+
+ rqst.name = name;
+ rqst.namelen = namelen;
+
+ rply.name = buffer;
+ rply.namelen = buflen;
+
+ if (transmit(db, &rqst, &rply) < 0) {
+ errno = CNID_ERR_DB;
+ return CNID_INVALID;
+ }
+
+ switch (rply.result) {
+ case CNID_DBD_RES_OK:
+ count = rply.namelen / sizeof(cnid_t);
+ LOG(log_debug, logtype_cnid, "cnid_find: got %d matches", count);
+ break;
+ case CNID_DBD_RES_NOTFOUND:
+ count = 0;
+ break;
+ case CNID_DBD_RES_ERR_DB:
+ errno = CNID_ERR_DB;
+ count = -1;
+ break;
+ default:
+ abort();
+ }
+
+ return count;
+}
+
+/* ---------------------- */
+int cnid_dbd_update(struct _cnid_db *cdb, cnid_t id, const struct stat *st,
+ cnid_t did, const char *name, size_t len)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
/* ---------------------- */
cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
- const cnid_t did, char *name, const size_t len,
- cnid_t hint)
+ cnid_t did, const char *name, size_t len, cnid_t hint)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
projects / netatalk.git / blobdiff