static void *server_task(void *args)
{
thr_info *info = (thr_info *) args;
const char *bind_to = info->bind_to;
size_t msg_size = info->msg_size;
int msg_count = info->msg_count;
int perf_type = info->perf_type;
int srv_fd = nn_socket(AF_SP, NN_PAIR);
assert(srv_fd != -1);
int rc = nn_bind(srv_fd, bind_to);
assert(rc >= 0);
int req_count = 0;
size_t nbytes;
while (true) {
char *buf = (char *) malloc(msg_size + 1);
nbytes = nn_recv(srv_fd, buf, msg_size, 0);
assert(nbytes == (int)msg_size);
if (perf_type == LATENCY) {
nbytes = nn_send(srv_fd, buf, msg_size, 0);
assert(nbytes == (int)msg_size);
}
free(buf);
req_count++;
if (req_count == msg_count) {
nbytes = nn_send(srv_fd, "well", 5, 0);
}
}
return NULL;
}
static void server(NN_UNUSED void *arg)
{
int bytes;
int count;
int sock = nn_socket(AF_SP, NN_PULL);
int res[TEST_LOOPS];
nn_assert(sock >= 0);
nn_assert(nn_bind(sock, SOCKET_ADDRESS) >= 0);
count = THREAD_COUNT * TEST_LOOPS;
memset(res, 0, sizeof (res));
while (count > 0)
{
char *buf = NULL;
int tid;
int num;
bytes = nn_recv(sock, &buf, NN_MSG, 0);
nn_assert(bytes >= 0);
nn_assert(bytes >= 2);
nn_assert(buf[0] >= 'A' && buf[0] <= 'Z');
nn_assert(buf[1] >= 'a' && buf[0] <= 'z');
tid = buf[0]-'A';
num = buf[1]-'a';
nn_assert(tid < THREAD_COUNT);
nn_assert(res[tid] == num);
res[tid]=num+1;
nn_freemsg(buf);
count--;
}
nn_close(sock);
}
int node (const int argc, const char **argv)
{
int sock = nn_socket (AF_SP, NN_BUS);
assert (sock >= 0);
assert (nn_bind (sock, argv[2]) >= 0);
sleep (1); // wait for connections
if (argc >= 3)
{
int x=3;
for(x; x<argc; x++)
assert (nn_connect (sock, argv[x]) >= 0);
}
sleep (1); // wait for connections
int to = 100;
assert (nn_setsockopt (sock, NN_SOL_SOCKET, NN_RCVTIMEO, &to, sizeof (to)) >= 0);
// SEND
int sz_n = strlen(argv[1]) + 1; // '\0' too
printf ("%s: SENDING '%s' ONTO BUS\n", argv[1], argv[1]);
int send = nn_send (sock, argv[1], sz_n, 0);
assert (send == sz_n);
while (1)
{
// RECV
char *buf = NULL;
int recv = nn_recv (sock, &buf, NN_MSG, 0);
if (recv >= 0)
{
printf ("%s: RECEIVED '%s' FROM BUS\n", argv[1], buf);
nn_freemsg (buf);
}
}
return nn_shutdown (sock, 0);
}
void lamb_show_client(int sock, int id) {
/*
printf("id | account | company | queue | concurrent\n");
printf("--------------------------------------------\n");
printf("%d a10001 2 25461 1000/s\n", id++);
printf("%d a10002 2 2461 2000/s\n", id++);
printf("%d a10003 2 5461 5000/s\n", id++);
printf("%d a10004 2 15461 1000/s\n", id++);
printf("%d a10005 2 461 500/s\n", id++);
*/
int rc;
char *cmd = "show client 12";
char res[4096];
rc = nn_send(sock, cmd, strlen(cmd), 0);
if (rc < 0) {
fprintf(stderr, "nn_send: %s (ignoring)\n", nn_strerror(nn_errno()));
return;
}
memset(res, 0, sizeof(res));
rc = nn_recv (sock, res, sizeof(res), NN_DONTWAIT);
if (rc < 0) {
fprintf(stderr, "nn_recv: %s\n", nn_strerror(nn_errno()));
return;
}
printf("\%s", res);
return;
}
int node0(const char *url)
{
int sz_date = strlen(DATE) + 1;
int sock = nn_socket(AF_SP, NN_REP);
assert(sock >= 0);
assert(nn_bind(sock, url) >= 0);
while (1) {
char *buf = NULL;
int bytes = nn_recv(sock, &buf, NN_MSG, 0);
assert(bytes >= 0);
if (strncmp(DATE, buf, sz_date) == 0) {
printf("NODE0: RECEIVED DATE REQUEST\n");
char *d = date();
int sz_d = strlen(d) + 1;
printf("NODE0: SENDING DATE %s\n", d);
bytes = nn_send(sock, d, sz_d, 0);
assert(bytes == sz_d);
}
nn_freemsg (buf);
}
return nn_shutdown (sock, 0);
}
void receive_ctxt(int socket, const FHEPubKey &pk,
std::vector<Ctxt> &ctxts) {
std::stringstream sstream;
MDL::Timer timer;
char *buf;
nn_recv(socket, &buf, NN_MSG, 0); // recv lens
nn_send(socket, NULL, 0, 0); // send ok
MDL::net::msg_header *hdr = (MDL::net::msg_header *)buf;
std::vector<size_t> lens(hdr->msg_ele_sze,
hdr->msg_ele_sze + hdr->msg_ele_nr);
printf("vec size %zd\n", lens.size());
timer.start();
struct nn_msghdr nn_hdr;
MDL::net::make_nn_header(&nn_hdr, lens);
printf("%zd\n", nn_hdr.msg_iovlen);
nn_recvmsg(socket, &nn_hdr, 0); // recv data
timer.end();
Ctxt c(pk);
for (size_t i = 0; i < nn_hdr.msg_iovlen; i++) {
sstream.str((char *)nn_hdr.msg_iov[i].iov_base);
sstream >> c;
ctxts.push_back(c);
}
nn_freemsg(buf);
nn_send(socket, NULL, 0, 0);
printf("receive %zd ciphers %fs\n", ctxts.size(), timer.second());
}
NanoMessage NanoSocket::Recv() throw()
{
char *buf = NULL;
int size = nn_recv (m_socket, &buf, NN_MSG, 0);
if (size < 0)
{
throw NanoException{};
}
std::stringstream compressed;
compressed.write(buf, size);
nn_freemsg (buf);
ios::filtering_streambuf<ios::input> decompressor;
decompressor.push(ios::zlib_decompressor());
decompressor.push(compressed);
std::stringstream decompressed;
ios::copy(decompressor, decompressed);
NanoMessage nm = NanoMessage::LoadMessage(decompressed.str());
std::cout << "Socket " << m_socket << ": "
<< "got message type " << nm.header.type << std::endl;
return nm;
}
pint32 pnet_recv(pnet_socket *socket, char **buffer)
{
if (unlikely(!socket)) {
plog_error("pnet_recv() нет объекта socket");
return -1;
}
if (unlikely(!buffer)) {
plog_error("pnet_recv() buffer неверен");
return -1;
}
int bytes = nn_recv(socket->socket_fd, buffer, NN_MSG, NN_DONTWAIT);
//int bytes = nn_recvmsg(socket->socket_fd, (struct nn_msghdr *)buffer, NN_DONTWAIT);
/*
struct nn_msghdr hdr;
struct nn_iovec iov [2];
char buf0 [10] = { 0 };
char buf1 [6] = { 0 };
iov [0].iov_base = buf0;
iov [0].iov_len = sizeof (buf0);
iov [1].iov_base = buf1;
iov [1].iov_len = sizeof (buf1);
memset (&hdr, 0, sizeof (hdr));
hdr.msg_iov = iov;
hdr.msg_iovlen = 2;
int bytes = nn_recvmsg(socket->socket_fd, &hdr, NN_DONTWAIT);
printf("%d | %s | %s\n", bytes, buf0, buf1);
*buffer = strdup(buf0);
*/
return bytes;
}
int main(void) {
int sock1 = sock_bind("tcp://127.0.0.1:9991");
int sock2 = sock_bind("tcp://127.0.0.1:9992");
int sockfd1 = get_rec_sockfd(sock1);
int sockfd2 = get_rec_sockfd(sock2);
sock_info sockinfo[] = {
{sock1, sockfd1},
{sock2, sockfd2}
};
printf("sock1: %d - sockfd1: %d\n", sock1, sockfd1);
printf("sock2: %d - sockfd2: %d\n", sock2, sockfd2);
fd_set readfds;
int maxfds = sockfd2;
int select_rc;
char *buf = NULL;
int i, j;
int go = 1;
for(;;) {
go = 1;
FD_ZERO(&readfds);
FD_SET(sockfd1, &readfds);
FD_SET(sockfd2, &readfds);
printf("inside loop\n");
select_rc = select(maxfds+1, &readfds, NULL, NULL, NULL);
printf("select was returned with: %d\n", select_rc);
for(i = 0; i <= maxfds && go; i++) {
if(FD_ISSET(i, &readfds)) {
printf("is set: %d\n", i);
for(j = 0; j < 2 && go; j++) {
if(sockinfo[j].sock_fd == i) {
nn_recv(sockinfo[j].sock_sp, &buf, NN_MSG, 0);
printf("recevied msg: %s\n", buf);
go = 0;
}
}
}
}
printf("for-done!\n");
}
return 0;
}
static void client_task(void *args, zctx_t *ctx, void *pipe)
{
thr_info *info = (thr_info *) args;
const char *connect = info->bind_to;
size_t msg_size = info->msg_size;
int msg_count = info->msg_count;
int perf_type = info->perf_type;
char *buf = (char *) malloc(msg_size);
memset(buf, 'a', msg_size-1);
buf[msg_size] = '\0';
int client_fd = nn_socket(AF_SP, NN_PAIR);
assert(client_fd != -1);
int opt = 1;
int rc = nn_setsockopt(client_fd, NN_TCP, NN_TCP_NODELAY, &opt, sizeof(opt));
assert(rc == 0);
rc = nn_connect(client_fd, connect);
assert(rc >= 0);
int i;
INT64 start_ts, end_ts;
get_timestamp(&start_ts);
for (i = 0; i < msg_count; i++) {
int nbytes = nn_send(client_fd, buf, msg_size, 0);
assert(nbytes == (int)msg_size);
if (perf_type == LATENCY) {
nbytes = nn_recv(client_fd, buf, msg_size, 0);
assert(nbytes == (int)msg_size);
}
}
buf = (char *) malloc(64);
nn_recv(client_fd, buf, 64, 0);
assert(strcmp(buf, "well") == 0);
free(buf);
get_timestamp(&end_ts);
if (perf_type == THROUGHPUT) {
cal_thr(msg_size, msg_count, end_ts - start_ts);
} else if (perf_type == LATENCY) {
cal_latency(msg_size, msg_count, end_ts - start_ts);
}
zstr_send(pipe, "done");
}
int main (int argc, char *argv [])
{
const char *connect_to;
size_t sz;
int rts;
char *buf;
int nbytes;
int s;
int rc;
int i;
int opt;
struct nn_stopwatch sw;
uint64_t total;
double lat;
if (argc != 4) {
printf ("usage: remote_lat <connect-to> <msg-size> <roundtrips>\n");
return 1;
}
connect_to = argv [1];
sz = atoi (argv [2]);
rts = atoi (argv [3]);
s = nn_socket (AF_SP, NN_PAIR);
assert (s != -1);
opt = 1;
rc = nn_setsockopt (s, NN_TCP, NN_TCP_NODELAY, &opt, sizeof (opt));
assert (rc == 0);
rc = nn_connect (s, connect_to);
assert (rc >= 0);
buf = malloc (sz);
assert (buf);
memset (buf, 111, sz);
nn_stopwatch_init (&sw);
for (i = 0; i != rts; i++) {
nbytes = nn_send (s, buf, sz, 0);
assert (nbytes == (int)sz);
nbytes = nn_recv (s, buf, sz, 0);
assert (nbytes == (int)sz);
}
total = nn_stopwatch_term (&sw);
lat = (double) total / (rts * 2);
printf ("message size: %d [B]\n", (int) sz);
printf ("roundtrip count: %d\n", (int) rts);
printf ("average latency: %.3f [us]\n", (double) lat);
free (buf);
rc = nn_close (s);
assert (rc == 0);
return 0;
}
int main ()
{
int rc;
int sink;
int source1;
int source2;
char buf [3];
sink = nn_socket (AF_SP, NN_SINK);
errno_assert (sink != -1);
rc = nn_bind (sink, SOCKET_ADDRESS);
errno_assert (rc >= 0);
source1 = nn_socket (AF_SP, NN_SOURCE);
errno_assert (source1 != -1);
rc = nn_connect (source1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
source2 = nn_socket (AF_SP, NN_SOURCE);
errno_assert (source2 != -1);
rc = nn_connect (source2, SOCKET_ADDRESS);
errno_assert (rc >= 0);
rc = nn_send (source1, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_send (source2, "DEF", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (sink, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (sink, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_close (sink);
errno_assert (rc == 0);
rc = nn_close (source1);
errno_assert (rc == 0);
rc = nn_close (source2);
errno_assert (rc == 0);
return 0;
}
inline int recv (void *buf, size_t len, int flags)
{
int rc = nn_recv (s, buf, len, flags);
if (nn_slow (rc < 0)) {
if (nn_slow (nn_errno () != EAGAIN))
throw nn::exception ();
return -1;
}
return rc;
}
int main (int argc, char *argv [])
{
int rc;
int s;
int i;
char *buf;
struct nn_thread thread;
struct nn_stopwatch stopwatch;
uint64_t elapsed;
double latency;
if (argc != 3) {
printf ("usage: inproc_lat <message-size> <roundtrip-count>\n");
return 1;
}
message_size = atoi (argv [1]);
roundtrip_count = atoi (argv [2]);
s = nn_socket (AF_SP, NN_PAIR);
assert (s != -1);
rc = nn_bind (s, "inproc://inproc_lat");
assert (rc >= 0);
buf = malloc (message_size);
assert (buf);
memset (buf, 111, message_size);
/* Wait a bit till the worker thread blocks in nn_recv(). */
nn_thread_init (&thread, worker, NULL);
nn_sleep (100);
nn_stopwatch_init (&stopwatch);
for (i = 0; i != roundtrip_count; i++) {
rc = nn_send (s, buf, message_size, 0);
assert (rc == (int)message_size);
rc = nn_recv (s, buf, message_size, 0);
assert (rc == (int)message_size);
}
elapsed = nn_stopwatch_term (&stopwatch);
latency = (double) elapsed / (roundtrip_count * 2);
printf ("message size: %d [B]\n", (int) message_size);
printf ("roundtrip count: %d\n", (int) roundtrip_count);
printf ("average latency: %.3f [us]\n", (double) latency);
nn_thread_term (&thread);
free (buf);
rc = nn_close (s);
assert (rc == 0);
return 0;
}
int recv_name(int sock, const char *name)
{
char *buf = NULL;
int result = nn_recv(sock, &buf, NN_MSG, 0);
if (result > 0)
{
printf("%s: RECEIVED \"%s\"\n", name, buf);
nn_freemsg(buf);
}
return result;
}
static void worker (NN_UNUSED void *arg)
{
int rc;
int s;
char buf [3];
/* Test socket. */
s = test_socket (AF_SP, NN_PAIR);
/* Launch blocking function to check that it will be unblocked once
nn_term() is called from the main thread. */
rc = nn_recv (s, buf, sizeof (buf), 0);
nn_assert (rc == -1 && nn_errno () == ETERM);
/* Check that all subsequent operations fail in synchronous manner. */
rc = nn_recv (s, buf, sizeof (buf), 0);
nn_assert (rc == -1 && nn_errno () == ETERM);
test_close (s);
}
/* --- server --- */
int node0(const char *url) {
int sock = nn_socket(AF_SP, NN_PULL);
assert (sock >= 0);
assert (nn_bind(sock, url) >= 0);
while(1) {
char *buf = NULL;
int bytes = nn_recv (sock, &buf, NN_MSG, 0);
assert(bytes >= 0);
printf("NODE0: RECEIVED \"%s\"\n", buf);
nn_freemsg (buf);
}
}
static void ftw_subscriber_async_recv_thread(void *arg)
{
LStrHandle msg_sent_to_lv;
struct ftw_socket *self;
void *recv_buf;
MgErr lv_err;
int socket_err;
int rc;
ftw_assert(arg);
/* Create local pointer to arguments and notify launching process this thread is constructed. */
self = ((struct ftw_socket *) arg);
nn_sem_post(&self->async_recv_ready);
lv_err = mgNoErr;
socket_err = 0;
/* This broker relays messages from the nanomsg socket into the LabVIEW incoming message queue. */
while (!lv_err && !socket_err) {
rc = nn_recv(self->id, &recv_buf, NN_MSG, 0);
if (rc < 0) {
socket_err = ((errno == ETIMEDOUT || errno == EAGAIN) ? 0 : errno);
continue;
}
msg_sent_to_lv = (LStrHandle)DSNewHandle(rc);
lv_err = ftw_support_buffer_to_LStrHandle(&msg_sent_to_lv, recv_buf, rc);
if (lv_err)
continue;
/* On the LabVIEW side, the handler is a an event registration, meaning
LabVIEW will not effectively apply backpressure to the Publisher socket.
For this reason, care must be taken that the Subscriber keep up with
the Publisher, yet this consideration has long-existed for the LabVIEW
developer (since, LV-native primitives will likewise cause a memory leak,
when Event Registrations are allowed to grow without bound). */
lv_err = PostLVUserEvent(self->incoming_msg_notifier_event, &msg_sent_to_lv);
if (lv_err)
continue;
lv_err = DSDisposeHandle (msg_sent_to_lv);
rc = nn_freemsg(recv_buf);
if (rc) {
socket_err = errno;
continue;
}
}
return;
}
void receive_pk(int socket, FHEPubKey &pk) {
char *buf;
int read;
if ((read = nn_recv(socket, &buf, NN_MSG, 0)) < 0) {
printf("receive pk error %s\n", nn_strerror(errno));
exit(-1);
}
std::stringstream sstream;
sstream.str(buf);
sstream >> pk;
nn_freemsg(buf);
}
JNIEXPORT jstring JNICALL Java_org_nanomsg_NanoLibrary_nn_1recvstr(JNIEnv* env,
jobject obj,
jint socket,
jint flags)
{
void *buf;
int ret = nn_recv(socket, &buf, NN_MSG, flags);
if (ret < 0) return 0;
jstring retst = (*env)->NewStringUTF(env, buf);
nn_freemsg(buf);
return retst;
}
JNIEXPORT jbyteArray JNICALL Java_org_nanomsg_NanoLibrary_nn_1recvbyte(JNIEnv* env,
jobject obj,
jint socket,
jint flags)
{
void *buf;
int ret = nn_recv(socket, &buf, NN_MSG, flags);
if (ret < 0) return 0;
jbyteArray result = (*env)->NewByteArray(env, ret);
(*env)->SetByteArrayRegion(env, result, 0, ret, (const jbyte*) buf);
nn_freemsg(buf);
return result;
}
int node (const int argc, const char **argv)
{
int sock = nn_socket (AF_SP, NN_BUS);
int sock_fd, efd, nfds;
struct epoll_event event, events[MAX_EVENTS];
size_t sz = sizeof(sock_fd);
nn_getsockopt(sock, NN_SOL_SOCKET, NN_RCVFD, &sock_fd, &sz);
assert(sock >= 0);
assert(nn_bind (sock, argv[2]) >= 0);
sleep (1); // wait for connections
if (argc >= 3) {
int x;
for(x = 3; x < argc; x++)
assert(nn_connect(sock, argv[x]) >= 0);
}
efd = epoll_create(MAX_EVENTS);
assert(efd != -1);
event.data.fd = sock_fd;
event.events = EPOLLIN;
assert(epoll_ctl(efd, EPOLL_CTL_ADD, sock_fd, &event) != -1);
// wait for connections
sleep(1);
int to = 100;
assert(nn_setsockopt (sock, NN_SOL_SOCKET, NN_RCVTIMEO, &to, sizeof(to)) >= 0);
// SEND
int sz_n = strlen(argv[1]) + 1; // '\0' too
printf ("%s: SENDING '%s' ONTO BUS\n", argv[1], argv[1]);
int send = nn_send (sock, argv[1], sz_n, 0);
assert (send == sz_n);
for(;;) {
nfds = epoll_wait(efd, events, MAX_EVENTS, -1);
assert(nfds != -1);
int n, recv;
for (n = 0; n < nfds; ++n) {
if (events[n].data.fd == sock_fd) {
char *buf = NULL;
recv = nn_recv(sock, &buf, NN_MSG, 0);
if (recv >= 0) {
printf ("%s: RECEIVED '%s' FROM BUS\n", argv[1], buf);
nn_freemsg (buf);
}
}
}
}
return nn_shutdown (sock, 0);
}
void process_json(cJSON *json,char *remoteaddr,int32_t localaccess)
{
int32_t sock,len,checklen,sendtimeout,recvtimeout; uint32_t apitag; uint64_t tag;
char endpoint[128],numstr[64],*resultstr,*jsonstr;
jsonstr = cJSON_Print(json), _stripwhite(jsonstr,' ');
len = (int32_t)strlen(jsonstr)+1;
apitag = _crc32(0,jsonstr,len);
sprintf(endpoint,"ipc://api.%u",apitag);
free(jsonstr);
if ( (recvtimeout= juint(json,"timeout")) == 0 )
recvtimeout = 30000;
sendtimeout = 30000;
randombytes((uint8_t *)&tag,sizeof(tag));
if ( cJSON_GetObjectItem(json,"tag") == 0 )
sprintf(numstr,"%llu",(long long)tag), cJSON_AddItemToObject(json,"tag",cJSON_CreateString(numstr));
if ( cJSON_GetObjectItem(json,"apitag") == 0 )
cJSON_AddItemToObject(json,"apitag",cJSON_CreateString(endpoint));
if ( remoteaddr != 0 )
cJSON_AddItemToObject(json,"broadcast",cJSON_CreateString("remoteaccess"));
if ( localaccess != 0 )
cJSON_AddItemToObject(json,"localaccess",cJSON_CreateNumber(1));
jsonstr = cJSON_Print(json), _stripwhite(jsonstr,' ');
//fprintf(stderr,"localacess.%d remote.(%s) jsonstr.(%s)\r\n",localaccess,remoteaddr!=0?remoteaddr:"",jsonstr);
len = (int32_t)strlen(jsonstr)+1;
if ( jsonstr != 0 )
{
if ( (sock= nn_socket(AF_SP,NN_PAIR)) >= 0 )
{
if ( sendtimeout > 0 && nn_setsockopt(sock,NN_SOL_SOCKET,NN_SNDTIMEO,&sendtimeout,sizeof(sendtimeout)) < 0 )
fprintf(stderr,"error setting sendtimeout %s\n",nn_errstr());
if ( nn_connect(sock,SUPERNET_APIENDPOINT) < 0 )
printf("error connecting to apiendpoint sock.%d type.%d (%s) %s\r\n",sock,NN_PUSH,SUPERNET_APIENDPOINT,nn_errstr());
else if ( (checklen= nn_send(sock,jsonstr,len,0)) != len )
printf("checklen.%d != len.%d for nn_send to (%s)\r\n",checklen,len,SUPERNET_APIENDPOINT);
else
{
if ( recvtimeout > 0 && nn_setsockopt(sock,NN_SOL_SOCKET,NN_RCVTIMEO,&recvtimeout,sizeof(recvtimeout)) < 0 )
fprintf(stderr,"error setting sendtimeout %s\n",nn_errstr());
if ( nn_recv(sock,&resultstr,NN_MSG,0) > 0 )
{
printf("Content-Length: %ld\r\n\r\n",strlen(resultstr)+2);
printf("%s\r\n",resultstr);
nn_freemsg(resultstr);
} else printf("error getting results %s\r\n",nn_errstr());
}
nn_shutdown(sock,0);
} else printf("error getting pushsock.%s\r\n",nn_errstr());
}
free(jsonstr);
}
/* The client runs just once, and then returns. */
int client (const char *url, const char *username)
{
int fd;
int rc;
char *greeting;
char *msg;
fd = nn_socket (AF_SP, NN_REQ);
if (fd < 0) {
fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
return (-1);
}
if (nn_connect (fd, url) < 0) {
fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
nn_close (fd);
return (-1);
}
usleep(1000);
if (nn_send (fd, username, strlen (username), 0) < 0) {
fprintf (stderr, "nn_send: %s\n", nn_strerror (nn_errno ()));
nn_close (fd);
return (-1);
}
/* Here we ask the library to allocate response buffer for us (NN_MSG). */
rc = nn_recv (fd, &msg, NN_MSG, 0);
if (rc < 0) {
fprintf (stderr, "nn_recv: %s\n", nn_strerror (nn_errno ()));
nn_close (fd);
return (-1);
}
nn_close (fd);
/* Response is not ASCIIZ terminated. */
greeting = calloc (rc + 1, 1);
if (greeting == NULL) {
fprintf (stderr, "calloc: %s\n", strerror (errno));
return (-1);
}
memcpy(greeting, msg, rc);
nn_freemsg (msg);
printf ("%s\n", greeting);
free (greeting);
return (0);
}
JNIEXPORT jint JNICALL Java_org_nanomsg_NanoLibrary_nn_1recv(JNIEnv* env,
jobject obj,
jint socket,
jobject buffer,
jint offset,
jint length,
jint flags)
{
jbyte* cbuf = 0;
jint ret = 0;
cbuf = (jbyte*) (*env)->GetDirectBufferAddress(env, buffer);
NANO_ASSERT(cbuf);
ret = nn_recv(socket, cbuf + offset, length, flags);
return ret;
}
int client (const char *url, const char *name)
{
int sock = nn_socket (AF_SP, NN_SUB);
assert (sock >= 0);
// TODO learn more about publishing/subscribe keys
assert (nn_setsockopt (sock, NN_SUB, NN_SUB_SUBSCRIBE, "", 0) >= 0);
assert (nn_connect (sock, url) >= 0);
while (1)
{
char *buf = NULL;
int bytes = nn_recv (sock, &buf, NN_MSG, 0);
assert (bytes >= 0);
printf ("CLIENT (%s): RECEIVED %s\n", name, buf);
nn_freemsg (buf);
}
return nn_shutdown (sock, 0);
}
int main ()
{
int rc;
int sb;
int sc;
int i;
char buf [4];
int opt;
size_t sz;
char msg[256];
char* pRecvd = 0;
// client, running on windows
sc = nn_socket (AF_SP, NN_PAIR);
errno_assert (sc >= 0);
// connect
rc = nn_connect (sc, SOCKET_ADDRESS);
errno_assert (rc > 0);
// send
memcpy(buf, "WHY\0", 4);
rc = nn_send (sc, buf, 3, 0);
printf("client: I sent '%s'\n", buf);
errno_assert (rc >= 0);
nn_assert (rc == 3);
// receive
rc = nn_recv (sc, &pRecvd, NN_MSG, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
sprintf(msg, "client: I received: '%s'\n\0", buf);
printf(msg);
// free
rc = nn_freemsg(pRecvd);
errno_assert (rc == 0);
// close
rc = nn_close (sc);
errno_assert (rc == 0);
return 0;
}
static sk_sp<SkPicture> recv_picture(int socket, PictureHeader* header) {
static const size_t hSize = sizeof(*header); // It's easy to slip up and use sizeof(header).
void* msg;
int size = nn_recv(socket, &msg, NN_MSG, 0/*flags*/);
SkDebugf("%d bytes", size);
// msg is first a fixed-size header, then an .skp.
memcpy(header, msg, hSize);
SkMemoryStream stream((uint8_t*)msg + hSize, size - hSize);
sk_sp<SkPicture> pic = SkPicture::MakeFromStream(&stream);
SkDebugf(" from proccess %d:", header->pid);
nn_freemsg(msg);
return pic;
}
int node1 (const char *url)
{
int sz_date = strlen(DATE) + 1; // '\0' too
char *buf = NULL;
int bytes = -1;
int sock = nn_socket (AF_SP, NN_REQ);
assert (sock >= 0);
assert (nn_connect (sock, url) >= 0);
printf ("NODE1: SENDING DATE REQUEST %s\n", DATE);
bytes = nn_send (sock, DATE, sz_date, 0);
assert (bytes == sz_date);
bytes = nn_recv (sock, &buf, NN_MSG, 0);
assert (bytes >= 0);
printf ("NODE1: RECEIVED DATE %s\n", buf);
nn_freemsg (buf);
return nn_shutdown (sock, 0);
}
int main(void)
{
printf("what: %d\n", ENOPROTOOPT);
printf("worker started\n");
int max_sz = -1;
int rsnd = 2000000000;
int router = nn_socket(AF_SP, NN_REQ);
nn_setsockopt(router, NN_SOL_SOCKET, NN_RCVMAXSIZE, &max_sz, sizeof(max_sz));
int optres = nn_setsockopt(router, NN_REQ, NN_REQ_RESEND_IVL, &rsnd, sizeof(rsnd));
printf("whats this: %d\n", optres);
assert(optres==0);
nn_connect(router, WORKERROUTER);
size_t nbytes;
char *buf = NULL;
char *greeting = "hey, another worker is here!";
nn_send(router, greeting, strlen(greeting), 0);
while(1){
nbytes = nn_recv(router, &buf, NN_MSG, 0);
char *uuid = malloc(sizeof(char)*37);
memcpy((void*)uuid,(const void*)buf,36);
uuid[36]='\0';
char *tevs = malloc(100);
sprintf(tevs, "tmp/%s",uuid);
FILE *file = fopen(tevs, "wb");
fwrite(buf+36, sizeof(char), nbytes-36, file);
fclose(file);
nn_freemsg(buf);
printf("got work for id: %s\n",uuid);
slice *result = forkorsomething(uuid);
printf("work %s done, reporting\n", uuid);
nn_send(router, result->bytes, result->len+1, 0);
free_slice(result);
printf("report sent\n");
}
}
