static void nn_cstream_terminating_closed (const struct nn_cp_sink **self,
struct nn_usock *usock)
{
struct nn_cstream *cstream;
cstream = nn_cont (self, struct nn_cstream, sink);
nn_epbase_term (&cstream->epbase);
nn_free (cstream);
}
static void nn_binproc_destroy (struct nn_epbase *self)
{
struct nn_binproc *binproc;
binproc = nn_cont (self, struct nn_binproc, epbase);
nn_list_item_term (&binproc->item);
nn_list_term (&binproc->sinprocs);
nn_fsm_term (&binproc->fsm);
nn_epbase_term (&binproc->epbase);
nn_free (binproc);
}
static void nn_cipc_destroy (struct nn_epbase *self)
{
struct nn_cipc *cipc;
cipc = nn_cont (self, struct nn_cipc, epbase);
nn_sipc_term (&cipc->sipc);
nn_backoff_term (&cipc->retry);
nn_usock_term (&cipc->usock);
nn_fsm_term (&cipc->fsm);
nn_epbase_term (&cipc->epbase);
nn_free (cipc);
}
static void nn_btcp_destroy (struct nn_epbase *self)
{
struct nn_btcp *btcp;
btcp = nn_cont (self, struct nn_btcp, epbase);
nn_assert_state (btcp, NN_BTCP_STATE_IDLE);
nn_list_term (&btcp->atcps);
nn_assert (btcp->atcp == NULL);
nn_usock_term (&btcp->usock);
nn_epbase_term (&btcp->epbase);
nn_fsm_term (&btcp->fsm);
nn_free (btcp);
}
static void nn_ctcp_destroy (struct nn_epbase *self)
{
struct nn_ctcp *ctcp;
ctcp = nn_cont (self, struct nn_ctcp, epbase);
nn_dns_term (&ctcp->dns);
nn_stcp_term (&ctcp->stcp);
nn_backoff_term (&ctcp->retry);
nn_usock_term (&ctcp->usock);
nn_fsm_term (&ctcp->fsm);
nn_epbase_term (&ctcp->epbase);
nn_free (ctcp);
}
static void nn_bipc_destroy (struct nn_epbase *self)
{
struct nn_bipc *bipc;
bipc = nn_cont (self, struct nn_bipc, epbase);
nn_assert (bipc->state == NN_BIPC_STATE_IDLE);
nn_list_term (&bipc->aipcs);
nn_assert (bipc->aipc == NULL);
nn_usock_term (&bipc->usock);
nn_epbase_term (&bipc->epbase);
nn_fsm_term (&bipc->fsm);
nn_free (bipc);
}
static void nn_bws_destroy (struct nn_epbase *self)
{
struct nn_bws *bws;
bws = nn_cont (self, struct nn_bws, epbase);
nn_assert_state (bws, NN_BWS_STATE_IDLE);
nn_list_term (&bws->awss);
nn_assert (bws->aws == NULL);
nn_usock_term (&bws->usock);
nn_epbase_term (&bws->epbase);
nn_fsm_term (&bws->fsm);
nn_free (bws);
}
static void nn_cws_destroy (struct nn_epbase *self)
{
struct nn_cws *cws;
cws = nn_cont (self, struct nn_cws, epbase);
nn_chunkref_term (&cws->resource);
nn_chunkref_term (&cws->remote_host);
nn_chunkref_term (&cws->nic);
nn_dns_term (&cws->dns);
nn_sws_term (&cws->sws);
nn_backoff_term (&cws->retry);
nn_usock_term (&cws->usock);
nn_fsm_term (&cws->fsm);
nn_epbase_term (&cws->epbase);
nn_free (cws);
}
int nn_btcp_create (void *hint, struct nn_epbase **epbase)
{
int rc;
struct nn_btcp *self;
const char *addr;
const char *end;
const char *pos;
struct sockaddr_storage ss;
size_t sslen;
int ipv4only;
size_t ipv4onlylen;
/* Allocate the new endpoint object. */
self = nn_alloc (sizeof (struct nn_btcp), "btcp");
alloc_assert (self);
/* Initalise the epbase. */
nn_epbase_init (&self->epbase, &nn_btcp_epbase_vfptr, hint);
addr = nn_epbase_getaddr (&self->epbase);
/* Parse the port. */
end = addr + strlen (addr);
pos = strrchr (addr, ':');
if (nn_slow (!pos)) {
nn_epbase_term (&self->epbase);
return -EINVAL;
}
++pos;
rc = nn_port_resolve (pos, end - pos);
if (nn_slow (rc < 0)) {
nn_epbase_term (&self->epbase);
return -EINVAL;
}
/* Check whether IPv6 is to be used. */
ipv4onlylen = sizeof (ipv4only);
nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
&ipv4only, &ipv4onlylen);
nn_assert (ipv4onlylen == sizeof (ipv4only));
/* Parse the address. */
rc = nn_iface_resolve (addr, pos - addr - 1, ipv4only, &ss, &sslen);
if (nn_slow (rc < 0)) {
nn_epbase_term (&self->epbase);
return -ENODEV;
}
/* Initialise the structure. */
nn_fsm_init_root (&self->fsm, nn_btcp_handler, nn_btcp_shutdown,
nn_epbase_getctx (&self->epbase));
self->state = NN_BTCP_STATE_IDLE;
nn_usock_init (&self->usock, NN_BTCP_SRC_USOCK, &self->fsm);
self->atcp = NULL;
nn_list_init (&self->atcps);
/* Start the state machine. */
nn_fsm_start (&self->fsm);
/* Return the base class as an out parameter. */
*epbase = &self->epbase;
return 0;
}
void nn_ins_item_term (struct nn_ins_item *self)
{
nn_list_item_term (&self->item);
nn_epbase_term (&self->epbase);
}
int nn_ctcp_create (void *hint, struct nn_epbase **epbase)
{
int rc;
const char *addr;
size_t addrlen;
const char *semicolon;
const char *hostname;
const char *colon;
const char *end;
struct sockaddr_storage ss;
size_t sslen;
int ipv4only;
size_t ipv4onlylen;
struct nn_ctcp *self;
int reconnect_ivl;
int reconnect_ivl_max;
size_t sz;
/* Allocate the new endpoint object. */
self = nn_alloc (sizeof (struct nn_ctcp), "ctcp");
alloc_assert (self);
/* Initalise the endpoint. */
nn_epbase_init (&self->epbase, &nn_ctcp_epbase_vfptr, hint);
/* Check whether IPv6 is to be used. */
ipv4onlylen = sizeof (ipv4only);
nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
&ipv4only, &ipv4onlylen);
nn_assert (ipv4onlylen == sizeof (ipv4only));
/* Start parsing the address. */
addr = nn_epbase_getaddr (&self->epbase);
addrlen = strlen (addr);
semicolon = strchr (addr, ';');
hostname = semicolon ? semicolon + 1 : addr;
colon = strrchr (addr, ':');
end = addr + addrlen;
/* Parse the port. */
if (nn_slow (!colon)) {
nn_epbase_term (&self->epbase);
return -EINVAL;
}
rc = nn_port_resolve (colon + 1, end - colon - 1);
if (nn_slow (rc < 0)) {
nn_epbase_term (&self->epbase);
return -EINVAL;
}
/* Check whether the host portion of the address is either a literal
or a valid hostname. */
if (nn_dns_check_hostname (hostname, colon - hostname) < 0 &&
nn_literal_resolve (hostname, colon - hostname, ipv4only,
&ss, &sslen) < 0) {
nn_epbase_term (&self->epbase);
return -EINVAL;
}
/* If local address is specified, check whether it is valid. */
if (semicolon) {
rc = nn_iface_resolve (addr, semicolon - addr, ipv4only, &ss, &sslen);
if (rc < 0) {
nn_epbase_term (&self->epbase);
return -ENODEV;
}
}
/* Initialise the structure. */
nn_fsm_init_root (&self->fsm, nn_ctcp_handler, nn_ctcp_shutdown,
nn_epbase_getctx (&self->epbase));
self->state = NN_CTCP_STATE_IDLE;
nn_usock_init (&self->usock, NN_CTCP_SRC_USOCK, &self->fsm);
sz = sizeof (reconnect_ivl);
nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL,
&reconnect_ivl, &sz);
nn_assert (sz == sizeof (reconnect_ivl));
sz = sizeof (reconnect_ivl_max);
nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX,
&reconnect_ivl_max, &sz);
nn_assert (sz == sizeof (reconnect_ivl_max));
if (reconnect_ivl_max == 0)
reconnect_ivl_max = reconnect_ivl;
nn_backoff_init (&self->retry, NN_CTCP_SRC_RECONNECT_TIMER,
reconnect_ivl, reconnect_ivl_max, &self->fsm);
nn_stcp_init (&self->stcp, NN_CTCP_SRC_STCP, &self->epbase, &self->fsm);
nn_dns_init (&self->dns, NN_CTCP_SRC_DNS, &self->fsm);
/* Start the state machine. */
nn_fsm_start (&self->fsm);
/* Return the base class as an out parameter. */
*epbase = &self->epbase;
return 0;
}
int nn_cws_create (void *hint, struct nn_epbase **epbase)
{
int rc;
const char *addr;
size_t addrlen;
const char *semicolon;
const char *hostname;
size_t hostlen;
const char *colon;
const char *slash;
const char *resource;
size_t resourcelen;
struct sockaddr_storage ss;
size_t sslen;
int ipv4only;
size_t ipv4onlylen;
struct nn_cws *self;
int reconnect_ivl;
int reconnect_ivl_max;
int msg_type;
size_t sz;
/* Allocate the new endpoint object. */
self = nn_alloc (sizeof (struct nn_cws), "cws");
alloc_assert (self);
/* Initalise the endpoint. */
nn_epbase_init (&self->epbase, &nn_cws_epbase_vfptr, hint);
/* Check whether IPv6 is to be used. */
ipv4onlylen = sizeof (ipv4only);
nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_IPV4ONLY,
&ipv4only, &ipv4onlylen);
nn_assert (ipv4onlylen == sizeof (ipv4only));
/* Start parsing the address. */
addr = nn_epbase_getaddr (&self->epbase);
addrlen = strlen (addr);
semicolon = strchr (addr, ';');
hostname = semicolon ? semicolon + 1 : addr;
colon = strrchr (addr, ':');
slash = colon ? strchr (colon, '/') : strchr (addr, '/');
resource = slash ? slash : addr + addrlen;
self->remote_hostname_len = colon ? colon - hostname : resource - hostname;
/* Host contains both hostname and port. */
hostlen = resource - hostname;
/* Parse the port; assume port 80 if not explicitly declared. */
if (nn_slow (colon != NULL)) {
rc = nn_port_resolve (colon + 1, resource - colon - 1);
if (nn_slow (rc < 0)) {
nn_epbase_term (&self->epbase);
return -EINVAL;
}
self->remote_port = rc;
}
else {
self->remote_port = 80;
}
/* Check whether the host portion of the address is either a literal
or a valid hostname. */
if (nn_dns_check_hostname (hostname, self->remote_hostname_len) < 0 &&
nn_literal_resolve (hostname, self->remote_hostname_len, ipv4only,
&ss, &sslen) < 0) {
nn_epbase_term (&self->epbase);
return -EINVAL;
}
/* If local address is specified, check whether it is valid. */
if (semicolon) {
rc = nn_iface_resolve (addr, semicolon - addr, ipv4only, &ss, &sslen);
if (rc < 0) {
nn_epbase_term (&self->epbase);
return -ENODEV;
}
}
/* At this point, the address is valid, so begin allocating resources. */
nn_chunkref_init (&self->remote_host, hostlen + 1);
memcpy (nn_chunkref_data (&self->remote_host), hostname, hostlen);
((uint8_t *) nn_chunkref_data (&self->remote_host)) [hostlen] = '\0';
if (semicolon) {
nn_chunkref_init (&self->nic, semicolon - addr);
memcpy (nn_chunkref_data (&self->nic),
addr, semicolon - addr);
}
else {
nn_chunkref_init (&self->nic, 1);
memcpy (nn_chunkref_data (&self->nic), "*", 1);
}
/* The requested resource is used in opening handshake. */
resourcelen = strlen (resource);
if (resourcelen) {
nn_chunkref_init (&self->resource, resourcelen + 1);
strncpy (nn_chunkref_data (&self->resource),
resource, resourcelen + 1);
}
else {
/* No resource specified, so allocate base path. */
nn_chunkref_init (&self->resource, 2);
strncpy (nn_chunkref_data (&self->resource), "/", 2);
}
/* Initialise the structure. */
nn_fsm_init_root (&self->fsm, nn_cws_handler, nn_cws_shutdown,
nn_epbase_getctx (&self->epbase));
self->state = NN_CWS_STATE_IDLE;
nn_usock_init (&self->usock, NN_CWS_SRC_USOCK, &self->fsm);
sz = sizeof (msg_type);
nn_epbase_getopt (&self->epbase, NN_WS, NN_WS_MSG_TYPE,
&msg_type, &sz);
nn_assert (sz == sizeof (msg_type));
self->msg_type = (uint8_t) msg_type;
sz = sizeof (reconnect_ivl);
nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL,
&reconnect_ivl, &sz);
nn_assert (sz == sizeof (reconnect_ivl));
sz = sizeof (reconnect_ivl_max);
nn_epbase_getopt (&self->epbase, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX,
&reconnect_ivl_max, &sz);
nn_assert (sz == sizeof (reconnect_ivl_max));
if (reconnect_ivl_max == 0)
reconnect_ivl_max = reconnect_ivl;
nn_backoff_init (&self->retry, NN_CWS_SRC_RECONNECT_TIMER,
reconnect_ivl, reconnect_ivl_max, &self->fsm);
nn_sws_init (&self->sws, NN_CWS_SRC_SWS, &self->epbase, &self->fsm);
nn_dns_init (&self->dns, NN_CWS_SRC_DNS, &self->fsm);
/* Start the state machine. */
nn_fsm_start (&self->fsm);
/* Return the base class as an out parameter. */
*epbase = &self->epbase;
return 0;
}
