int nn_ws_send (int s, const void *msg, size_t len, uint8_t msg_type, int flags)
{
int rc;
struct nn_iovec iov;
struct nn_msghdr hdr;
struct nn_cmsghdr *cmsg;
size_t cmsgsz;
iov.iov_base = (void*) msg;
iov.iov_len = len;
cmsgsz = NN_CMSG_SPACE (sizeof (msg_type));
cmsg = nn_allocmsg (cmsgsz, 0);
if (cmsg == NULL)
return -1;
cmsg->cmsg_level = NN_WS;
cmsg->cmsg_type = NN_WS_HDR_OPCODE;
cmsg->cmsg_len = NN_CMSG_LEN (sizeof (msg_type));
memcpy (NN_CMSG_DATA (cmsg), &msg_type, sizeof (msg_type));
hdr.msg_iov = &iov;
hdr.msg_iovlen = 1;
hdr.msg_control = &cmsg;
hdr.msg_controllen = NN_MSG;
rc = nn_sendmsg (s, &hdr, flags);
return rc;
}
struct nn_cmsghdr *nn_cmsg_nxthdr_ (const struct nn_msghdr *mhdr,
const struct nn_cmsghdr *cmsg)
{
char *data;
size_t sz;
struct nn_cmsghdr *next;
size_t headsz;
/* Early return if no message is provided. */
if (nn_slow (mhdr == NULL))
return NULL;
/* Get the actual data. */
if (mhdr->msg_controllen == NN_MSG) {
data = *((void**) mhdr->msg_control);
sz = nn_chunk_size (data);
}
else {
data = (char*) mhdr->msg_control;
sz = mhdr->msg_controllen;
}
/* Ancillary data allocation was not even large enough for one element. */
if (nn_slow (sz < NN_CMSG_SPACE (0)))
return NULL;
/* If cmsg is set to NULL we are going to return first property.
Otherwise move to the next property. */
if (!cmsg)
next = (struct nn_cmsghdr*) data;
else
next = (struct nn_cmsghdr*)
(((char*) cmsg) + NN_CMSG_ALIGN_ (cmsg->cmsg_len));
/* If there's no space for next property, treat it as the end
of the property list. */
headsz = ((char*) next) - data;
if (headsz + NN_CMSG_SPACE (0) > sz ||
headsz + NN_CMSG_ALIGN_ (next->cmsg_len) > sz)
return NULL;
/* Success. */
return next;
}
struct nn_cmsghdr *nn_cmsg_nexthdr_ (const struct nn_msghdr *mhdr,
const struct nn_cmsghdr *cmsg)
{
char *data;
size_t sz;
struct nn_cmsghdr *next;
size_t headsz;
/* Get the actual data. */
if (mhdr->msg_controllen == NN_MSG) {
data = *((void**) mhdr->msg_control);
sz = nn_chunk_size (data);
}
else {
data = (char*) mhdr->msg_control;
sz = mhdr->msg_controllen;
}
/* If cmsg is set to NULL we are going to return first property.
Otherwise move to the next property. */
if (!cmsg)
next = (struct nn_cmsghdr*) data;
else
next = (struct nn_cmsghdr*)
(((char*) cmsg) + NN_CMSG_SPACE (cmsg->cmsg_len));
/* If there's no space for next property, treat it as the end
of the property list. */
headsz = ((char*) next) - ((char*) mhdr->msg_control);
if (headsz + sizeof (struct nn_cmsghdr) > sz ||
headsz + NN_CMSG_SPACE (next->cmsg_len) > sz)
return NULL;
/* Success. */
return next;
}
int nn_recvmsg (int s, struct nn_msghdr *msghdr, int flags)
{
int rc;
struct nn_msg msg;
uint8_t *data;
size_t sz;
int i;
struct nn_iovec *iov;
void *chunk;
size_t hdrssz;
void *ctrl;
size_t ctrlsz;
size_t spsz;
size_t sptotalsz;
struct nn_cmsghdr *chdr;
NN_BASIC_CHECKS;
if (nn_slow (!msghdr)) {
errno = EINVAL;
return -1;
}
if (nn_slow (msghdr->msg_iovlen < 0)) {
errno = EMSGSIZE;
return -1;
}
/* Get a message. */
rc = nn_sock_recv (self.socks [s], &msg, flags);
if (nn_slow (rc < 0)) {
errno = -rc;
return -1;
}
if (msghdr->msg_iovlen == 1 && msghdr->msg_iov [0].iov_len == NN_MSG) {
chunk = nn_chunkref_getchunk (&msg.body);
*(void**) (msghdr->msg_iov [0].iov_base) = chunk;
sz = nn_chunk_size (chunk);
}
else {
/* Copy the message content into the supplied gather array. */
data = nn_chunkref_data (&msg.body);
sz = nn_chunkref_size (&msg.body);
for (i = 0; i != msghdr->msg_iovlen; ++i) {
iov = &msghdr->msg_iov [i];
if (nn_slow (iov->iov_len == NN_MSG)) {
nn_msg_term (&msg);
errno = EINVAL;
return -1;
}
if (iov->iov_len > sz) {
memcpy (iov->iov_base, data, sz);
break;
}
memcpy (iov->iov_base, data, iov->iov_len);
data += iov->iov_len;
sz -= iov->iov_len;
}
sz = nn_chunkref_size (&msg.body);
}
/* Retrieve the ancillary data from the message. */
if (msghdr->msg_control) {
spsz = nn_chunkref_size (&msg.sphdr);
sptotalsz = NN_CMSG_SPACE (spsz);
ctrlsz = sptotalsz + nn_chunkref_size (&msg.hdrs);
if (msghdr->msg_controllen == NN_MSG) {
/* Allocate the buffer. */
rc = nn_chunk_alloc (ctrlsz, 0, &ctrl);
errnum_assert (rc == 0, -rc);
/* Set output parameters. */
*((void**) msghdr->msg_control) = ctrl;
}
else {
/* Just use the buffer supplied by the user. */
ctrl = msghdr->msg_control;
ctrlsz = msghdr->msg_controllen;
}
/* If SP header alone won't fit into the buffer, return no ancillary
properties. */
if (ctrlsz >= sptotalsz) {
/* Fill in SP_HDR ancillary property. */
chdr = (struct nn_cmsghdr*) ctrl;
chdr->cmsg_len = sptotalsz;
chdr->cmsg_level = PROTO_SP;
chdr->cmsg_type = SP_HDR;
memcpy (chdr + 1, nn_chunkref_data (&msg.sphdr), spsz);
/* Fill in as many remaining properties as possible.
Truncate the trailing properties if necessary. */
hdrssz = nn_chunkref_size (&msg.hdrs);
if (hdrssz > ctrlsz - sptotalsz)
hdrssz = ctrlsz - sptotalsz;
memcpy (((char*) ctrl) + sptotalsz,
nn_chunkref_data (&msg.hdrs), hdrssz);
}
}
nn_msg_term (&msg);
return (int) sz;
}
int nn_sendmsg (int s, const struct nn_msghdr *msghdr, int flags)
{
int rc;
size_t sz;
size_t spsz;
int i;
struct nn_iovec *iov;
struct nn_msg msg;
void *chunk;
int nnmsg;
struct nn_cmsghdr *cmsg;
NN_BASIC_CHECKS;
if (nn_slow (!msghdr)) {
errno = EINVAL;
return -1;
}
if (nn_slow (msghdr->msg_iovlen < 0)) {
errno = EMSGSIZE;
return -1;
}
if (msghdr->msg_iovlen == 1 && msghdr->msg_iov [0].iov_len == NN_MSG) {
chunk = *(void**) msghdr->msg_iov [0].iov_base;
if (nn_slow (chunk == NULL)) {
errno = EFAULT;
return -1;
}
sz = nn_chunk_size (chunk);
nn_msg_init_chunk (&msg, chunk);
nnmsg = 1;
}
else {
/* Compute the total size of the message. */
sz = 0;
for (i = 0; i != msghdr->msg_iovlen; ++i) {
iov = &msghdr->msg_iov [i];
if (nn_slow (iov->iov_len == NN_MSG)) {
errno = EINVAL;
return -1;
}
if (nn_slow (!iov->iov_base && iov->iov_len)) {
errno = EFAULT;
return -1;
}
if (nn_slow (sz + iov->iov_len < sz)) {
errno = EINVAL;
return -1;
}
sz += iov->iov_len;
}
/* Create a message object from the supplied scatter array. */
nn_msg_init (&msg, sz);
sz = 0;
for (i = 0; i != msghdr->msg_iovlen; ++i) {
iov = &msghdr->msg_iov [i];
memcpy (((uint8_t*) nn_chunkref_data (&msg.body)) + sz,
iov->iov_base, iov->iov_len);
sz += iov->iov_len;
}
nnmsg = 0;
}
/* Add ancillary data to the message. */
if (msghdr->msg_control) {
/* Copy all headers. */
/* TODO: SP_HDR should not be copied here! */
if (msghdr->msg_controllen == NN_MSG) {
chunk = *((void**) msghdr->msg_control);
nn_chunkref_term (&msg.hdrs);
nn_chunkref_init_chunk (&msg.hdrs, chunk);
}
else {
nn_chunkref_term (&msg.hdrs);
nn_chunkref_init (&msg.hdrs, msghdr->msg_controllen);
memcpy (nn_chunkref_data (&msg.hdrs),
msghdr->msg_control, msghdr->msg_controllen);
}
/* Search for SP_HDR property. */
cmsg = NN_CMSG_FIRSTHDR (msghdr);
while (cmsg) {
if (cmsg->cmsg_level == PROTO_SP && cmsg->cmsg_type == SP_HDR) {
/* Copy body of SP_HDR property into 'sphdr'. */
nn_chunkref_term (&msg.sphdr);
spsz = cmsg->cmsg_len - NN_CMSG_SPACE (0);
nn_chunkref_init (&msg.sphdr, spsz);
memcpy (nn_chunkref_data (&msg.sphdr),
NN_CMSG_DATA (cmsg), spsz);
break;
}
cmsg = NN_CMSG_NXTHDR (msghdr, cmsg);
}
}
/* Send it further down the stack. */
rc = nn_sock_send (self.socks [s], &msg, flags);
if (nn_slow (rc < 0)) {
/* If we are dealing with user-supplied buffer, detach it from
the message object. */
if (nnmsg)
nn_chunkref_init (&msg.body, 0);
nn_msg_term (&msg);
errno = -rc;
return -1;
}
/* Adjust the statistics. */
nn_sock_stat_increment (self.socks [s], NN_STAT_MESSAGES_SENT, 1);
nn_sock_stat_increment (self.socks [s], NN_STAT_BYTES_SENT, sz);
return (int) sz;
}
int main ()
{
int rc;
int rep;
int req;
struct nn_msghdr hdr;
struct nn_iovec iovec;
unsigned char body [3];
unsigned char ctrl [256];
struct nn_cmsghdr *cmsg;
unsigned char *data;
void *buf;
rep = test_socket (AF_SP_RAW, NN_REP);
test_bind (rep, SOCKET_ADDRESS);
req = test_socket (AF_SP, NN_REQ);
test_connect (req, SOCKET_ADDRESS);
/* Test ancillary data in static buffer. */
test_send (req, "ABC");
iovec.iov_base = body;
iovec.iov_len = sizeof (body);
hdr.msg_iov = &iovec;
hdr.msg_iovlen = 1;
hdr.msg_control = ctrl;
hdr.msg_controllen = sizeof (ctrl);
rc = nn_recvmsg (rep, &hdr, 0);
errno_assert (rc == 3);
cmsg = NN_CMSG_FIRSTHDR (&hdr);
while (1) {
nn_assert (cmsg);
if (cmsg->cmsg_level == PROTO_SP && cmsg->cmsg_type == SP_HDR)
break;
cmsg = NN_CMSG_NXTHDR (&hdr, cmsg);
}
nn_assert (cmsg->cmsg_len == NN_CMSG_SPACE (8));
data = NN_CMSG_DATA (cmsg);
nn_assert (!(data[0] & 0x80));
nn_assert (data[4] & 0x80);
rc = nn_sendmsg (rep, &hdr, 0);
nn_assert (rc == 3);
test_recv (req, "ABC");
/* Test ancillary data in dynamically allocated buffer (NN_MSG). */
test_send (req, "ABC");
iovec.iov_base = body;
iovec.iov_len = sizeof (body);
hdr.msg_iov = &iovec;
hdr.msg_iovlen = 1;
hdr.msg_control = &buf;
hdr.msg_controllen = NN_MSG;
rc = nn_recvmsg (rep, &hdr, 0);
errno_assert (rc == 3);
cmsg = NN_CMSG_FIRSTHDR (&hdr);
while (1) {
nn_assert (cmsg);
if (cmsg->cmsg_level == PROTO_SP && cmsg->cmsg_type == SP_HDR)
break;
cmsg = NN_CMSG_NXTHDR (&hdr, cmsg);
}
nn_assert (cmsg->cmsg_len == NN_CMSG_SPACE (8));
data = NN_CMSG_DATA (cmsg);
nn_assert (!(data[0] & 0x80));
nn_assert (data[4] & 0x80);
rc = nn_sendmsg (rep, &hdr, 0);
nn_assert (rc == 3);
test_recv (req, "ABC");
test_close (req);
test_close (rep);
return 0;
}
int main ()
{
int rc;
int sb;
int sc;
int s1, s2;
int i;
char buf [256];
int val;
struct nn_msghdr hdr;
struct nn_iovec iovec;
unsigned char body [3];
void *control;
struct nn_cmsghdr *cmsg;
unsigned char *data;
/* Create a simple topology. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
/* Try a duplicate bind. It should fail. */
rc = nn_bind (sc, SOCKET_ADDRESS);
nn_assert (rc < 0 && errno == EADDRINUSE);
/* Ping-pong test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "ABC");
test_recv (sb, "ABC");
test_send (sb, "DEFG");
test_recv (sc, "DEFG");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "XYZ");
}
test_close (sc);
test_close (sb);
/* Test whether queue limits are observed. */
sb = test_socket (AF_SP, NN_PAIR);
val = 200;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVBUF, &val, sizeof (val));
errno_assert (rc == 0);
test_bind (sb, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
val = 200;
rc = nn_setsockopt (sc, NN_SOL_SOCKET, NN_SNDTIMEO, &val, sizeof (val));
errno_assert (rc == 0);
i = 0;
while (1) {
rc = nn_send (sc, "0123456789", 10, 0);
if (rc < 0 && nn_errno () == EAGAIN)
break;
errno_assert (rc >= 0);
nn_assert (rc == 10);
++i;
}
nn_assert (i == 20);
test_recv (sb, "0123456789");
test_send (sc, "0123456789");
rc = nn_send (sc, "0123456789", 10, 0);
nn_assert (rc < 0 && nn_errno () == EAGAIN);
for (i = 0; i != 20; ++i) {
test_recv (sb, "0123456789");
}
/* Make sure that even a message that doesn't fit into the buffers
gets across. */
for (i = 0; i != sizeof (buf); ++i)
buf [i] = 'A';
rc = nn_send (sc, buf, 256, 0);
errno_assert (rc >= 0);
nn_assert (rc == 256);
rc = nn_recv (sb, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 256);
test_close (sc);
test_close (sb);
#if 0
/* Test whether connection rejection is handled decently. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, SOCKET_ADDRESS);
s2 = test_socket (AF_SP, NN_PAIR);
test_connect (s2, SOCKET_ADDRESS);
nn_sleep (100);
test_close (s2);
test_close (s1);
test_close (sb);
#endif
/* Check whether SP message header is transferred correctly. */
sb = test_socket (AF_SP_RAW, NN_REP);
test_bind (sb, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_REQ);
test_connect (sc, SOCKET_ADDRESS);
test_send (sc, "ABC");
iovec.iov_base = body;
iovec.iov_len = sizeof (body);
hdr.msg_iov = &iovec;
hdr.msg_iovlen = 1;
hdr.msg_control = &control;
hdr.msg_controllen = NN_MSG;
rc = nn_recvmsg (sb, &hdr, 0);
errno_assert (rc == 3);
cmsg = NN_CMSG_FIRSTHDR (&hdr);
while (1) {
nn_assert (cmsg);
if (cmsg->cmsg_level == PROTO_SP && cmsg->cmsg_type == SP_HDR)
break;
cmsg = NN_CMSG_NXTHDR (&hdr, cmsg);
}
nn_assert (cmsg->cmsg_len == NN_CMSG_SPACE (8));
data = NN_CMSG_DATA (cmsg);
nn_assert (!(data[0] & 0x80));
nn_assert (data[4] & 0x80);
nn_freemsg (control);
test_close (sc);
test_close (sb);
/* Test binding a new socket after originally bound socket shuts down. */
sb = test_socket (AF_SP, NN_BUS);
test_bind (sb, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_BUS);
test_connect (sc, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_BUS);
test_connect (s1, SOCKET_ADDRESS);
/* Close bound socket, leaving connected sockets connect. */
test_close (sb);
nn_sleep (100);
/* Rebind a new socket to the address to which our connected sockets are listening. */
s2 = test_socket (AF_SP, NN_BUS);
test_bind (s2, SOCKET_ADDRESS);
/* Ping-pong test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "ABC");
test_send (s1, "QRS");
test_recv (s2, "ABC");
test_recv (s2, "QRS");
test_send (s2, "DEFG");
test_recv (sc, "DEFG");
test_recv (s1, "DEFG");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_recv (s2, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_send (s1, "MNO");
}
for (i = 0; i != 100; ++i) {
test_recv (s2, "MNO");
}
test_close (s1);
test_close (sc);
test_close (s2);
return 0;
}
int nn_recvmsg (int s, struct nn_msghdr *msghdr, int flags)
{
int rc;
struct nn_msg msg;
uint8_t *data;
size_t sz;
int i;
struct nn_iovec *iov;
void *chunk;
size_t hdrssz;
void *ctrl;
size_t ctrlsz;
size_t spsz;
size_t sptotalsz;
struct nn_cmsghdr *chdr;
struct nn_sock *sock;
rc = nn_global_hold_socket (&sock, s);
if (nn_slow (rc < 0)) {
errno = -rc;
return -1;
}
if (nn_slow (!msghdr)) {
rc = -EINVAL;
goto fail;
}
if (nn_slow (msghdr->msg_iovlen < 0)) {
rc = -EMSGSIZE;
goto fail;
}
/* Get a message. */
rc = nn_sock_recv (sock, &msg, flags);
if (nn_slow (rc < 0)) {
goto fail;
}
if (msghdr->msg_iovlen == 1 && msghdr->msg_iov [0].iov_len == NN_MSG) {
chunk = nn_chunkref_getchunk (&msg.body);
*(void**) (msghdr->msg_iov [0].iov_base) = chunk;
sz = nn_chunk_size (chunk);
}
else {
/* Copy the message content into the supplied gather array. */
data = nn_chunkref_data (&msg.body);
sz = nn_chunkref_size (&msg.body);
for (i = 0; i != msghdr->msg_iovlen; ++i) {
iov = &msghdr->msg_iov [i];
if (nn_slow (iov->iov_len == NN_MSG)) {
nn_msg_term (&msg);
rc = -EINVAL;
goto fail;
}
if (iov->iov_len > sz) {
memcpy (iov->iov_base, data, sz);
break;
}
memcpy (iov->iov_base, data, iov->iov_len);
data += iov->iov_len;
sz -= iov->iov_len;
}
sz = nn_chunkref_size (&msg.body);
}
/* Retrieve the ancillary data from the message. */
if (msghdr->msg_control) {
spsz = nn_chunkref_size (&msg.sphdr);
sptotalsz = NN_CMSG_SPACE (spsz+sizeof (size_t));
ctrlsz = sptotalsz + nn_chunkref_size (&msg.hdrs);
if (msghdr->msg_controllen == NN_MSG) {
/* Allocate the buffer. */
rc = nn_chunk_alloc (ctrlsz, 0, &ctrl);
errnum_assert (rc == 0, -rc);
/* Set output parameters. */
*((void**) msghdr->msg_control) = ctrl;
}
else {
/* Just use the buffer supplied by the user. */
ctrl = msghdr->msg_control;
ctrlsz = msghdr->msg_controllen;
}
/* If SP header alone won't fit into the buffer, return no ancillary
properties. */
if (ctrlsz >= sptotalsz) {
char *ptr;
/* Fill in SP_HDR ancillary property. */
chdr = (struct nn_cmsghdr*) ctrl;
chdr->cmsg_len = sptotalsz;
chdr->cmsg_level = PROTO_SP;
chdr->cmsg_type = SP_HDR;
ptr = (void *)chdr;
ptr += sizeof (*chdr);
*(size_t *)(void *)ptr = spsz;
ptr += sizeof (size_t);
memcpy (ptr, nn_chunkref_data (&msg.sphdr), spsz);
/* Fill in as many remaining properties as possible.
Truncate the trailing properties if necessary. */
hdrssz = nn_chunkref_size (&msg.hdrs);
if (hdrssz > ctrlsz - sptotalsz)
hdrssz = ctrlsz - sptotalsz;
memcpy (((char*) ctrl) + sptotalsz,
nn_chunkref_data (&msg.hdrs), hdrssz);
}
}
nn_msg_term (&msg);
/* Adjust the statistics. */
nn_sock_stat_increment (sock, NN_STAT_MESSAGES_RECEIVED, 1);
nn_sock_stat_increment (sock, NN_STAT_BYTES_RECEIVED, sz);
nn_global_rele_socket (sock);
return (int) sz;
fail:
nn_global_rele_socket (sock);
errno = -rc;
return -1;
}