void nn_priolist_activate (struct nn_priolist *self, struct nn_pipe *pipe,
struct nn_priolist_data *data)
{
struct nn_priolist_slot *slot;
slot = &self->slots [data->priority - 1];
/* If there are already some elements in this slot, current pipe is not
going to change. */
if (!nn_list_empty (&slot->pipes)) {
nn_list_insert (&slot->pipes, &data->item, nn_list_end (&slot->pipes));
return;
}
/* Add first pipe into the slot. If there are no pipes in priolist at all
this slot becomes current. */
nn_list_insert (&slot->pipes, &data->item, nn_list_end (&slot->pipes));
slot->current = data;
if (self->current == -1) {
self->current = data->priority;
return;
}
/* If the current priority is lower than the one of the newly activated
pipe, this slot becomes current. */
if (self->current > data->priority) {
self->current = data->priority;
return;
}
/* Current doesn't change otherwise. */
}
static void nn_ctx_add_transport (struct nn_transport *transport)
{
transport->init ();
nn_list_insert (&self.transports, &transport->list,
nn_list_end (&self.transports));
}
int nn_sock_add_ep (struct nn_sock *self, struct nn_transport *transport,
int bind, const char *addr)
{
int rc;
struct nn_ep *ep;
int eid;
nn_ctx_enter (&self->ctx);
/* Instantiate the endpoint. */
ep = nn_alloc (sizeof (struct nn_ep), "endpoint");
rc = nn_ep_init (ep, NN_SOCK_SRC_EP, self, self->eid, transport,
bind, addr);
if (nn_slow (rc < 0)) {
nn_free (ep);
nn_ctx_leave (&self->ctx);
return rc;
}
nn_ep_start (ep);
/* Increase the endpoint ID for the next endpoint. */
eid = self->eid;
++self->eid;
/* Add it to the list of active endpoints. */
nn_list_insert (&self->eps, &ep->item, nn_list_end (&self->eps));
nn_ctx_leave (&self->ctx);
return eid;
}
void nn_ins_connect (struct nn_ins_item *item, nn_ins_fn fn)
{
struct nn_list_item *it;
struct nn_ins_item *bitem;
nn_mutex_lock (&self.sync);
/* Insert the entry into the endpoint repository. */
nn_list_insert (&self.connected, &item->item,
nn_list_end (&self.connected));
/* During this process a pipe may be created. */
for (it = nn_list_begin (&self.bound);
it != nn_list_end (&self.bound);
it = nn_list_next (&self.bound, it)) {
bitem = nn_cont (it, struct nn_ins_item, item);
if (strncmp (nn_epbase_getaddr (&item->epbase),
nn_epbase_getaddr (&bitem->epbase), NN_SOCKADDR_MAX) == 0) {
/* Check whether the two sockets are compatible. */
if (!nn_epbase_ispeer (&item->epbase, bitem->protocol))
break;
/* Call back to cinproc to create actual connection. */
fn (item, bitem);
break;
}
}
nn_mutex_unlock (&self.sync);
}
static void nn_global_add_transport (struct nn_transport *transport)
{
if (transport->init)
transport->init ();
nn_list_insert (&self.transports, &transport->item,
nn_list_end (&self.transports));
}
static void nn_cinproc_connect (struct nn_ins_item *self,
struct nn_ins_item *peer)
{
struct nn_cinproc *cinproc;
struct nn_binproc *binproc;
struct nn_sinproc *sinproc;
cinproc = nn_cont (self, struct nn_cinproc, item);
binproc = nn_cont (peer, struct nn_binproc, item);
nn_assert_state (cinproc, NN_CINPROC_STATE_ACTIVE);
sinproc = nn_alloc (sizeof (struct nn_sinproc), "sinproc");
alloc_assert (sinproc);
nn_sinproc_init (sinproc, NN_CINPROC_SRC_SINPROC,
cinproc->item.ep, &cinproc->fsm);
nn_list_insert (&cinproc->sinprocs, &sinproc->item,
nn_list_end (&cinproc->sinprocs));
nn_sinproc_connect (sinproc, &binproc->fsm);
nn_ep_stat_increment (cinproc->item.ep, NN_STAT_INPROGRESS_CONNECTIONS, -1);
nn_ep_stat_increment (cinproc->item.ep, NN_STAT_ESTABLISHED_CONNECTIONS, 1);
}
static int nn_inproc_ctx_connect (const char *addr, void *hint,
struct nn_epbase **epbase)
{
int rc;
struct nn_list_item *it;
struct nn_inprocc *inprocc;
struct nn_inprocb *inprocb;
struct nn_msgpipe *pipe;
/* Insert the entry into the endpoint repository. */
inprocc = nn_alloc (sizeof (struct nn_inprocc), "inprocc");
alloc_assert (inprocc);
rc = nn_inprocc_init (inprocc, addr, hint);
if (nn_slow (rc != 0))
return rc;
nn_list_insert (&self.connected, &inprocc->list,
nn_list_end (&self.connected));
/* During this process a pipe may be created. */
for (it = nn_list_begin (&self.bound);
it != nn_list_end (&self.bound);
it = nn_list_next (&self.bound, it)) {
inprocb = nn_cont (it, struct nn_inprocb, list);
if (strcmp (addr, nn_inprocb_getaddr (inprocb)) == 0) {
pipe = nn_alloc (sizeof (struct nn_msgpipe), "msgpipe");
alloc_assert (pipe);
nn_msgpipe_init (pipe, inprocb, inprocc);
break;
}
}
nn_assert (epbase);
*epbase = &inprocc->epbase;
return 0;
}
int ftw_publisher_construct(struct ftw_socket_callsite **callsite, const char *addr,
int linger, struct ftw_socket **sock)
{
struct ftw_socket *inst;
int rcs;
int rco;
int rcb;
/* Preconditions expected of LabVIEW. */
ftw_assert(*callsite && addr);
nn_mutex_lock(&(*callsite)->sync);
rcs = nn_socket(AF_SP, NN_PUB);
/* Socket creation failure? */
if (rcs < 0) {
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rcs;
}
rco = nn_setsockopt(rcs, NN_SOL_SOCKET, NN_LINGER, &linger, sizeof(linger));
if (rco < 0) {
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rco;
}
rcb = nn_bind(rcs, addr);
/* Endpoint creation failure? */
if (rcb < 0) {
nn_close(rcs);
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rcb;
}
inst = ftw_malloc(sizeof(struct ftw_socket));
ftw_assert(inst);
memset(inst, 0, sizeof(*inst));
inst->id = rcs;
inst->callsite = *callsite;
nn_list_item_init(&inst->item);
nn_list_insert(&(*callsite)->active_sockets, &inst->item,
nn_list_end(&(*callsite)->active_sockets));
*sock = inst;
(*callsite)->lifetime_sockets++;
nn_mutex_unlock(&(*callsite)->sync);
return 0;
}
void nn_binproc_connect (struct nn_binproc *self, struct nn_cinproc *peer)
{
struct nn_sinproc *sinproc;
nn_assert (self->state == NN_BINPROC_STATE_ACTIVE);
sinproc = nn_alloc (sizeof (struct nn_sinproc), "sinproc");
alloc_assert (sinproc);
nn_sinproc_init (sinproc, NN_BINPROC_SRC_SINPROC,
&self->epbase, &self->fsm);
nn_list_insert (&self->sinprocs, &sinproc->item,
nn_list_end (&self->sinprocs));
nn_sinproc_connect (sinproc, &peer->fsm);
}
/* Allocate a new message chunk, append it to message array, and return
pointer to its buffer. */
static void *nn_msg_chunk_new (size_t size, struct nn_list *msg_array)
{
struct msg_chunk *self;
self = nn_alloc (sizeof (struct msg_chunk), "msg_chunk");
alloc_assert (self);
nn_chunkref_init (&self->chunk, size);
nn_list_item_init (&self->item);
nn_list_insert (msg_array, &self->item, nn_list_end (msg_array));
return nn_chunkref_data (&self->chunk);
}
static int nn_inproc_bind (const char *addr, void *hint,
struct nn_epbase **epbase)
{
struct nn_list_item *it;
struct nn_binproc *binproc;
struct nn_cinproc *cinproc;
nn_mutex_lock (&self.sync);
/* Check whether the endpoint isn't already bound. */
/* TODO: This is an O(n) algorithm! */
for (it = nn_list_begin (&self.bound); it != nn_list_end (&self.bound);
it = nn_list_next (&self.bound, it)) {
binproc = nn_cont (it, struct nn_binproc, item);
if (strncmp (addr, nn_binproc_getaddr (binproc),
NN_SOCKADDR_MAX) == 0) {
nn_mutex_unlock (&self.sync);
return -EADDRINUSE;
}
}
/* Insert the entry into the endpoint repository. */
binproc = nn_binproc_create (hint);
nn_list_insert (&self.bound, &binproc->item, nn_list_end (&self.bound));
/* During this process new pipes may be created. */
for (it = nn_list_begin (&self.connected);
it != nn_list_end (&self.connected);
it = nn_list_next (&self.connected, it)) {
cinproc = nn_cont (it, struct nn_cinproc, item);
if (strncmp (addr, nn_cinproc_getaddr (cinproc),
NN_SOCKADDR_MAX) == 0) {
/* Check whether the two sockets are compatible. */
if (!nn_epbase_ispeer (&binproc->epbase, cinproc->protocol))
continue;
nn_assert (cinproc->connects == 0);
cinproc->connects = 1;
nn_binproc_connect (binproc, cinproc);
}
}
nn_assert (epbase);
*epbase = &binproc->epbase;
nn_mutex_unlock (&self.sync);
return 0;
}
int nn_ins_bind (struct nn_ins_item *item, nn_ins_fn fn)
{
struct nn_list_item *it;
struct nn_ins_item *bitem;
struct nn_ins_item *citem;
nn_mutex_lock (&self.sync);
/* Check whether the endpoint isn't already bound. */
/* TODO: This is an O(n) algorithm! */
for (it = nn_list_begin (&self.bound); it != nn_list_end (&self.bound);
it = nn_list_next (&self.bound, it)) {
bitem = nn_cont (it, struct nn_ins_item, item);
if (strncmp (nn_ep_getaddr(bitem->ep), nn_ep_getaddr(item->ep),
NN_SOCKADDR_MAX) == 0) {
nn_mutex_unlock (&self.sync);
return -EADDRINUSE;
}
}
/* Insert the entry into the endpoint repository. */
nn_list_insert (&self.bound, &item->item,
nn_list_end (&self.bound));
/* During this process new pipes may be created. */
for (it = nn_list_begin (&self.connected);
it != nn_list_end (&self.connected);
it = nn_list_next (&self.connected, it)) {
citem = nn_cont (it, struct nn_ins_item, item);
if (strncmp (nn_ep_getaddr(item->ep), nn_ep_getaddr(citem->ep),
NN_SOCKADDR_MAX) == 0) {
/* Check whether the two sockets are compatible. */
if (!nn_ep_ispeer_ep (item->ep, citem->ep))
continue;
fn (item, citem);
}
}
nn_mutex_unlock (&self.sync);
return 0;
}
static int nn_inproc_ctx_bind (const char *addr, void *hint,
struct nn_epbase **epbase)
{
int rc;
struct nn_list_item *it;
struct nn_inprocb *inprocb;
struct nn_inprocc *inprocc;
struct nn_msgpipe *pipe;
/* Check whether the endpoint isn't already bound. */
/* TODO: This is an O(n) algorithm! */
for (it = nn_list_begin (&self.bound); it != nn_list_end (&self.bound);
it = nn_list_next (&self.bound, it)) {
inprocb = nn_cont (it, struct nn_inprocb, list);
if (strncmp (addr, nn_inprocb_getaddr (inprocb), NN_SOCKADDR_MAX) == 0)
return -EADDRINUSE;
}
/* Insert the entry into the endpoint repository. */
inprocb = nn_alloc (sizeof (struct nn_inprocb), "inprocb");
alloc_assert (inprocb);
rc = nn_inprocb_init (inprocb, addr, hint);
if (nn_slow (rc != 0))
return rc;
nn_list_insert (&self.bound, &inprocb->list, nn_list_end (&self.bound));
/* During this process new pipes may be created. */
for (it = nn_list_begin (&self.connected);
it != nn_list_end (&self.connected);
it = nn_list_next (&self.connected, it)) {
inprocc = nn_cont (it, struct nn_inprocc, list);
if (strncmp (addr, nn_inprocc_getaddr (inprocc),
NN_SOCKADDR_MAX) == 0) {
pipe = nn_alloc (sizeof (struct nn_msgpipe), "msgpipe");
alloc_assert (pipe);
nn_msgpipe_init (pipe, inprocb, inprocc);
}
}
nn_assert (epbase);
*epbase = &inprocb->epbase;
return 0;
}
static void nn_binproc_connect (struct nn_ins_item *self,
struct nn_ins_item *peer)
{
struct nn_binproc *binproc;
struct nn_cinproc *cinproc;
struct nn_sinproc *sinproc;
binproc = nn_cont (self, struct nn_binproc, item);
cinproc = nn_cont (peer, struct nn_cinproc, item);
nn_assert (binproc->state == NN_BINPROC_STATE_ACTIVE);
sinproc = nn_alloc (sizeof (struct nn_sinproc), "sinproc");
alloc_assert (sinproc);
nn_sinproc_init (sinproc, NN_BINPROC_SRC_SINPROC,
&binproc->item.epbase, &binproc->fsm);
nn_list_insert (&binproc->sinprocs, &sinproc->item,
nn_list_end (&binproc->sinprocs));
nn_sinproc_connect (sinproc, &cinproc->fsm);
}
static void nn_sock_shutdown (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_sock *sock;
struct nn_list_item *it;
struct nn_ep *ep;
sock = nn_cont (self, struct nn_sock, fsm);
if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
nn_assert (sock->state == NN_SOCK_STATE_ACTIVE ||
sock->state == NN_SOCK_STATE_ZOMBIE);
/* Close sndfd and rcvfd. This should make any current
select/poll using SNDFD and/or RCVFD exit. */
if (!(sock->socktype->flags & NN_SOCKTYPE_FLAG_NORECV)) {
nn_efd_term (&sock->rcvfd);
memset (&sock->rcvfd, 0xcd, sizeof (sock->rcvfd));
}
if (!(sock->socktype->flags & NN_SOCKTYPE_FLAG_NOSEND)) {
nn_efd_term (&sock->sndfd);
memset (&sock->sndfd, 0xcd, sizeof (sock->sndfd));
}
/* Ask all the associated endpoints to stop. */
it = nn_list_begin (&sock->eps);
while (it != nn_list_end (&sock->eps)) {
ep = nn_cont (it, struct nn_ep, item);
it = nn_list_next (&sock->eps, it);
nn_list_erase (&sock->eps, &ep->item);
nn_list_insert (&sock->sdeps, &ep->item,
nn_list_end (&sock->sdeps));
nn_ep_stop (ep);
}
sock->state = NN_SOCK_STATE_STOPPING_EPS;
goto finish2;
}
static int nn_inproc_connect (const char *addr, void *hint,
struct nn_epbase **epbase)
{
struct nn_list_item *it;
struct nn_cinproc *cinproc;
struct nn_binproc *binproc;
nn_mutex_lock (&self.sync);
/* Insert the entry into the endpoint repository. */
cinproc = nn_cinproc_create (hint);
nn_list_insert (&self.connected, &cinproc->item,
nn_list_end (&self.connected));
/* During this process a pipe may be created. */
for (it = nn_list_begin (&self.bound);
it != nn_list_end (&self.bound);
it = nn_list_next (&self.bound, it)) {
binproc = nn_cont (it, struct nn_binproc, item);
if (strncmp (addr, nn_binproc_getaddr (binproc),
NN_SOCKADDR_MAX) == 0) {
/* Check whether the two sockets are compatible. */
if (!nn_epbase_ispeer (&cinproc->epbase, binproc->protocol))
break;
++binproc->connects;
nn_cinproc_connect (cinproc, binproc);
break;
}
}
nn_assert (epbase);
*epbase = &cinproc->epbase;
nn_mutex_unlock (&self.sync);
return 0;
}
int nn_sock_rm_ep (struct nn_sock *self, int eid)
{
struct nn_list_item *it;
struct nn_ep *ep;
nn_ctx_enter (&self->ctx);
/* Find the specified enpoint. */
ep = NULL;
for (it = nn_list_begin (&self->eps);
it != nn_list_end (&self->eps);
it = nn_list_next (&self->eps, it)) {
ep = nn_cont (it, struct nn_ep, item);
if (ep->eid == eid)
break;
ep = NULL;
}
/* The endpoint doesn't exist. */
if (!ep) {
nn_ctx_leave (&self->ctx);
return -EINVAL;
}
/* Move the endpoint from the list of active endpoints to the list
of shutting down endpoints. */
nn_list_erase (&self->eps, &ep->item);
nn_list_insert (&self->sdeps, &ep->item, nn_list_end (&self->sdeps));
/* Ask the endpoint to stop. Actual terminatation may be delayed
by the transport. */
nn_ep_stop (ep);
nn_ctx_leave (&self->ctx);
return 0;
}
void nn_astream_init (struct nn_astream *self, struct nn_epbase *epbase,
int s, struct nn_usock *usock, struct nn_bstream *bstream)
{
int sndbuf;
int rcvbuf;
size_t sz;
/* Switch the state. */
self->sink = &nn_astream_state_connected;
self->bstream = bstream;
/* This stearm does not belong yet to the bstream. */
nn_list_item_init (&self->item);
/* Get the current values of NN_SNDBUF and NN_RCVBUF options. */
sz = sizeof (sndbuf);
nn_epbase_getopt (&self->bstream->epbase, NN_SOL_SOCKET, NN_SNDBUF,
&sndbuf, &sz);
nn_assert (sz == sizeof (sndbuf));
sz = sizeof (rcvbuf);
nn_epbase_getopt (&self->bstream->epbase, NN_SOL_SOCKET, NN_RCVBUF,
&rcvbuf, &sz);
nn_assert (sz == sizeof (rcvbuf));
/* Start the stream state machine. */
nn_usock_init_child (&self->usock, usock, s, &self->sink, sndbuf, rcvbuf,
usock->cp);
/* Note: must add myself to the astreams list *before* initializing my
stream, which may fail and terminate me. */
nn_list_insert (&bstream->astreams, &self->item,
nn_list_end (&bstream->astreams));
/* Note: may fail and terminate me - do not reference self after
this point! */
nn_stream_init (&self->stream, epbase, &self->usock);
}
static void nn_global_add_socktype (struct nn_socktype *socktype)
{
nn_list_insert (&self.socktypes, &socktype->item,
nn_list_end (&self.socktypes));
}
static void nn_bipc_handler (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_bipc *bipc;
struct nn_aipc *aipc;
bipc = nn_cont (self, struct nn_bipc, fsm);
nn_assert(bipc);
switch (bipc->state) {
/******************************************************************************/
/* IDLE state. */
/******************************************************************************/
case NN_BIPC_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_bipc_start_listening (bipc);
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
default:
nn_fsm_bad_source (bipc->state, src, type);
}
/******************************************************************************/
/* ACTIVE state. */
/* The execution is yielded to the aipc state machine in this state. */
/******************************************************************************/
case NN_BIPC_STATE_ACTIVE:
if (srcptr == bipc->aipc) {
switch (type) {
case NN_AIPC_ACCEPTED:
/* Move the newly created connection to the list of existing
connections. */
nn_list_insert (&bipc->aipcs, &bipc->aipc->item,
nn_list_end (&bipc->aipcs));
bipc->aipc = NULL;
/* Start waiting for a new incoming connection. */
nn_bipc_start_accepting (bipc);
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
}
/* For all remaining events we'll assume they are coming from one
of remaining child aipc objects. */
nn_assert (src == NN_BIPC_SRC_AIPC);
aipc = (struct nn_aipc*) srcptr;
switch (type) {
case NN_AIPC_ERROR:
nn_aipc_stop (aipc);
return;
case NN_AIPC_STOPPED:
nn_list_erase (&bipc->aipcs, &aipc->item);
nn_aipc_term (aipc);
nn_free (aipc);
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
/******************************************************************************/
/* CLOSING_USOCK state. */
/* usock object was asked to stop but it haven't stopped yet. */
/******************************************************************************/
case NN_BIPC_STATE_CLOSING:
switch (src) {
case NN_BIPC_SRC_USOCK:
switch (type) {
case NN_USOCK_SHUTDOWN:
return;
case NN_USOCK_STOPPED:
nn_backoff_start (&bipc->retry);
bipc->state = NN_BIPC_STATE_WAITING;
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
default:
nn_fsm_bad_source (bipc->state, src, type);
}
/******************************************************************************/
/* WAITING state. */
/* Waiting before re-bind is attempted. This way we won't overload */
/* the system by continuous re-bind attemps. */
/******************************************************************************/
case NN_BIPC_STATE_WAITING:
switch (src) {
case NN_BIPC_SRC_RECONNECT_TIMER:
switch (type) {
case NN_BACKOFF_TIMEOUT:
nn_backoff_stop (&bipc->retry);
bipc->state = NN_BIPC_STATE_STOPPING_BACKOFF;
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
default:
nn_fsm_bad_source (bipc->state, src, type);
}
/******************************************************************************/
/* STOPPING_BACKOFF state. */
/* backoff object was asked to stop, but it haven't stopped yet. */
/******************************************************************************/
case NN_BIPC_STATE_STOPPING_BACKOFF:
switch (src) {
case NN_BIPC_SRC_RECONNECT_TIMER:
switch (type) {
case NN_BACKOFF_STOPPED:
nn_bipc_start_listening (bipc);
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
default:
nn_fsm_bad_source (bipc->state, src, type);
}
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (bipc->state, src, type);
}
}
static void nn_bws_handler (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_bws *bws;
struct nn_aws *aws;
bws = nn_cont (self, struct nn_bws, fsm);
switch (bws->state) {
/******************************************************************************/
/* IDLE state. */
/******************************************************************************/
case NN_BWS_STATE_IDLE:
nn_assert (src == NN_FSM_ACTION);
nn_assert (type == NN_FSM_START);
bws->state = NN_BWS_STATE_ACTIVE;
return;
/******************************************************************************/
/* ACTIVE state. */
/* The execution is yielded to the aws state machine in this state. */
/******************************************************************************/
case NN_BWS_STATE_ACTIVE:
if (src == NN_BWS_SRC_USOCK) {
nn_assert (type == NN_USOCK_SHUTDOWN || type == NN_USOCK_STOPPED);
return;
}
/* For all remaining events we'll assume they are coming from one
of remaining child aws objects. */
nn_assert (src == NN_BWS_SRC_AWS);
aws = (struct nn_aws*) srcptr;
switch (type) {
case NN_AWS_ACCEPTED:
/* Move the newly created connection to the list of existing
connections. */
nn_list_insert (&bws->awss, &bws->aws->item,
nn_list_end (&bws->awss));
bws->aws = NULL;
/* Start waiting for a new incoming connection. */
nn_bws_start_accepting (bws);
return;
case NN_AWS_ERROR:
nn_aws_stop (aws);
return;
case NN_AWS_STOPPED:
nn_list_erase (&bws->awss, &aws->item);
nn_aws_term (aws);
nn_free (aws);
return;
default:
nn_fsm_bad_action (bws->state, src, type);
}
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (bws->state, src, type);
}
}
/* Main body of the daemon. */
static void nn_tcpmuxd_routine (void *arg)
{
int rc;
struct nn_tcpmuxd_ctx *ctx;
int conn;
int pos;
char service [256];
struct nn_tcpmuxd_conn *tc = 0;
size_t sz;
ssize_t ssz;
int i;
struct nn_list_item *it;
unsigned char buf [2];
struct timeval tv;
ctx = (struct nn_tcpmuxd_ctx*) arg;
while (1) {
/* Wait for events. */
rc = (int32_t)poll (ctx->pfd, (int32_t)ctx->pfd_size, -1);
errno_assert (rc >= 0);
nn_assert (rc != 0);
/* There's an incoming TCP connection. */
if (ctx->pfd [0].revents & POLLIN) {
/* Accept the connection. */
conn = accept (ctx->tcp_listener, NULL, NULL);
if (conn < 0 && errno == ECONNABORTED)
continue;
errno_assert (conn >= 0);
/* Set timeouts to prevent malevolent client blocking the service.
Note that these options are not supported on Solaris. */
tv.tv_sec = 0;
tv.tv_usec = 100000;
rc = setsockopt (conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof (tv));
errno_assert (rc == 0 || (rc < 0 && errno == ENOPROTOOPT));
rc = setsockopt (conn, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof (tv));
errno_assert (rc == 0 || (rc < 0 && errno == ENOPROTOOPT));
/* Read TCPMUX header. */
pos = 0;
while (1) {
nn_assert (pos < sizeof (service));
ssz = recv (conn, &service [pos], 1, 0);
if (ssz < 0 && errno == EAGAIN) {
close (conn);
continue;
}
errno_assert (ssz >= 0);
nn_assert (ssz == 1);
service [pos] = tolower ((uint32_t)service [pos]);
if (pos > 0 && service [pos - 1] == 0x0d &&
service [pos] == 0x0a)
break;
++pos;
}
service [pos - 1] = 0;
/* Check whether specified service is listening. */
for (it = nn_list_begin (&ctx->conns);
it != nn_list_end (&ctx->conns);
it = nn_list_next (&ctx->conns, it)) {
tc = nn_cont (it, struct nn_tcpmuxd_conn, item);
if (strcmp (service, tc->service) == 0)
break;
}
/* If no one is listening, tear down the connection. */
if (it == nn_list_end (&ctx->conns)) {
ssz = send (conn, "-\x0d\x0a", 3, 0);
if (ssz < 0 && errno == EAGAIN) {
close (conn);
continue;
}
errno_assert (ssz >= 0);
nn_assert (ssz == 3);
close (conn);
continue;
}
/* Send TCPMUX reply. */
ssz = send (conn, "+\x0d\x0a", 3, 0);
if (ssz < 0 && errno == EAGAIN) {
close (conn);
continue;
}
errno_assert (ssz >= 0);
nn_assert (ssz == 3);
nn_assert (tc != 0);
/* Pass the file descriptor to the listening process. */
rc = nn_tcpmuxd_send_fd (tc->fd, conn);
errno_assert (rc == 0);
}
/* There's an incoming IPC connection. */
if (ctx->pfd [1].revents & POLLIN) {
/* Accept the connection. */
conn = accept (ctx->ipc_listener, NULL, NULL);
if (conn < 0 && errno == ECONNABORTED)
continue;
errno_assert (conn >= 0);
/* Create new connection entry. */
tc = nn_alloc (sizeof (struct nn_tcpmuxd_conn), "tcpmuxd_conn");
nn_assert (tc);
tc->fd = conn;
nn_list_item_init (&tc->item);
/* Adjust the pollset. We will poll for errors only. */
ctx->pfd_size++;
if (ctx->pfd_size > ctx->pfd_capacity) {
ctx->pfd_capacity *= 2;
ctx->pfd = nn_realloc (ctx->pfd,
sizeof (struct pollfd) * ctx->pfd_capacity);
alloc_assert (ctx->pfd);
}
ctx->pfd [ctx->pfd_size - 1].fd = conn;
ctx->pfd [ctx->pfd_size - 1].events = 0;
ctx->pfd [ctx->pfd_size - 1].revents = 0;
/* Read the connection header. */
ssz = recv (conn, buf, 2, 0);
errno_assert (ssz >= 0);
nn_assert (ssz == 2);
sz = nn_gets (buf);
tc->service = nn_alloc (sz + 1, "tcpmuxd_conn.service");
nn_assert (tc->service);
ssz = recv (conn, tc->service, sz, 0);
errno_assert (ssz >= 0);
nn_assert (ssz == sz);
for (i = 0; i != sz; ++i)
tc->service [i] = tolower ((uint32_t)tc->service [i]);
tc->service [sz] = 0;
/* Add the entry to the IPC connections list. */
nn_list_insert (&ctx->conns, &tc->item, nn_list_end (&ctx->conns));
}
for (i = 2; i < ctx->pfd_size; ++i) {
if (ctx->pfd [i].revents & POLLERR ||
ctx->pfd [i].revents & POLLHUP) {
nn_tcpmuxd_disconnect (ctx, i);
i--;
}
}
}
int ftw_subscriber_construct(struct ftw_socket_callsite **callsite, LVUserEventRef *lv_event,
const char *addr, int linger, int max_recv_size, struct ftw_socket **sock)
{
struct ftw_socket *inst;
int rcc;
int rcs;
int rco;
/* Preconditions expected of LabVIEW. */
ftw_assert(*callsite && addr);
nn_mutex_lock(&(*callsite)->sync);
rcs = nn_socket(AF_SP, NN_SUB);
/* Socket creation failure? */
if (rcs < 0) {
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rcs;
}
rco = nn_setsockopt(rcs, NN_SOL_SOCKET, NN_LINGER, &linger, sizeof(linger));
if (rco < 0) {
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rco;
}
rco = nn_setsockopt(rcs, NN_SOL_SOCKET, NN_RCVMAXSIZE, &max_recv_size, sizeof(max_recv_size));
if (rco < 0) {
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rco;
}
rcc = nn_connect(rcs, addr);
/* Endpoint creation failure? */
if (rcc < 0) {
nn_close(rcs);
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rcc;
}
rco = nn_setsockopt (rcs, NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
if (rco < 0) {
nn_close(rcs);
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rco;
}
inst = ftw_malloc(sizeof(struct ftw_socket));
ftw_assert(inst);
inst->incoming_msg_notifier_event = *lv_event;
inst->id = rcs;
inst->callsite = *callsite;
nn_list_item_init(&inst->item);
nn_list_insert(&(*callsite)->active_sockets, &inst->item,
nn_list_end(&(*callsite)->active_sockets));
nn_sem_init(&inst->msg_acknowledged);
/* Launch thread and wait for it to initialize. */
nn_sem_init(&inst->async_recv_ready);
nn_thread_init(&inst->async_recv_thread, ftw_subscriber_async_recv_thread, inst);
nn_sem_wait(&inst->async_recv_ready);
*sock = inst;
(*callsite)->lifetime_sockets++;
nn_mutex_unlock(&(*callsite)->sync);
return 0;
}
static void nn_bipc_handler (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_bipc *bipc;
struct nn_list_item *it;
struct nn_aipc *aipc;
bipc = nn_cont (self, struct nn_bipc, fsm);
/******************************************************************************/
/* STOP procedure. */
/******************************************************************************/
if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
nn_aipc_stop (bipc->aipc);
bipc->state = NN_BIPC_STATE_STOPPING_AIPC;
}
if (nn_slow (bipc->state == NN_BIPC_STATE_STOPPING_AIPC)) {
if (!nn_aipc_isidle (bipc->aipc))
return;
nn_aipc_term (bipc->aipc);
nn_free (bipc->aipc);
bipc->aipc = NULL;
nn_usock_stop (&bipc->usock);
bipc->state = NN_BIPC_STATE_STOPPING_USOCK;
}
if (nn_slow (bipc->state == NN_BIPC_STATE_STOPPING_USOCK)) {
if (!nn_usock_isidle (&bipc->usock))
return;
for (it = nn_list_begin (&bipc->aipcs);
it != nn_list_end (&bipc->aipcs);
it = nn_list_next (&bipc->aipcs, it)) {
aipc = nn_cont (it, struct nn_aipc, item);
nn_aipc_stop (aipc);
}
bipc->state = NN_BIPC_STATE_STOPPING_AIPCS;
goto aipcs_stopping;
}
if (nn_slow (bipc->state == NN_BIPC_STATE_STOPPING_AIPCS)) {
nn_assert (src == NN_BIPC_SRC_AIPC && type == NN_AIPC_STOPPED);
aipc = (struct nn_aipc *) srcptr;
nn_list_erase (&bipc->aipcs, &aipc->item);
nn_aipc_term (aipc);
nn_free (aipc);
/* If there are no more aipc state machines, we can stop the whole
bipc object. */
aipcs_stopping:
if (nn_list_empty (&bipc->aipcs)) {
bipc->state = NN_BIPC_STATE_IDLE;
nn_fsm_stopped_noevent (&bipc->fsm);
nn_epbase_stopped (&bipc->epbase);
return;
}
return;
}
switch (bipc->state) {
/******************************************************************************/
/* IDLE state. */
/******************************************************************************/
case NN_BIPC_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_bipc_start_listening (bipc);
nn_bipc_start_accepting (bipc);
bipc->state = NN_BIPC_STATE_ACTIVE;
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
default:
nn_fsm_bad_source (bipc->state, src, type);
}
/******************************************************************************/
/* ACTIVE state. */
/* The execution is yielded to the aipc state machine in this state. */
/******************************************************************************/
case NN_BIPC_STATE_ACTIVE:
if (srcptr == bipc->aipc) {
switch (type) {
case NN_AIPC_ACCEPTED:
/* Move the newly created connection to the list of existing
connections. */
nn_list_insert (&bipc->aipcs, &bipc->aipc->item,
nn_list_end (&bipc->aipcs));
bipc->aipc = NULL;
/* Start waiting for a new incoming connection. */
nn_bipc_start_accepting (bipc);
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
}
/* For all remaining events we'll assume they are coming from one
of remaining child aipc objects. */
nn_assert (src == NN_BIPC_SRC_AIPC);
aipc = (struct nn_aipc*) srcptr;
switch (type) {
case NN_AIPC_ERROR:
nn_aipc_stop (aipc);
return;
case NN_AIPC_STOPPED:
nn_list_erase (&bipc->aipcs, &aipc->item);
nn_aipc_term (aipc);
nn_free (aipc);
return;
default:
nn_fsm_bad_action (bipc->state, src, type);
}
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (bipc->state, src, type);
}
}
void nn_dist_out (struct nn_dist *self, struct nn_pipe *pipe,
struct nn_dist_data *data)
{
++self->count;
nn_list_insert (&self->pipes, &data->item, nn_list_end (&self->pipes));
}
/* Main body of the daemon. */
static void nn_tcpmuxd_routine (void *arg)
{
int rc;
struct nn_tcpmuxd_ctx *ctx;
struct pollfd pfd [2];
int conn;
int pos;
char service [256];
struct nn_tcpmuxd_conn *tc;
size_t sz;
ssize_t ssz;
int i;
struct nn_list_item *it;
unsigned char buf [2];
struct timeval tv;
ctx = (struct nn_tcpmuxd_ctx*) arg;
pfd [0].fd = ctx->tcp_listener;
pfd [0].events = POLLIN;
pfd [1].fd = ctx->ipc_listener;
pfd [1].events = POLLIN;
while (1) {
/* Wait for events. */
rc = poll (pfd, 2, -1);
errno_assert (rc >= 0);
nn_assert (rc != 0);
/* There's an incoming TCP connection. */
if (pfd [0].revents & POLLIN) {
/* Accept the connection. */
conn = accept (ctx->tcp_listener, NULL, NULL);
if (conn < 0 && errno == ECONNABORTED)
continue;
errno_assert (conn >= 0);
tv.tv_sec = 0;
tv.tv_usec = 100000;
rc = setsockopt (conn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof (tv));
errno_assert (rc == 0);
rc = setsockopt (conn, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof (tv));
errno_assert (rc == 0);
/* Read TCPMUX header. */
pos = 0;
while (1) {
nn_assert (pos < sizeof (service));
ssz = recv (conn, &service [pos], 1, 0);
if (ssz < 0 && errno == EAGAIN) {
close (conn);
continue;
}
errno_assert (ssz >= 0);
nn_assert (ssz == 1);
service [pos] = tolower (service [pos]);
if (pos > 0 && service [pos - 1] == 0x0d &&
service [pos] == 0x0a)
break;
++pos;
}
service [pos - 1] = 0;
/* Check whether specified service is listening. */
for (it = nn_list_begin (&ctx->conns);
it != nn_list_end (&ctx->conns);
it = nn_list_next (&ctx->conns, it)) {
tc = nn_cont (it, struct nn_tcpmuxd_conn, item);
if (strcmp (service, tc->service) == 0)
break;
}
/* If no one is listening, tear down the connection. */
if (it == nn_list_end (&ctx->conns)) {
ssz = send (conn, "-\x0d\x0a", 3, 0);
if (ssz < 0 && errno == EAGAIN) {
close (conn);
continue;
}
errno_assert (ssz >= 0);
nn_assert (ssz == 3);
close (conn);
continue;
}
/* Send TCPMUX reply. */
ssz = send (conn, "+\x0d\x0a", 3, 0);
if (ssz < 0 && errno == EAGAIN) {
close (conn);
continue;
}
errno_assert (ssz >= 0);
nn_assert (ssz == 3);
/* Pass the file descriptor to the listening process. */
rc = send_fd (tc->fd, conn);
errno_assert (rc == 0);
}
/* There's an incoming IPC connection. */
if (pfd [1].revents & POLLIN) {
/* Accept the connection. */
conn = accept (ctx->ipc_listener, NULL, NULL);
if (conn < 0 && errno == ECONNABORTED)
continue;
errno_assert (conn >= 0);
/* Create new connection entry. */
tc = nn_alloc (sizeof (struct nn_tcpmuxd_conn), "tcpmuxd_conn");
nn_assert (tc);
tc->fd = conn;
nn_list_item_init (&tc->item);
/* Read the connection header. */
ssz = recv (conn, buf, 2, 0);
errno_assert (ssz >= 0);
nn_assert (ssz == 2);
sz = nn_gets (buf);
tc->service = nn_alloc (sz + 1, "tcpmuxd_conn.service");
nn_assert (tc->service);
ssz = recv (conn, tc->service, sz, 0);
errno_assert (ssz >= 0);
nn_assert (ssz == sz);
for (i = 0; i != sz; ++i)
tc->service [sz] = tolower (tc->service [sz]);
tc->service [sz] = 0;
/* Add the entry to the IPC connections list. */
nn_list_insert (&ctx->conns, &tc->item, nn_list_end (&ctx->conns));
}
}
static void nn_btcp_handler (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_btcp *btcp;
struct nn_atcp *atcp;
btcp = nn_cont (self, struct nn_btcp, fsm);
switch (btcp->state) {
/******************************************************************************/
/* IDLE state. */
/******************************************************************************/
case NN_BTCP_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_btcp_start_listening (btcp);
nn_btcp_start_accepting (btcp);
btcp->state = NN_BTCP_STATE_ACTIVE;
return;
default:
nn_fsm_bad_action (btcp->state, src, type);
}
default:
nn_fsm_bad_source (btcp->state, src, type);
}
/******************************************************************************/
/* ACTIVE state. */
/* The execution is yielded to the atcp state machine in this state. */
/******************************************************************************/
case NN_BTCP_STATE_ACTIVE:
if (srcptr == btcp->atcp) {
switch (type) {
case NN_ATCP_ACCEPTED:
/* Move the newly created connection to the list of existing
connections. */
nn_list_insert (&btcp->atcps, &btcp->atcp->item,
nn_list_end (&btcp->atcps));
btcp->atcp = NULL;
/* Start waiting for a new incoming connection. */
nn_btcp_start_accepting (btcp);
return;
default:
nn_fsm_bad_action (btcp->state, src, type);
}
}
/* For all remaining events we'll assume they are coming from one
of remaining child atcp objects. */
nn_assert (src == NN_BTCP_SRC_ATCP);
atcp = (struct nn_atcp*) srcptr;
switch (type) {
case NN_ATCP_ERROR:
nn_atcp_stop (atcp);
return;
case NN_ATCP_STOPPED:
nn_list_erase (&btcp->atcps, &atcp->item);
nn_atcp_term (atcp);
nn_free (atcp);
return;
default:
nn_fsm_bad_action (btcp->state, src, type);
}
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (btcp->state, src, type);
}
}
static void nn_ctx_add_socktype (struct nn_socktype *socktype)
{
nn_list_insert (&self.socktypes, &socktype->list,
nn_list_end (&self.socktypes));
}
