int nn_ep_init (struct nn_ep *self, int src, struct nn_sock *sock, int eid,
struct nn_transport *transport, int bind, const char *addr)
{
int rc;
nn_fsm_init (&self->fsm, nn_ep_handler, nn_ep_shutdown,
src, self, &sock->fsm);
self->state = NN_EP_STATE_IDLE;
self->epbase = NULL;
self->sock = sock;
self->eid = eid;
self->last_errno = 0;
nn_list_item_init (&self->item);
memcpy (&self->options, &sock->ep_template, sizeof(struct nn_ep_options));
/* Store the textual form of the address. */
nn_assert (strlen (addr) <= NN_SOCKADDR_MAX);
strcpy (self->addr, addr);
/* Create transport-specific part of the endpoint. */
if (bind)
rc = transport->bind ((void*) self, &self->epbase);
else
rc = transport->connect ((void*) self, &self->epbase);
/* Endpoint creation failed. */
if (rc < 0) {
nn_list_item_term (&self->item);
nn_fsm_term (&self->fsm);
return rc;
}
return 0;
}
void nn_timer_init (struct nn_timer *self, int src, struct nn_fsm *owner)
{
nn_fsm_init (&self->fsm, nn_timer_handler, src, self, owner);
self->state = NN_TIMER_STATE_IDLE;
nn_worker_task_init (&self->start_task, &self->fsm);
nn_worker_task_init (&self->stop_task, &self->fsm);
nn_worker_timer_init (&self->wtimer, &self->fsm);
nn_fsm_event_init (&self->done);
self->worker = nn_fsm_choose_worker (&self->fsm);
self->timeout = -1;
}
void nn_pipebase_init(struct nn_pipebase *self,const struct nn_pipebase_vfptr *vfptr,struct nn_epbase *epbase)
{
nn_assert(epbase->ep->sock);
nn_fsm_init(&self->fsm,NULL,NULL,0,self,&epbase->ep->sock->fsm);
self->vfptr = vfptr;
self->state = NN_PIPEBASE_STATE_IDLE;
self->instate = NN_PIPEBASE_INSTATE_DEACTIVATED;
self->outstate = NN_PIPEBASE_OUTSTATE_DEACTIVATED;
self->sock = epbase->ep->sock;
memcpy(&self->options,&epbase->ep->options,sizeof(struct nn_ep_options));
nn_fsm_event_init(&self->in);
nn_fsm_event_init(&self->out);
}
void nn_streamhdr_init (struct nn_streamhdr *self, int src,
struct nn_fsm *owner)
{
nn_fsm_init (&self->fsm, nn_streamhdr_handler, src, self, owner);
self->state = NN_STREAMHDR_STATE_IDLE;
nn_timer_init (&self->timer, NN_STREAMHDR_SRC_TIMER, &self->fsm);
nn_fsm_event_init (&self->done);
self->usock = NULL;
self->usock_owner.src = -1;
self->usock_owner.fsm = NULL;
self->pipebase = NULL;
}
void nn_aipc_init (struct nn_aipc *self, int src,
struct nn_epbase *epbase, struct nn_fsm *owner)
{
nn_fsm_init (&self->fsm, nn_aipc_handler, src, self, owner);
self->state = NN_AIPC_STATE_IDLE;
nn_usock_init (&self->usock, NN_AIPC_SRC_USOCK, &self->fsm);
self->listener = NULL;
self->listener_owner.src = -1;
self->listener_owner.fsm = NULL;
nn_sipc_init (&self->sipc, NN_AIPC_SRC_SIPC, epbase, &self->fsm);
nn_fsm_event_init (&self->accepted);
nn_fsm_event_init (&self->done);
nn_list_item_init (&self->item);
}
void nn_stcp_init(struct nn_stcp *self,int32_t src,struct nn_epbase *epbase,struct nn_fsm *owner)
{
nn_fsm_init(&self->fsm,nn_stcp_handler,nn_stcp_shutdown,src,self,owner);
self->state = NN_STCP_STATE_IDLE;
nn_streamhdr_init(&self->streamhdr,NN_STCP_SRC_STREAMHDR,&self->fsm);
self->usock = NULL;
self->usock_owner.src = -1;
self->usock_owner.fsm = NULL;
nn_pipebase_init(&self->pipebase,&nn_stcp_pipebase_vfptr,epbase);
self->instate = -1;
nn_msg_init(&self->inmsg,0);
self->outstate = -1;
nn_msg_init(&self->outmsg,0);
nn_fsm_event_init(&self->done);
}
void nn_atcp_init (struct nn_atcp *self, int src,
struct nn_epbase *epbase, struct nn_fsm *owner)
{
nn_fsm_init (&self->fsm, nn_atcp_handler, nn_atcp_shutdown,
src, self, owner);
self->state = NN_ATCP_STATE_IDLE;
self->epbase = epbase;
nn_usock_init (&self->usock, NN_ATCP_SRC_USOCK, &self->fsm);
self->listener = NULL;
self->listener_owner.src = -1;
self->listener_owner.fsm = NULL;
nn_stcp_init (&self->stcp, NN_ATCP_SRC_STCP, epbase, &self->fsm);
nn_fsm_event_init (&self->accepted);
nn_fsm_event_init (&self->done);
nn_list_item_init (&self->item);
}
void nn_usock_init (struct nn_usock *self, int src, struct nn_fsm *owner)
{
/* Initalise the state machine. */
nn_fsm_init (&self->fsm, nn_usock_handler, nn_usock_shutdown,
src, self, owner);
self->state = NN_USOCK_STATE_IDLE;
/* Choose a worker thread to handle this socket. */
self->worker = nn_fsm_choose_worker (&self->fsm);
/* Actual file descriptor will be generated during 'start' step. */
self->s = -1;
self->errnum = 0;
self->in.buf = NULL;
self->in.len = 0;
self->in.batch = NULL;
self->in.batch_len = 0;
self->in.batch_pos = 0;
self->in.pfd = NULL;
memset (&self->out.hdr, 0, sizeof (struct msghdr));
/* Initialise tasks for the worker thread. */
nn_worker_fd_init (&self->wfd, NN_USOCK_SRC_FD, &self->fsm);
nn_worker_task_init (&self->task_connecting, NN_USOCK_SRC_TASK_CONNECTING,
&self->fsm);
nn_worker_task_init (&self->task_connected, NN_USOCK_SRC_TASK_CONNECTED,
&self->fsm);
nn_worker_task_init (&self->task_accept, NN_USOCK_SRC_TASK_ACCEPT,
&self->fsm);
nn_worker_task_init (&self->task_send, NN_USOCK_SRC_TASK_SEND, &self->fsm);
nn_worker_task_init (&self->task_recv, NN_USOCK_SRC_TASK_RECV, &self->fsm);
nn_worker_task_init (&self->task_stop, NN_USOCK_SRC_TASK_STOP, &self->fsm);
/* Intialise events raised by usock. */
nn_fsm_event_init (&self->event_established);
nn_fsm_event_init (&self->event_sent);
nn_fsm_event_init (&self->event_received);
nn_fsm_event_init (&self->event_error);
/* accepting is not going on at the moment. */
self->asock = NULL;
}
void nn_sws_init (struct nn_sws *self, int src,
struct nn_epbase *epbase, struct nn_fsm *owner)
{
nn_fsm_init (&self->fsm, nn_sws_handler, nn_sws_shutdown,
src, self, owner);
self->state = NN_SWS_STATE_IDLE;
nn_wshdr_init (&self->wshdr, NN_SWS_SRC_HANDSHAKE, &self->fsm);
self->usock = NULL;
self->usock_owner.src = -1;
self->usock_owner.fsm = NULL;
nn_pipebase_init (&self->pipebase, &nn_sws_pipebase_vfptr, epbase);
self->instate = -1;
nn_list_init (&self->inmsg_array);
self->outstate = -1;
nn_msg_init (&self->outmsg, 0);
self->continuing = 0;
nn_fsm_event_init (&self->done);
}
