static int
tapdisk_nbdserver_enable_client(td_nbdserver_client_t *client)
{
INFO("Enable client");
if (client->client_event_id >= 0) {
ERROR("Attempting to enable an already-enabled client");
return -1;
}
if (client->client_fd < 0) {
ERROR("Attempting to register events on a closed client");
return -1;
}
client->client_event_id = tapdisk_server_register_event(
SCHEDULER_POLL_READ_FD,
client->client_fd, 0,
tapdisk_nbdserver_clientcb,
client);
if (client->client_event_id < 0) {
ERROR("Error registering events on client: %d",
client->client_event_id);
return client->client_event_id;
}
return client->client_event_id;
}
static void
td_fdreceiver_accept_fd(event_id_t id, char mode, void *data)
{
struct sockaddr_storage their_addr;
socklen_t sin_size = sizeof(their_addr);
struct td_fdreceiver *fdreceiver = data;
int new_fd;
INFO("Unix domain socket is ready to accept");
new_fd = accept(fdreceiver->fd,
(struct sockaddr *)&their_addr, &sin_size);
if (fdreceiver->client_fd != -1) {
ERROR("td_fdreceiver_accept_fd: can only cope with one connec"
"tion at once to the unix domain socket!");
close(new_fd);
return;
}
fdreceiver->client_fd = new_fd;
fdreceiver->client_event_id =
tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
fdreceiver->client_fd, 0,
td_fdreceiver_recv_fd,
fdreceiver);
if (fdreceiver->client_event_id < 0) {
ERROR("td_fdreceiver_accept_fd: failed to register event "
"(errno=%d)", errno);
close(new_fd);
fdreceiver->client_fd = -1;
}
}
static int ctl_open(struct tdlog_state* s, const char* name)
{
struct sockaddr_un saddr;
if (!(s->ctlpath = ctl_makepath(name, "ctl")))
return -1;
if ((s->ctl.fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
BWPRINTF("error opening control socket: %s", strerror(errno));
goto err;
}
memset(&saddr, 0, sizeof(saddr));
saddr.sun_family = AF_UNIX;
memcpy(saddr.sun_path, s->ctlpath, strlen(s->ctlpath));
if (unlink(s->ctlpath) && errno != ENOENT) {
BWPRINTF("error unlinking old socket path %s: %s", s->ctlpath,
strerror(errno));
goto err_sock;
}
if (bind(s->ctl.fd, (const struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
BWPRINTF("error binding control socket to %s: %s", s->ctlpath,
strerror(errno));
goto err_sock;
}
if (listen(s->ctl.fd, 1) < 0) {
BWPRINTF("error listening on control socket: %s", strerror(errno));
goto err_sock;
}
s->ctl.id = tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
s->ctl.fd, 0, ctl_accept, s);
if (s->ctl.id < 0) {
BWPRINTF("error register event handler: %s", strerror(s->ctl.id));
goto err_sock;
}
return 0;
err_sock:
close(s->ctl.fd);
s->ctl.fd = -1;
err:
free(s->ctlpath);
s->ctlpath = NULL;
return -1;
}
static int
tapdisk_nbdserver_enable_client(td_nbdserver_client_t *client)
{
ASSERT(client);
ASSERT(client->client_event_id == -1);
ASSERT(client->client_fd >= 0);
INFO("Enable client");
client->client_event_id = tapdisk_server_register_event(
SCHEDULER_POLL_READ_FD,
client->client_fd, TV_ZERO,
tapdisk_nbdserver_clientcb,
client);
if (client->client_event_id < 0) {
ERR("Error registering events on client: %d",
client->client_event_id);
return client->client_event_id;
}
return client->client_event_id;
}
struct td_fdreceiver *
td_fdreceiver_start(char *path, fd_cb_t callback, void *data)
{
unsigned int s = -1;
struct sockaddr_un local;
int len;
int err;
struct td_fdreceiver *fdreceiver;
fdreceiver = malloc(sizeof(struct td_fdreceiver));
if (!fdreceiver) {
ERROR("td_fdreceiver_start: error allocating memory for "
"fdreceiver (path=%s)", path);
goto error;
}
fdreceiver->path = strdup(path);
fdreceiver->fd = -1;
fdreceiver->fd_event_id = -1;
fdreceiver->client_fd = -1;
fdreceiver->client_event_id = -1;
fdreceiver->callback = callback;
fdreceiver->callback_data = data;
snprintf(local.sun_path, sizeof(local.sun_path), "%s", path);
local.sun_family = AF_UNIX;
/*
* NB: here we unlink anything that was there before - be very careful
* with the paths you pass to this function!
*/
unlink(local.sun_path);
len = strlen(local.sun_path) + sizeof(local.sun_family);
s = socket(AF_UNIX, SOCK_STREAM, 0);
if (s < 0) {
ERROR("td_fdreceiver_start: error creating socket "
"(path=%s)", path);
goto error;
}
err = bind(s, (struct sockaddr *)&local, len);
if (err < 0) {
ERROR("td_fdreceiver_start: error binding (path=%s)", path);
goto error;
}
err = listen(s, 5);
if (err < 0) {
ERROR("td_fdreceiver_start: error listening (path=%s)", path);
goto error;
}
fdreceiver->fd = s;
fdreceiver->fd_event_id =
tapdisk_server_register_event(SCHEDULER_POLL_READ_FD,
fdreceiver->fd, 0,
td_fdreceiver_accept_fd,
fdreceiver);
if (fdreceiver->fd_event_id < 0) {
ERROR("td_fdreceiver_start: error registering event "
"(path=%s)", path);
goto error;
}
INFO("Set up local unix domain socket on path '%s'", path);
return fdreceiver;
error:
free(fdreceiver);
if (s >= 0)
close(s);
return NULL;
}
