static void nn_aipc_shutdown (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_aipc *aipc;
aipc = nn_cont (self, struct nn_aipc, fsm);
if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
nn_sipc_stop (&aipc->sipc);
aipc->state = NN_AIPC_STATE_STOPPING_SIPC_FINAL;
}
if (nn_slow (aipc->state == NN_AIPC_STATE_STOPPING_SIPC_FINAL)) {
if (!nn_sipc_isidle (&aipc->sipc))
return;
nn_usock_stop (&aipc->usock);
aipc->state = NN_AIPC_STATE_STOPPING;
}
if (nn_slow (aipc->state == NN_AIPC_STATE_STOPPING)) {
if (!nn_usock_isidle (&aipc->usock))
return;
if (aipc->listener) {
nn_assert (aipc->listener_owner.fsm);
nn_usock_swap_owner (aipc->listener, &aipc->listener_owner);
aipc->listener = NULL;
aipc->listener_owner.src = 1;
aipc->listener_owner.fsm = NULL;
}
aipc->state = NN_AIPC_STATE_IDLE;
nn_fsm_stopped (&aipc->fsm, NN_AIPC_STOPPED);
return;
}
nn_fsm_bad_state(aipc->state, src, type);
}
static void nn_stcp_shutdown(struct nn_fsm *self,int32_t src,int32_t type,NN_UNUSED void *srcptr)
{
struct nn_stcp *stcp;
stcp = nn_cont (self, struct nn_stcp, fsm);
if ( nn_slow(src == NN_FSM_ACTION && type == NN_FSM_STOP) )
{
nn_pipebase_stop(&stcp->pipebase);
nn_streamhdr_stop(&stcp->streamhdr);
stcp->state = NN_STCP_STATE_STOPPING;
}
if ( nn_slow(stcp->state == NN_STCP_STATE_STOPPING) )
{
if ( nn_streamhdr_isidle(&stcp->streamhdr) )
{
nn_usock_swap_owner(stcp->usock,&stcp->usock_owner);
stcp->usock = NULL;
stcp->usock_owner.src = -1;
stcp->usock_owner.fsm = NULL;
stcp->state = NN_STCP_STATE_IDLE;
nn_fsm_stopped (&stcp->fsm,NN_STCP_STOPPED);
return;
}
return;
}
nn_fsm_bad_state(stcp->state,src,type);
}
static void nn_sws_shutdown (struct nn_fsm *self, int src, int type,
NN_UNUSED void *srcptr)
{
struct nn_sws *sws;
sws = nn_cont (self, struct nn_sws, fsm);
if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
/* TODO: Consider sending a close code here? */
nn_pipebase_stop (&sws->pipebase);
nn_wshdr_stop (&sws->wshdr);
sws->state = NN_SWS_STATE_STOPPING;
}
if (nn_slow (sws->state == NN_SWS_STATE_STOPPING)) {
if (nn_wshdr_isidle (&sws->wshdr)) {
nn_usock_swap_owner (sws->usock, &sws->usock_owner);
sws->usock = NULL;
sws->usock_owner.src = -1;
sws->usock_owner.fsm = NULL;
sws->state = NN_SWS_STATE_IDLE;
nn_fsm_stopped (&sws->fsm, NN_SWS_RETURN_STOPPED);
return;
}
return;
}
nn_fsm_bad_state (sws->state, src, type);
}
void nn_streamhdr_start (struct nn_streamhdr *self, struct nn_usock *usock,
struct nn_pipebase *pipebase)
{
size_t sz;
int protocol;
/* Take ownership of the underlying socket. */
nn_assert (self->usock == NULL && self->usock_owner.fsm == NULL);
self->usock_owner.src = NN_STREAMHDR_SRC_USOCK;
self->usock_owner.fsm = &self->fsm;
nn_usock_swap_owner (usock, &self->usock_owner);
self->usock = usock;
self->pipebase = pipebase;
/* Get the protocol identifier. */
sz = sizeof (protocol);
nn_pipebase_getopt (pipebase, NN_SOL_SOCKET, NN_PROTOCOL, &protocol, &sz);
nn_assert (sz == sizeof (protocol));
/* Compose the protocol header. */
memcpy (self->protohdr, "\0SP\0\0\0\0\0", 8);
nn_puts (self->protohdr + 4, (uint16_t) protocol);
/* Launch the state machine. */
nn_fsm_start (&self->fsm);
}
void nn_stcp_start(struct nn_stcp *self, struct nn_usock *usock)
{
// Take ownership of the underlying socket
nn_assert(self->usock == NULL && self->usock_owner.fsm == NULL);
self->usock_owner.src = NN_STCP_SRC_USOCK;
self->usock_owner.fsm = &self->fsm;
nn_usock_swap_owner(usock,&self->usock_owner);
self->usock = usock;
nn_fsm_start(&self->fsm); // Launch the state machine
}
void nn_slibfabric_start (struct nn_slibfabric *self, struct nn_usock *usock)
{
/* Take ownership of the underlying socket. */
nn_assert (self->usock == NULL && self->usock_owner.fsm == NULL);
self->usock_owner.src = NN_SLIBFABRIC_SRC_USOCK;
self->usock_owner.fsm = &self->fsm;
nn_usock_swap_owner (usock, &self->usock_owner);
self->usock = usock;
/* Launch the state machine. */
nn_fsm_start (&self->fsm);
}
void nn_atcp_start (struct nn_atcp *self, struct nn_usock *listener)
{
nn_assert_state (self, NN_ATCP_STATE_IDLE);
/* Take ownership of the listener socket. */
self->listener = listener;
self->listener_owner.src = NN_ATCP_SRC_LISTENER;
self->listener_owner.fsm = &self->fsm;
nn_usock_swap_owner (listener, &self->listener_owner);
/* Start the state machine. */
nn_fsm_start (&self->fsm);
}
void nn_aipc_start (struct nn_aipc *self, struct nn_usock *listener)
{
nn_assert (self->state == NN_AIPC_STATE_IDLE);
/* Take ownership of the listener socket. */
self->listener = listener;
self->listener_owner.src = NN_AIPC_SRC_USOCK;
self->listener_owner.fsm = &self->fsm;
nn_usock_swap_owner (listener, &self->listener_owner);
/* Start the state machine. */
nn_fsm_start (&self->fsm);
}
void nn_sws_start (struct nn_sws *self, struct nn_usock *usock, int mode,
const char *host)
{
/* Take ownership of the underlying socket. */
nn_assert (self->usock == NULL && self->usock_owner.fsm == NULL);
self->usock_owner.src = NN_SWS_SRC_USOCK;
self->usock_owner.fsm = &self->fsm;
nn_usock_swap_owner (usock, &self->usock_owner);
self->usock = usock;
self->mode = mode;
self->remote_host = host;
/* Launch the state machine. */
nn_fsm_start (&self->fsm);
}
static void nn_aws_shutdown (struct nn_fsm *self, int src, int type,
NN_UNUSED void *srcptr)
{
struct nn_aws *aws;
aws = nn_cont (self, struct nn_aws, fsm);
nn_assert (aws);
if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
if (!nn_sws_isidle (&aws->sws)) {
nn_epbase_stat_increment (aws->epbase,
NN_STAT_DROPPED_CONNECTIONS, 1);
nn_sws_stop (&aws->sws);
}
aws->state = NN_AWS_STATE_STOPPING_SWS_FINAL;
}
if (nn_slow (aws->state == NN_AWS_STATE_STOPPING_SWS_FINAL)) {
if (!nn_sws_isidle (&aws->sws))
return;
nn_usock_stop (&aws->usock);
aws->state = NN_AWS_STATE_STOPPING;
}
if (nn_slow (aws->state == NN_AWS_STATE_STOPPING)) {
if (!nn_usock_isidle (&aws->usock))
return;
if (aws->listener) {
nn_assert (aws->listener_owner.fsm);
nn_usock_swap_owner (aws->listener, &aws->listener_owner);
aws->listener = NULL;
aws->listener_owner.src = -1;
aws->listener_owner.fsm = NULL;
}
aws->state = NN_AWS_STATE_IDLE;
nn_fsm_stopped (&aws->fsm, NN_AWS_STOPPED);
return;
}
nn_fsm_bad_action (aws->state, src, type);
}
static void nn_atcp_handler (struct nn_fsm *self, int src, int type,
NN_UNUSED void *srcptr)
{
struct nn_atcp *atcp;
int val;
size_t sz;
atcp = nn_cont (self, struct nn_atcp, fsm);
switch (atcp->state) {
/******************************************************************************/
/* IDLE state. */
/* The state machine wasn't yet started. */
/******************************************************************************/
case NN_ATCP_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_usock_accept (&atcp->usock, atcp->listener);
atcp->state = NN_ATCP_STATE_ACCEPTING;
return;
default:
nn_fsm_bad_action (atcp->state, src, type);
}
default:
nn_fsm_bad_source (atcp->state, src, type);
}
/******************************************************************************/
/* ACCEPTING state. */
/* Waiting for incoming connection. */
/******************************************************************************/
case NN_ATCP_STATE_ACCEPTING:
switch (src) {
case NN_ATCP_SRC_USOCK:
switch (type) {
case NN_USOCK_ACCEPTED:
nn_epbase_clear_error (atcp->epbase);
/* Set the relevant socket options. */
sz = sizeof (val);
nn_epbase_getopt (atcp->epbase, NN_SOL_SOCKET, NN_SNDBUF,
&val, &sz);
nn_assert (sz == sizeof (val));
nn_usock_setsockopt (&atcp->usock, SOL_SOCKET, SO_SNDBUF,
&val, sizeof (val));
sz = sizeof (val);
nn_epbase_getopt (atcp->epbase, NN_SOL_SOCKET, NN_RCVBUF,
&val, &sz);
nn_assert (sz == sizeof (val));
nn_usock_setsockopt (&atcp->usock, SOL_SOCKET, SO_RCVBUF,
&val, sizeof (val));
/* Return ownership of the listening socket to the parent. */
nn_usock_swap_owner (atcp->listener, &atcp->listener_owner);
atcp->listener = NULL;
atcp->listener_owner.src = -1;
atcp->listener_owner.fsm = NULL;
nn_fsm_raise (&atcp->fsm, &atcp->accepted, NN_ATCP_ACCEPTED);
/* Start the stcp state machine. */
nn_usock_activate (&atcp->usock);
nn_stcp_start (&atcp->stcp, &atcp->usock);
atcp->state = NN_ATCP_STATE_ACTIVE;
nn_epbase_stat_increment (atcp->epbase,
NN_STAT_ACCEPTED_CONNECTIONS, 1);
return;
default:
nn_fsm_bad_action (atcp->state, src, type);
}
case NN_ATCP_SRC_LISTENER:
switch (type) {
case NN_USOCK_ACCEPT_ERROR:
nn_epbase_set_error (atcp->epbase,
nn_usock_geterrno(atcp->listener));
nn_epbase_stat_increment (atcp->epbase,
NN_STAT_ACCEPT_ERRORS, 1);
nn_usock_accept (&atcp->usock, atcp->listener);
return;
default:
nn_fsm_bad_action (atcp->state, src, type);
}
default:
nn_fsm_bad_source (atcp->state, src, type);
}
/******************************************************************************/
/* ACTIVE state. */
/******************************************************************************/
case NN_ATCP_STATE_ACTIVE:
switch (src) {
case NN_ATCP_SRC_STCP:
switch (type) {
case NN_STCP_ERROR:
nn_stcp_stop (&atcp->stcp);
atcp->state = NN_ATCP_STATE_STOPPING_STCP;
nn_epbase_stat_increment (atcp->epbase,
NN_STAT_BROKEN_CONNECTIONS, 1);
return;
default:
nn_fsm_bad_action (atcp->state, src, type);
}
default:
nn_fsm_bad_source (atcp->state, src, type);
}
/******************************************************************************/
/* STOPPING_STCP state. */
/******************************************************************************/
case NN_ATCP_STATE_STOPPING_STCP:
switch (src) {
case NN_ATCP_SRC_STCP:
switch (type) {
case NN_USOCK_SHUTDOWN:
return;
case NN_STCP_STOPPED:
nn_usock_stop (&atcp->usock);
atcp->state = NN_ATCP_STATE_STOPPING_USOCK;
return;
default:
nn_fsm_bad_action (atcp->state, src, type);
}
default:
nn_fsm_bad_source (atcp->state, src, type);
}
/******************************************************************************/
/* STOPPING_USOCK state. */
/******************************************************************************/
case NN_ATCP_STATE_STOPPING_USOCK:
switch (src) {
case NN_ATCP_SRC_USOCK:
switch (type) {
case NN_USOCK_SHUTDOWN:
return;
case NN_USOCK_STOPPED:
nn_fsm_raise (&atcp->fsm, &atcp->done, NN_ATCP_ERROR);
atcp->state = NN_ATCP_STATE_DONE;
return;
default:
nn_fsm_bad_action (atcp->state, src, type);
}
default:
nn_fsm_bad_source (atcp->state, src, type);
}
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (atcp->state, src, type);
}
}
static void nn_aipc_handler (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_aipc *aipc;
aipc = nn_cont (self, struct nn_aipc, fsm);
/******************************************************************************/
/* STOP procedure. */
/******************************************************************************/
if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
nn_sipc_stop (&aipc->sipc);
aipc->state = NN_AIPC_STATE_STOPPING_SIPC_FINAL;
}
if (nn_slow (aipc->state == NN_AIPC_STATE_STOPPING_SIPC_FINAL)) {
if (!nn_sipc_isidle (&aipc->sipc))
return;
nn_usock_stop (&aipc->usock);
aipc->state = NN_AIPC_STATE_STOPPING;
}
if (nn_slow (aipc->state == NN_AIPC_STATE_STOPPING)) {
if (!nn_usock_isidle (&aipc->usock))
return;
if (aipc->listener) {
nn_assert (aipc->listener_owner.fsm);
nn_usock_swap_owner (aipc->listener, &aipc->listener_owner);
aipc->listener = NULL;
aipc->listener_owner.src = 1;
aipc->listener_owner.fsm = NULL;
}
aipc->state = NN_AIPC_STATE_IDLE;
nn_fsm_stopped (&aipc->fsm, NN_AIPC_STOPPED);
return;
}
switch (aipc->state) {
/******************************************************************************/
/* IDLE state. */
/* The state machine wasn't yet started. */
/******************************************************************************/
case NN_AIPC_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_usock_accept (&aipc->usock, aipc->listener);
aipc->state = NN_AIPC_STATE_ACCEPTING;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* ACCEPTING state. */
/* Waiting for incoming connection. */
/******************************************************************************/
case NN_AIPC_STATE_ACCEPTING:
switch (src) {
case NN_AIPC_SRC_USOCK:
switch (type) {
case NN_USOCK_ACCEPTED:
/* Return ownership of the listening socket to the parent. */
nn_usock_swap_owner (aipc->listener, &aipc->listener_owner);
aipc->listener = NULL;
aipc->listener_owner.src = -1;
aipc->listener_owner.fsm = NULL;
nn_fsm_raise (&aipc->fsm, &aipc->accepted, NN_AIPC_ACCEPTED);
/* Start the sipc state machine. */
nn_usock_activate (&aipc->usock);
nn_sipc_start (&aipc->sipc, &aipc->usock);
aipc->state = NN_AIPC_STATE_ACTIVE;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* ACTIVE state. */
/******************************************************************************/
case NN_AIPC_STATE_ACTIVE:
switch (src) {
case NN_AIPC_SRC_SIPC:
switch (type) {
case NN_SIPC_ERROR:
nn_sipc_stop (&aipc->sipc);
aipc->state = NN_AIPC_STATE_STOPPING_SIPC;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* STOPPING_SIPC state. */
/******************************************************************************/
case NN_AIPC_STATE_STOPPING_SIPC:
switch (src) {
case NN_AIPC_SRC_SIPC:
switch (type) {
case NN_SIPC_STOPPED:
nn_usock_stop (&aipc->usock);
aipc->state = NN_AIPC_STATE_STOPPING_USOCK;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* STOPPING_USOCK state. */
/******************************************************************************/
case NN_AIPC_STATE_STOPPING_USOCK:
switch (src) {
case NN_AIPC_SRC_USOCK:
switch (type) {
case NN_USOCK_STOPPED:
nn_fsm_raise (&aipc->fsm, &aipc->done, NN_AIPC_ERROR);
aipc->state = NN_AIPC_STATE_DONE;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (aipc->state, src, type);
}
}
static void nn_streamhdr_handler (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_streamhdr *streamhdr;
struct nn_iovec iovec;
int protocol;
streamhdr = nn_cont (self, struct nn_streamhdr, fsm);
/******************************************************************************/
/* STOP procedure. */
/******************************************************************************/
if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
nn_timer_stop (&streamhdr->timer);
streamhdr->state = NN_STREAMHDR_STATE_STOPPING;
}
if (nn_slow (streamhdr->state == NN_STREAMHDR_STATE_STOPPING)) {
if (!nn_timer_isidle (&streamhdr->timer))
return;
streamhdr->state = NN_STREAMHDR_STATE_IDLE;
nn_fsm_stopped (&streamhdr->fsm, NN_STREAMHDR_STOPPED);
return;
}
switch (streamhdr->state) {
/******************************************************************************/
/* IDLE state. */
/******************************************************************************/
case NN_STREAMHDR_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_timer_start (&streamhdr->timer, 1000);
iovec.iov_base = streamhdr->protohdr;
iovec.iov_len = sizeof (streamhdr->protohdr);
nn_usock_send (streamhdr->usock, &iovec, 1);
streamhdr->state = NN_STREAMHDR_STATE_SENDING;
return;
default:
nn_fsm_bad_action (streamhdr->state, src, type);
}
default:
nn_fsm_bad_source (streamhdr->state, src, type);
}
/******************************************************************************/
/* SENDING state. */
/******************************************************************************/
case NN_STREAMHDR_STATE_SENDING:
switch (src) {
case NN_STREAMHDR_SRC_USOCK:
switch (type) {
case NN_USOCK_SENT:
nn_usock_recv (streamhdr->usock, streamhdr->protohdr,
sizeof (streamhdr->protohdr));
streamhdr->state = NN_STREAMHDR_STATE_RECEIVING;
return;
case NN_USOCK_ERROR:
nn_timer_stop (&streamhdr->timer);
streamhdr->state = NN_STREAMHDR_STATE_STOPPING_TIMER_ERROR;
return;
default:
nn_fsm_bad_action (streamhdr->state, src, type);
}
case NN_STREAMHDR_SRC_TIMER:
switch (type) {
case NN_TIMER_TIMEOUT:
nn_timer_stop (&streamhdr->timer);
streamhdr->state = NN_STREAMHDR_STATE_STOPPING_TIMER_ERROR;
return;
default:
nn_fsm_bad_action (streamhdr->state, src, type);
}
default:
nn_fsm_bad_source (streamhdr->state, src, type);
}
/******************************************************************************/
/* RECEIVING state. */
/******************************************************************************/
case NN_STREAMHDR_STATE_RECEIVING:
switch (src) {
case NN_STREAMHDR_SRC_USOCK:
switch (type) {
case NN_USOCK_RECEIVED:
/* Here we are checking whether the peer speaks the same
protocol as this socket. */
if (memcmp (streamhdr->protohdr, "\0SP\0", 4) != 0)
goto invalidhdr;
protocol = nn_gets (streamhdr->protohdr + 4);
if (!nn_pipebase_ispeer (streamhdr->pipebase, protocol))
goto invalidhdr;
nn_timer_stop (&streamhdr->timer);
streamhdr->state = NN_STREAMHDR_STATE_STOPPING_TIMER_DONE;
return;
case NN_USOCK_ERROR:
invalidhdr:
nn_timer_stop (&streamhdr->timer);
streamhdr->state = NN_STREAMHDR_STATE_STOPPING_TIMER_ERROR;
return;
default:
nn_assert (0);
}
case NN_STREAMHDR_SRC_TIMER:
switch (type) {
case NN_TIMER_TIMEOUT:
nn_timer_stop (&streamhdr->timer);
streamhdr->state = NN_STREAMHDR_STATE_STOPPING_TIMER_ERROR;
return;
default:
nn_fsm_bad_action (streamhdr->state, src, type);
}
default:
nn_fsm_bad_source (streamhdr->state, src, type);
}
/******************************************************************************/
/* STOPPING_TIMER_ERROR state. */
/******************************************************************************/
case NN_STREAMHDR_STATE_STOPPING_TIMER_ERROR:
switch (src) {
case NN_STREAMHDR_SRC_TIMER:
switch (type) {
case NN_TIMER_STOPPED:
nn_usock_swap_owner (streamhdr->usock, &streamhdr->usock_owner);
streamhdr->usock = NULL;
streamhdr->usock_owner.src = -1;
streamhdr->usock_owner.fsm = NULL;
streamhdr->state = NN_STREAMHDR_STATE_DONE;
nn_fsm_raise (&streamhdr->fsm, &streamhdr->done,
NN_STREAMHDR_ERROR);
return;
default:
nn_fsm_bad_action (streamhdr->state, src, type);
}
default:
nn_fsm_bad_source (streamhdr->state, src, type);
}
/******************************************************************************/
/* STOPPING_TIMER_DONE state. */
/******************************************************************************/
case NN_STREAMHDR_STATE_STOPPING_TIMER_DONE:
switch (src) {
case NN_STREAMHDR_SRC_TIMER:
switch (type) {
case NN_TIMER_STOPPED:
nn_usock_swap_owner (streamhdr->usock, &streamhdr->usock_owner);
streamhdr->usock = NULL;
streamhdr->usock_owner.src = -1;
streamhdr->usock_owner.fsm = NULL;
streamhdr->state = NN_STREAMHDR_STATE_DONE;
nn_fsm_raise (&streamhdr->fsm, &streamhdr->done,
NN_STREAMHDR_OK);
return;
default:
nn_fsm_bad_action (streamhdr->state, src, type);
}
default:
nn_fsm_bad_source (streamhdr->state, src, type);
}
/******************************************************************************/
/* DONE state. */
/* The header exchange was either done successfully of failed. There's */
/* nothing that can be done in this state except stopping the object. */
/******************************************************************************/
case NN_STREAMHDR_STATE_DONE:
nn_fsm_bad_source (streamhdr->state, src, type);
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (streamhdr->state, src, type);
}
}
static void nn_aws_handler (struct nn_fsm *self, int src, int type,
NN_UNUSED void *srcptr)
{
struct nn_aws *aws;
int val;
size_t sz;
aws = nn_cont (self, struct nn_aws, fsm);
nn_assert (aws);
switch (aws->state) {
/******************************************************************************/
/* IDLE state. */
/* The state machine wasn't yet started. */
/******************************************************************************/
case NN_AWS_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_usock_accept (&aws->usock, aws->listener);
aws->state = NN_AWS_STATE_ACCEPTING;
return;
default:
nn_fsm_bad_action (aws->state, src, type);
}
default:
nn_fsm_bad_source (aws->state, src, type);
}
/******************************************************************************/
/* ACCEPTING state. */
/* Waiting for incoming connection. */
/******************************************************************************/
case NN_AWS_STATE_ACCEPTING:
switch (src) {
case NN_AWS_SRC_USOCK:
switch (type) {
case NN_USOCK_ACCEPTED:
nn_epbase_clear_error (aws->epbase);
/* Set the relevant socket options. */
sz = sizeof (val);
nn_epbase_getopt (aws->epbase, NN_SOL_SOCKET, NN_SNDBUF,
&val, &sz);
nn_assert (sz == sizeof (val));
nn_usock_setsockopt (&aws->usock, SOL_SOCKET, SO_SNDBUF,
&val, sizeof (val));
sz = sizeof (val);
nn_epbase_getopt (aws->epbase, NN_SOL_SOCKET, NN_RCVBUF,
&val, &sz);
nn_assert (sz == sizeof (val));
nn_usock_setsockopt (&aws->usock, SOL_SOCKET, SO_RCVBUF,
&val, sizeof (val));
/* Since the WebSocket handshake must poll, the receive
timeout is set to zero. Later, it will be set again
to the value specified by the socket option. */
val = 0;
sz = sizeof (val);
nn_usock_setsockopt (&aws->usock, SOL_SOCKET, SO_RCVTIMEO,
&val, sizeof (val));
/* Return ownership of the listening socket to the parent. */
nn_usock_swap_owner (aws->listener, &aws->listener_owner);
aws->listener = NULL;
aws->listener_owner.src = -1;
aws->listener_owner.fsm = NULL;
nn_fsm_raise (&aws->fsm, &aws->accepted, NN_AWS_ACCEPTED);
/* Start the sws state machine. */
nn_usock_activate (&aws->usock);
nn_sws_start (&aws->sws, &aws->usock, NN_WS_SERVER,
NULL, NULL);
aws->state = NN_AWS_STATE_ACTIVE;
nn_epbase_stat_increment (aws->epbase,
NN_STAT_ACCEPTED_CONNECTIONS, 1);
return;
default:
nn_fsm_bad_action (aws->state, src, type);
}
case NN_AWS_SRC_LISTENER:
switch (type) {
case NN_USOCK_ACCEPT_ERROR:
nn_epbase_set_error (aws->epbase,
nn_usock_geterrno (aws->listener));
nn_epbase_stat_increment (aws->epbase,
NN_STAT_ACCEPT_ERRORS, 1);
nn_usock_accept (&aws->usock, aws->listener);
return;
default:
nn_fsm_bad_action (aws->state, src, type);
}
default:
nn_fsm_bad_source (aws->state, src, type);
}
/******************************************************************************/
/* ACTIVE state. */
/******************************************************************************/
case NN_AWS_STATE_ACTIVE:
switch (src) {
case NN_AWS_SRC_SWS:
switch (type) {
case NN_SWS_RETURN_CLOSE_HANDSHAKE:
/* Peer closed connection without intention to reconnect, or
local endpoint failed remote because of invalid data. */
nn_sws_stop (&aws->sws);
aws->state = NN_AWS_STATE_STOPPING_SWS;
return;
case NN_SWS_RETURN_ERROR:
nn_sws_stop (&aws->sws);
aws->state = NN_AWS_STATE_STOPPING_SWS;
nn_epbase_stat_increment (aws->epbase,
NN_STAT_BROKEN_CONNECTIONS, 1);
return;
default:
nn_fsm_bad_action (aws->state, src, type);
}
default:
nn_fsm_bad_source (aws->state, src, type);
}
/******************************************************************************/
/* STOPPING_SWS state. */
/******************************************************************************/
case NN_AWS_STATE_STOPPING_SWS:
switch (src) {
case NN_AWS_SRC_SWS:
switch (type) {
case NN_USOCK_SHUTDOWN:
return;
case NN_SWS_RETURN_STOPPED:
nn_usock_stop (&aws->usock);
aws->state = NN_AWS_STATE_STOPPING_USOCK;
return;
default:
nn_fsm_bad_action (aws->state, src, type);
}
default:
nn_fsm_bad_source (aws->state, src, type);
}
/******************************************************************************/
/* STOPPING_USOCK state. */
/******************************************************************************/
case NN_AWS_STATE_STOPPING_USOCK:
switch (src) {
case NN_AWS_SRC_USOCK:
switch (type) {
case NN_USOCK_SHUTDOWN:
return;
case NN_USOCK_STOPPED:
nn_aws_stop (aws);
return;
default:
nn_fsm_bad_action (aws->state, src, type);
}
default:
nn_fsm_bad_source (aws->state, src, type);
}
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (aws->state, src, type);
}
}
static void nn_aipc_handler (struct nn_fsm *self, int src, int type,
void *srcptr)
{
struct nn_aipc *aipc;
int val;
size_t sz;
aipc = nn_cont (self, struct nn_aipc, fsm);
switch (aipc->state) {
/******************************************************************************/
/* IDLE state. */
/* The state machine wasn't yet started. */
/******************************************************************************/
case NN_AIPC_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_usock_accept (&aipc->usock, aipc->listener);
aipc->state = NN_AIPC_STATE_ACCEPTING;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* ACCEPTING state. */
/* Waiting for incoming connection. */
/******************************************************************************/
case NN_AIPC_STATE_ACCEPTING:
switch (src) {
case NN_AIPC_SRC_USOCK:
switch (type) {
case NN_USOCK_ACCEPTED:
/* Set the relevant socket options. */
sz = sizeof (val);
nn_epbase_getopt (aipc->epbase, NN_SOL_SOCKET, NN_SNDBUF,
&val, &sz);
nn_assert (sz == sizeof (val));
nn_usock_setsockopt (&aipc->usock, SOL_SOCKET, SO_SNDBUF,
&val, sizeof (val));
sz = sizeof (val);
nn_epbase_getopt (aipc->epbase, NN_SOL_SOCKET, NN_RCVBUF,
&val, &sz);
nn_assert (sz == sizeof (val));
nn_usock_setsockopt (&aipc->usock, SOL_SOCKET, SO_RCVBUF,
&val, sizeof (val));
/* Return ownership of the listening socket to the parent. */
nn_usock_swap_owner (aipc->listener, &aipc->listener_owner);
aipc->listener = NULL;
aipc->listener_owner.src = -1;
aipc->listener_owner.fsm = NULL;
nn_fsm_raise (&aipc->fsm, &aipc->accepted, NN_AIPC_ACCEPTED);
/* Start the sipc state machine. */
nn_usock_activate (&aipc->usock);
nn_sipc_start (&aipc->sipc, &aipc->usock);
aipc->state = NN_AIPC_STATE_ACTIVE;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* ACTIVE state. */
/******************************************************************************/
case NN_AIPC_STATE_ACTIVE:
switch (src) {
case NN_AIPC_SRC_SIPC:
switch (type) {
case NN_SIPC_ERROR:
nn_sipc_stop (&aipc->sipc);
aipc->state = NN_AIPC_STATE_STOPPING_SIPC;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* STOPPING_SIPC state. */
/******************************************************************************/
case NN_AIPC_STATE_STOPPING_SIPC:
switch (src) {
case NN_AIPC_SRC_SIPC:
switch (type) {
case NN_SIPC_STOPPED:
nn_usock_stop (&aipc->usock);
aipc->state = NN_AIPC_STATE_STOPPING_USOCK;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* STOPPING_USOCK state. */
/******************************************************************************/
case NN_AIPC_STATE_STOPPING_USOCK:
switch (src) {
case NN_AIPC_SRC_USOCK:
switch (type) {
case NN_USOCK_STOPPED:
nn_fsm_raise (&aipc->fsm, &aipc->done, NN_AIPC_ERROR);
aipc->state = NN_AIPC_STATE_DONE;
return;
default:
nn_fsm_bad_action (aipc->state, src, type);
}
default:
nn_fsm_bad_source (aipc->state, src, type);
}
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_fsm_bad_state (aipc->state, src, type);
}
}
static void nn_stcp_handler (struct nn_fsm *self, int src, int type,
void *srcptr)
{
int rc;
struct nn_stcp *stcp;
uint64_t size;
stcp = nn_cont (self, struct nn_stcp, fsm);
/******************************************************************************/
/* STOP procedure. */
/******************************************************************************/
if (nn_slow (src == NN_FSM_ACTION && type == NN_FSM_STOP)) {
nn_pipebase_stop (&stcp->pipebase);
nn_streamhdr_stop (&stcp->streamhdr);
stcp->state = NN_STCP_STATE_STOPPING;
}
if (nn_slow (stcp->state == NN_STCP_STATE_STOPPING)) {
if (nn_streamhdr_isidle (&stcp->streamhdr)) {
nn_usock_swap_owner (stcp->usock, &stcp->usock_owner);
stcp->usock = NULL;
stcp->usock_owner.src = -1;
stcp->usock_owner.fsm = NULL;
stcp->state = NN_STCP_STATE_IDLE;
nn_fsm_stopped (&stcp->fsm, NN_STCP_STOPPED);
return;
}
return;
}
switch (stcp->state) {
/******************************************************************************/
/* IDLE state. */
/******************************************************************************/
case NN_STCP_STATE_IDLE:
switch (src) {
case NN_FSM_ACTION:
switch (type) {
case NN_FSM_START:
nn_streamhdr_start (&stcp->streamhdr, stcp->usock,
&stcp->pipebase);
stcp->state = NN_STCP_STATE_PROTOHDR;
return;
default:
nn_assert (0);
}
default:
nn_assert (0);
}
/******************************************************************************/
/* PROTOHDR state. */
/******************************************************************************/
case NN_STCP_STATE_PROTOHDR:
switch (src) {
case NN_STCP_SRC_STREAMHDR:
switch (type) {
case NN_STREAMHDR_OK:
/* Before moving to the active state stop the streamhdr
state machine. */
nn_streamhdr_stop (&stcp->streamhdr);
stcp->state = NN_STCP_STATE_STOPPING_STREAMHDR;
return;
case NN_STREAMHDR_ERROR:
/* Raise the error and move directly to the DONE state.
streamhdr object will be stopped later on. */
stcp->state = NN_STCP_STATE_DONE;
nn_fsm_raise (&stcp->fsm, &stcp->done, NN_STCP_ERROR);
return;
default:
nn_assert (0);
}
default:
nn_assert (0);
}
/******************************************************************************/
/* STOPPING_STREAMHDR state. */
/******************************************************************************/
case NN_STCP_STATE_STOPPING_STREAMHDR:
switch (src) {
case NN_STCP_SRC_STREAMHDR:
switch (type) {
case NN_STREAMHDR_STOPPED:
/* Start the pipe. */
rc = nn_pipebase_start (&stcp->pipebase);
errnum_assert (rc == 0, -rc);
/* Start receiving a message in asynchronous manner. */
stcp->instate = NN_STCP_INSTATE_HDR;
nn_usock_recv (stcp->usock, &stcp->inhdr,
sizeof (stcp->inhdr));
/* Mark the pipe as available for sending. */
stcp->outstate = NN_STCP_OUTSTATE_IDLE;
stcp->state = NN_STCP_STATE_ACTIVE;
return;
default:
nn_assert (0);
}
default:
nn_assert (0);
}
/******************************************************************************/
/* ACTIVE state. */
/******************************************************************************/
case NN_STCP_STATE_ACTIVE:
switch (src) {
case NN_STCP_SRC_USOCK:
switch (type) {
case NN_USOCK_SENT:
/* The message is now fully sent. */
nn_assert (stcp->outstate == NN_STCP_OUTSTATE_SENDING);
stcp->outstate = NN_STCP_OUTSTATE_IDLE;
nn_msg_term (&stcp->outmsg);
nn_msg_init (&stcp->outmsg, 0);
nn_pipebase_sent (&stcp->pipebase);
return;
case NN_USOCK_RECEIVED:
switch (stcp->instate) {
case NN_STCP_INSTATE_HDR:
/* Message header was received. Allocate memory for the
message. */
size = nn_getll (stcp->inhdr);
nn_msg_term (&stcp->inmsg);
nn_msg_init (&stcp->inmsg, (size_t) size);
/* Special case when size of the message body is 0. */
if (!size) {
stcp->instate = NN_STCP_INSTATE_HASMSG;
nn_pipebase_received (&stcp->pipebase);
return;
}
/* Start receiving the message body. */
stcp->instate = NN_STCP_INSTATE_BODY;
nn_usock_recv (stcp->usock,
nn_chunkref_data (&stcp->inmsg.body), (size_t) size);
return;
case NN_STCP_INSTATE_BODY:
/* Message body was received. Notify the owner that it
can receive it. */
stcp->instate = NN_STCP_INSTATE_HASMSG;
nn_pipebase_received (&stcp->pipebase);
return;
default:
nn_assert (0);
}
case NN_USOCK_ERROR:
nn_pipebase_stop (&stcp->pipebase);
stcp->state = NN_STCP_STATE_DONE;
nn_fsm_raise (&stcp->fsm, &stcp->done, NN_STCP_ERROR);
return;
default:
nn_assert (0);
}
default:
nn_assert (0);
}
/******************************************************************************/
/* DONE state. */
/* The underlying connection is closed. There's nothing that can be done in */
/* this state except stopping the object. */
/******************************************************************************/
case NN_STCP_STATE_DONE:
nn_assert (0);
/******************************************************************************/
/* Invalid state. */
/******************************************************************************/
default:
nn_assert (0);
}
}