void nn_aws_init (struct nn_aws *self, int src,
struct nn_epbase *epbase, struct nn_fsm *owner)
{
nn_fsm_init (&self->fsm, nn_aws_handler, nn_aws_shutdown,
src, self, owner);
self->state = NN_AWS_STATE_IDLE;
self->epbase = epbase;
nn_usock_init (&self->usock, NN_AWS_SRC_USOCK, &self->fsm);
self->listener = NULL;
self->listener_owner.src = -1;
self->listener_owner.fsm = NULL;
nn_sws_init (&self->sws, NN_AWS_SRC_SWS, epbase, &self->fsm);
nn_fsm_event_init (&self->accepted);
nn_fsm_event_init (&self->done);
nn_list_item_init (&self->item);
}
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;
}
