コード例 #1
0
ファイル: server.c プロジェクト: RPI-HPC/cq
static void send_response(void *sock, int internal_status, int exit_status)
{
	void *buf;
	int len;

	CqRep rep = CQ_REP__INIT;
	zmq_msg_t msg;
	zmq_msg_init(&msg);

	rep.exit_status = exit_status;
	rep.internal_status = internal_status;

	len = cq_rep__get_packed_size(&rep);
	buf = malloc(len);
	cq_rep__pack(&rep, buf);

	zmq_msg_init_data(&msg, buf, len, free_buf, NULL);

	zmq_msg_send(&msg, sock, 0);

	zmq_msg_close(&msg);
}
コード例 #2
0
ファイル: Socket.cpp プロジェクト: hawkproject/hawksource
/**
 * Issue a read on the socket.
 */
static zmq_msg_t* do_read(JNIEnv *env, jobject obj, zmq_msg_t *message, int flags)
{
    void *s = get_socket (env, obj);

    int rc = zmq_msg_init (message);
    if (rc != 0) {
        raise_exception (env, zmq_errno());
        return NULL;
    }

#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,0,0)
    rc = zmq_recvmsg (s, message, flags);
#else
    rc = zmq_recv (s, message, flags);
#endif
    int err = zmq_errno();
    if (rc < 0 && err == EAGAIN) {
        rc = zmq_msg_close (message);
        err = zmq_errno();
        if (rc != 0) {
            raise_exception (env, err);
            return NULL;
        }
        return NULL;
    }

    if (rc < 0) {
        raise_exception (env, err);
        rc = zmq_msg_close (message);
        err = zmq_errno();
        if (rc != 0) {
            raise_exception (env, err);
            return NULL;
        }
        return NULL;
    }
    
    return message;
}
コード例 #3
0
ファイル: handler.c プロジェクト: derdewey/mongrel2
static inline int handler_recv_parse(Handler *handler, HandlerParser *parser)
{
    check(handler->running, "Called while handler wasn't running, that's not good.");

    zmq_msg_t *inmsg = calloc(sizeof(zmq_msg_t), 1);
    int rc = 0;

    check_mem(inmsg);

    rc = zmq_msg_init(inmsg);
    check(rc == 0, "Failed to initialize message.");

    taskstate("recv");

    rc = mqrecv(handler->recv_socket, inmsg, ZMQ_NOBLOCK);
    check(rc == 0, "Receive on handler socket failed.");
    check(handler->running, "Received shutdown notification, goodbye.");

    rc = HandlerParser_execute(parser, zmq_msg_data(inmsg), zmq_msg_size(inmsg));
    check(rc == 1, "Failed to parse message from handler.");

    check(parser->target_count > 0, "Message sent had 0 targets: %.*s",
            (int)zmq_msg_size(inmsg), (char *)zmq_msg_data(inmsg));

    debug("Parsed message with %d targets, first: %d, uuid: %s, and body: %d",
            (int)parser->target_count, parser->targets[0],
            bdata(parser->uuid), blength(parser->body));

    zmq_msg_close(inmsg);
    free(inmsg);
    return 0;

error:
    if(inmsg) {
        zmq_msg_close(inmsg);
        free(inmsg);
    }
    return -1;
}
コード例 #4
0
ファイル: zmq_a.c プロジェクト: braman/sessc
int main(int argc, char *argv[])
{
    if (argc < 3) return EXIT_FAILURE;
    int M = atoi(argv[1]);
    int N = atoi(argv[2]);
    printf("M: %d, N: %d\n", M, N);

    void *ctx = zmq_init(1);
    void *b = zmq_socket(ctx, ZMQ_PAIR);
    zmq_connect(b, "tcp://localhost:4444");

    zmq_msg_t msg;
    int val[M];
    long long start_time = sc_time();

    int i;
    for (i=0; i<N; i++) {
        int *buf = (int *)malloc(M * sizeof(int));
        memset(val, i, M * sizeof(int));
        memcpy(buf, val, M * sizeof(int));
        zmq_msg_init_data(&msg, buf, M * sizeof(int), _dealloc, NULL);
        zmq_send(b, &msg, 0);
        zmq_msg_close(&msg);

        zmq_msg_init(&msg);
        zmq_recv(b, &msg, 0);
        memcpy(val, (int *)zmq_msg_data(&msg), zmq_msg_size(&msg));
        zmq_msg_close(&msg);
    }

    long long end_time = sc_time();

    printf("zmq_a: Time elapsed: %f sec\n", sc_time_diff(start_time, end_time));

    zmq_close(b);
    zmq_term(ctx);

    return EXIT_SUCCESS;
}
コード例 #5
0
ファイル: pair.cpp プロジェクト: Strongc/playasa
int zmq::pair_t::xsend (zmq_msg_t *msg_, int flags_)
{
    if (outpipe == NULL || !outpipe_alive) {
        errno = EAGAIN;
        return -1;
    }

    if (!outpipe->write (msg_)) {
        outpipe_alive = false;
        errno = EAGAIN;
        return -1;
    }

    if (!(flags_ & ZMQ_SNDMORE))
        outpipe->flush ();

    //  Detach the original message from the data buffer.
    int rc = zmq_msg_init (msg_);
    zmq_assert (rc == 0);

    return 0;
}
コード例 #6
0
ファイル: test_stream_empty.cpp プロジェクト: AimuTran/avbot
int main (void) {
    setup_test_environment ();
    void *ctx = zmq_ctx_new ();
    assert (ctx);
    
    void *stream = zmq_socket (ctx, ZMQ_STREAM);
    assert (stream);
    void *dealer = zmq_socket (ctx, ZMQ_DEALER);
    assert (dealer);
    
    int rc = zmq_bind (stream, "tcp://127.0.0.1:5555");
    assert (rc >= 0);
    rc = zmq_connect (dealer, "tcp://127.0.0.1:5555");
    assert (rc >= 0);
    zmq_send (dealer, "", 0, 0);
    
    zmq_msg_t ident, empty;
    zmq_msg_init (&ident);
    rc = zmq_msg_recv (&ident, stream, 0);
    assert (rc >= 0);
    rc = zmq_msg_init_data (&empty, (void *) "", 0, NULL, NULL);
    assert (rc >= 0);
    
    rc = zmq_msg_send (&ident, stream, ZMQ_SNDMORE);
    assert (rc >= 0);
    rc = zmq_msg_close (&ident);
    assert (rc >= 0);
    
    rc = zmq_msg_send (&empty, stream, 0);
    assert (rc >= 0);
    
    //  This close used to fail with Bad Address
    rc = zmq_msg_close (&empty);
    assert (rc >= 0);
    
    close_zero_linger (dealer);
    close_zero_linger (stream);
    zmq_ctx_term (ctx);
}
コード例 #7
0
int main (int argc, char const *argv[]) {

  void* context = zmq_ctx_new();
  //create a SUB socket
  void* subscriber = zmq_socket(context, ZMQ_SUB);

  const char* filter;
  
  if(argc > 1) {
    filter = argv[1];
  } else {
    filter = "Company1|";
  }
  printf("Collecting stock information from the server.\n");

  int conn = zmq_connect(subscriber, "tcp://localhost:4040");
  // must set a subscription for SUB socket
  conn = zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, filter, strlen(filter));

  int i = 0;
  for(i = 0; i < 10; i++) {
    zmq_msg_t reply;
    zmq_msg_init(&reply);
    // receive the message, previous message is deallocated
    zmq_msg_recv(&reply, subscriber, 0);
    
    int length = zmq_msg_size(&reply);
    char* value = malloc(length + 1);
    memcpy(value, zmq_msg_data(&reply), length);
    zmq_msg_close(&reply);
    printf("%s\n", value);    
    free(value);

  }
  zmq_close(subscriber);
  zmq_ctx_destroy(context);

  return 0;
}
コード例 #8
0
ファイル: Executor.cpp プロジェクト: ATNoG/remoteLevelDB
void Executor::work()
{
    void *socket = zmq_socket(vcontext, ZMQ_REP);
    zmq_msg_t zMsg;
    char *cstring = NULL;
    size_t msgSize = 0;
    
    zmq_connect(socket, "inproc://storageWorkers");
    
    while(vstop==false)
    {
        zmq_msg_init(&zMsg);
        zmq_msg_recv(&zMsg, socket, 0);
        msgSize = zmq_msg_size(&zMsg);
        cstring = new char[msgSize+1];
        memcpy(cstring, zmq_msg_data(&zMsg), msgSize);
        zmq_msg_close(&zMsg);
        cstring[msgSize] = '\0';
        std::string str(cstring);
        delete cstring;

        Message* msg = vmsgFactory->parse(str);

        Action *action = vactionFactory->parse(*msg);
        delete msg;

        msg = action->execute();
        delete action;

        msgSize = msg->toString().size()+1;
        zmq_msg_init_size(&zMsg, msgSize);
        memcpy(zmq_msg_data(&zMsg), msg->toString().c_str(), msgSize);
        delete msg;
        zmq_msg_send(&zMsg, socket, 0);
        zmq_msg_close(&zMsg);
    }
    zmq_close(socket);
}    
コード例 #9
0
ファイル: wuproxy.c プロジェクト: Double-Lv/zguide2
int main (void)
{
    void *context = zmq_init (1);

    //  This is where the weather server sits
    void *frontend = zmq_socket (context, ZMQ_XSUB);
    zmq_connect (frontend, "tcp://192.168.55.210:5556");

    //  This is our public endpoint for subscribers
    void *backend = zmq_socket (context, ZMQ_XPUB);
    zmq_bind (backend, "tcp://10.1.1.0:8100");

    //  Subscribe on everything
    zmq_setsockopt (frontend, ZMQ_SUBSCRIBE, "", 0);

    //  Shunt messages out to our own subscribers
    while (1) {
        while (1) {
            zmq_msg_t message;
            int64_t more;

            //  Process all parts of the message
            zmq_msg_init (&message);
            zmq_recv (frontend, &message, 0);
            size_t more_size = sizeof (more);
            zmq_getsockopt (frontend, ZMQ_RCVMORE, &more, &more_size);
            zmq_send (backend, &message, more? ZMQ_SNDMORE: 0);
            zmq_msg_close (&message);
            if (!more)
                break;      //  Last message part
        }
    }
    //  We don't actually get here but if we did, we'd shut down neatly
    zmq_close (frontend);
    zmq_close (backend);
    zmq_term (context);
    return 0;
}
コード例 #10
0
ファイル: issue.c プロジェクト: amrali/issues
// This main thread simply starts several clients, and a server, and then
// waits for the server to finish.
//
int main (void)
{
    void *context = zmq_init (1);

    // Backend socket talks to workers over inproc
    void *pipein = zmq_socket (context, ZMQ_DEALER);
    zsocket_bind (pipein, "inproc://pipe");

    // Frontend socket talks to clients over TCP
    void *pipeout = zmq_socket (context, ZMQ_ROUTER);
    zsocket_connect (pipeout, "inproc://pipe");

    zstr_send (pipein, "ABC");
    
    int rc;
    zmq_msg_t msg;
    zmq_msg_init (&msg);
    rc = zmq_recvmsg (pipeout, &msg, 0);
    if (rc < 0) {
        printf ("E: error, failed\n");
        exit (1);
    }
    int rcvmore;
    size_t type_size = sizeof (int);
    rc = zmq_getsockopt (pipeout, ZMQ_RCVMORE, &rcvmore, &type_size);
    if (rc)
        puts (strerror (errno));
    assert (rc == 0);

    int rcvlabel;
    zmq_getsockopt (pipeout, ZMQ_RCVLABEL, &rcvlabel, &type_size);
    assert (rc == 0);

    printf ("Got first message part: size=%zd more=%d label=%d\n",
        zmq_msg_size (&msg), rcvmore, rcvlabel);

    return 0;
}
コード例 #11
0
ファイル: table_server.c プロジェクト: abhay123lp/audioscout
int kill_server(){
    char addr[32];
    void *ctx = main_ctx;

    snprintf(addr, 32, "tcp://%s:%d", GlobalArgs.server_address, GlobalArgs.port + 1);
    void *skt = socket_connect(ctx, ZMQ_REQ, addr);
    if (!skt){
	syslog(LOG_CRIT,"KILLSERVER: unable to get req skt");
	return -1;
    }

    uint8_t tn = table_number;
    table_number = 0;

    char *tmpstr = strdup(kill_str);
    sendmore_msg_data(skt, tmpstr, strlen(tmpstr)+1, free_fn, NULL);
    send_msg_vsm(skt, &tn, sizeof(uint8_t));

    time_t curr_time;
    time(&curr_time);

    zmq_msg_t msg;
    zmq_msg_init(&msg);
    int err = 0;
    do {
	err = zmq_recv(skt, &msg, ZMQ_NOBLOCK);
	sleep(1);
    } while (err && time(NULL) < curr_time + 10 );
    if (err){
	syslog(LOG_ERR, "KILLSERVER: no ack recieved - ignore");
	err = -1;
    }

    zmq_close(skt);
    syslog(LOG_DEBUG,"KILLSERVER: server killed");

    return err;
}
コード例 #12
0
ファイル: raptor_proxy.c プロジェクト: junglefire/Raptor
// worker thread function
static void* worker_routine (void *context)
{
	// socket to talk to dispatcher
	void* receiver = zmq_socket(context, ZMQ_REP); 
	if (!receiver) 
	{
		dzlog_error("create socket to talk to dispatcher failed, err: %s", zmq_strerror(errno));
		return NULL;
	}

	if (zmq_connect(receiver, "inproc://workers") != 0)
	{
		dzlog_error("worker thread connect worker_socket failed, err: %s", zmq_strerror(errno));
		return NULL;
	}

	dzlog_info("worker thread run ...");

	while (1) 
	{
		zmq_msg_t request;
		zmq_msg_init(&request);
		zmq_recvmsg(receiver, &request, 0); 
		printf("Recv Hello\n"); 
		zmq_msg_close(&request);

		sleep(1);
		
		zmq_msg_t reply;
		zmq_msg_init_size(&reply, 5);
		memcpy(zmq_msg_data (&reply), "World", 5); 
		zmq_sendmsg(receiver, &reply, 0); 
		zmq_msg_close(&reply);
	}

	zmq_close (receiver);
	return NULL;
}
コード例 #13
0
ファイル: proxy_thr.cpp プロジェクト: somdoron/libzmq
static void subscriber_thread_main (void *pvoid)
{
    const proxy_hwm_cfg_t *cfg = (proxy_hwm_cfg_t *) pvoid;
    const int idx = cfg->thread_idx;

    void *subsocket = zmq_socket (cfg->context, ZMQ_SUB);
    assert (subsocket);

    set_hwm (subsocket);

    TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (subsocket, ZMQ_SUBSCRIBE, 0, 0));

    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_connect (subsocket, cfg->backend_endpoint[idx]));

    //  Receive message_count messages
    uint64_t rxsuccess = 0;
    bool success = true;
    while (success) {
        zmq_msg_t msg;
        int rc = zmq_msg_init (&msg);
        assert (rc == 0);

        rc = zmq_msg_recv (&msg, subsocket, 0);
        if (rc != -1) {
            TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&msg));
            rxsuccess++;
        }

        if (rxsuccess == message_count)
            break;
    }

    //  Cleanup

    zmq_close (subsocket);
    printf ("subscriber thread ended\n");
}
コード例 #14
0
ファイル: xsub.cpp プロジェクト: AbdelghaniDr/mirror
int zmq::xsub_t::xsend (zmq_msg_t *msg_, int options_)
{
    size_t size = zmq_msg_size (msg_);
    unsigned char *data = (unsigned char*) zmq_msg_data (msg_);

    //  Malformed subscriptions are dropped silently.
    if (size >= 1) {

        //  Process a subscription.
        if (*data == 1)
            subscriptions.add (data + 1, size - 1);

        //  Process an unsubscription. Invalid unsubscription is ignored.
        if (*data == 0)
            subscriptions.rm (data + 1, size - 1);
    }

    int rc = zmq_msg_close (msg_);
    zmq_assert (rc == 0);
    rc = zmq_msg_init (msg_);
    zmq_assert (rc == 0);
    return 0;
}
コード例 #15
0
ファイル: common.c プロジェクト: NixM0nk3y/nagmq
void input_reaper(void * insock) {
	while(1) {
		zmq_msg_t input;
		zmq_msg_init(&input);

		if(zmq_msg_recv(&input, insock, ZMQ_DONTWAIT) == -1) {
			if(errno == EAGAIN)
				break;
			else if(errno == EINTR)
				continue;
			syslog(LOG_ERR, "Error receiving message from interface: %s",
				zmq_strerror(errno));
			continue;
		}

		if(insock == pullsock)
			process_pull_msg(&input);
		else if(insock == reqsock)
			process_req_msg(&input);

		zmq_msg_close(&input);
	}
}
コード例 #16
0
ファイル: van.cpp プロジェクト: lacozhang/numopt
void Van::monitor() {
  VLOG(1) << "starting monitoring...";
  void *s = CHECK_NOTNULL(zmq_socket(context_, ZMQ_PAIR));
  CHECK(!zmq_connect(s, "inproc://monitor"));
  while (true) {
    zmq_msg_t msg;
    zmq_msg_init(&msg);
    if (zmq_msg_recv(&msg, s, 0) == -1) {
      if (errno == EINTR)
        continue;
      break;
    }
    uint8_t *data = (uint8_t *)zmq_msg_data(&msg);
    int event = *(reinterpret_cast<uint16_t *>(data));
    int value = *(reinterpret_cast<uint32_t *>(data + 2));

    if (event == ZMQ_EVENT_DISCONNECTED) {
      auto &manager = PostOffice::getInstance().manager();
      if (isScheduler()) {
        Lock l(fdToNodeIdMu_);
        if (fdToNodeId_.find(value) == fdToNodeId_.end()) {
          LOG(WARNING) << "cannot find the node id for Fd = " << value;
          continue;
        }
        manager.nodeDisconnected(fdToNodeId_[value]);
      } else {
        manager.nodeDisconnected(scheduler_.id());
      }
    }

    if (event == ZMQ_EVENT_MONITOR_STOPPED) {
      break;
    }
  }
  zmq_close(s);
  VLOG(1) << "monitor stopped";
}
コード例 #17
0
void test_routing_id ()
{
    //  Create the infrastructure
    void *sc = test_context_socket (ZMQ_DEALER);

    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, "inproc://routing_id"));

    void *sb = test_context_socket (ZMQ_ROUTER);

    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, "inproc://routing_id"));

    //  Send 2-part message.
    TEST_ASSERT_EQUAL_INT (
      1, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (sc, "A", 1, ZMQ_SNDMORE)));
    TEST_ASSERT_EQUAL_INT (
      1, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (sc, "B", 1, 0)));

    //  Routing id comes first.
    zmq_msg_t msg;
    TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&msg));
    TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, sb, 0));
    TEST_ASSERT_EQUAL_INT (1, zmq_msg_more (&msg));

    //  Then the first part of the message body.
    TEST_ASSERT_EQUAL_INT (
      1, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, sb, 0)));
    TEST_ASSERT_EQUAL_INT (1, zmq_msg_more (&msg));

    //  And finally, the second part of the message body.
    TEST_ASSERT_EQUAL_INT (
      1, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, sb, 0)));
    TEST_ASSERT_EQUAL_INT (0, zmq_msg_more (&msg));

    //  Deallocate the infrastructure.
    test_context_socket_close (sc);
    test_context_socket_close (sb);
}
コード例 #18
0
ファイル: zgw.cpp プロジェクト: zhangnian/zgw
void ZGWServer::pullThreadFunc()
{
    LOG_INFO << "PULL线程启动, TID: " << muduo::CurrentThread::tid();
    assert( NULL != zmqContext_ );

    std::string pull_endpoint = ini_.GetValue("backend", "pull_service", "");
    if( pull_endpoint.size() == 0 )
    {
        LOG_ERROR << "未设置PULL socket的地址";
        return;
    }

    void* pullSocket = zmq_socket(zmqContext_, ZMQ_PULL);
    assert( NULL != pullSocket );

    int rc = zmq_bind(pullSocket, pull_endpoint.c_str());
    assert( rc == 0 );

    LOG_INFO << "绑定PULL Socket成功,地址: " << pull_endpoint;
    while(true)
    {
        zmq_msg_t msg_t;
        rc = zmq_msg_init(&msg_t);
        assert( 0 == rc );

        rc = zmq_msg_recv(&msg_t, pullSocket, 0);
        if( rc == -1 )
        {
            LOG_ERROR << "PULL线程接收消息失败, errno: " << errno;
        }
        else
        {
            responseMsg(msg_t);
        }
        zmq_msg_close(&msg_t);
    }
}
コード例 #19
0
static ssize_t
ngx_zeromq_recv_part(void *zmq, ngx_event_t *rev, u_char *buf, size_t size)
{
    zmq_msg_t  zmq_msg;
    ssize_t    n;

    if (zmq_msg_init(&zmq_msg) == -1) {
        ngx_zeromq_log_error(rev->log, "zmq_msg_init()");
        return NGX_ERROR;
    }

    n = ngx_zeromq_recvmsg(zmq, rev, &zmq_msg);
    if (n < 0) {
        goto done;
    }

    if ((size_t) n > size) {
        ngx_log_error(NGX_LOG_ALERT, rev->log, 0,
                      "zmq_recv: ZeroMQ message part too big (%uz) to fit"
                      " into buffer (%uz)", n, size);

        n = NGX_ERROR;
        goto done;
    }

    ngx_memcpy(buf, zmq_msg_data(&zmq_msg), n);

done:

    if (zmq_msg_close(&zmq_msg) == -1) {
        ngx_zeromq_log_error(rev->log, "zmq_msg_close()");
        return NGX_ERROR;
    }

    return n;
}
コード例 #20
0
ファイル: rpc.c プロジェクト: 40a/experiments
void rpc_call_accept_response(rpc_call_t *rpc) {
  zmq_msg_t response;
  int rc;

  printf("rpc_call_accept_response\n");
  rc = zmq_msg_init(&response);
  rc = zmq_recv(rpc->socket, &response, ZMQ_NOBLOCK);

  insist_return(rc == 0 || errno == EAGAIN, (void)(0),
                "zmq_recv: expected success or EAGAIN, got errno %d:%s",
                errno, strerror(errno));

  if (rc == -1 && errno == EAGAIN) {
    /* nothing to do, would block */
    zmq_msg_close(&response);
    return;
  }

  rpc_call_handle_response(rpc, &response);
  zmq_msg_close(&response);

  /* Free the 'rpc' call */
  rpc_call_free(rpc);
} /* rpc_call_accept_response */
コード例 #21
0
ファイル: Event.cpp プロジェクト: Agnie-Software/jzmq
static zmq_msg_t*
read_msg(JNIEnv *env, void *socket, zmq_msg_t *msg, int flags)
{
    int rc = zmq_msg_init (msg);
    if (rc != 0) {
        raise_exception (env, zmq_errno());
        return NULL;
    }

#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,0,0)
    rc = zmq_recvmsg (socket, msg, flags);
#else
    rc = zmq_recv (socket, msg, flags);
#endif
    int err = zmq_errno();
    if (rc < 0 && err == EAGAIN) {
        rc = zmq_msg_close (msg);
        err = zmq_errno();
        if (rc != 0) {
            raise_exception (env, err);
            return NULL;
        }
        return NULL;
    }
    if (rc < 0) {
        raise_exception (env, err);
        rc = zmq_msg_close (msg);
        err = zmq_errno();
        if (rc != 0) {
            raise_exception (env, err);
            return NULL;
        }
        return NULL;
    }
    return msg;
}
コード例 #22
0
ファイル: easyzmq.c プロジェクト: prtitrz/Thrall
//  Receives all message parts from socket, prints neatly
void s_dump (void *socket)
{
    puts ("----------------------------------------");
    while (1) {
        //  Process all parts of the message
        zmq_msg_t message;
        zmq_msg_init (&message);
        zmq_recv (socket, &message, 0);

        //  Dump the message as text or binary
        char *data = zmq_msg_data (&message);
        int size = zmq_msg_size (&message);
        int is_text = 1;
        int char_nbr;
        for (char_nbr = 0; char_nbr < size; char_nbr++)
            if ((unsigned char) data [char_nbr] < 32
            ||  (unsigned char) data [char_nbr] > 127)
                is_text = 0;

        printf ("[%03d] ", size);
        for (char_nbr = 0; char_nbr < size; char_nbr++) {
            if (is_text)
                printf ("%c", data [char_nbr]);
            else
                printf ("%02X", (unsigned char) data [char_nbr]);
        }
        printf ("\n");

        int64_t more;           //  Multipart detection
        size_t more_size = sizeof (more);
        zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
        zmq_msg_close (&message);
        if (!more)
            break;      //  Last message part
    }
}
コード例 #23
0
ファイル: rep.cpp プロジェクト: jthornber/zeromq2
int zmq::rep_t::xsend (zmq_msg_t *msg_, int flags_)
{
    if (!waiting_for_reply) {
        errno = EFSM;
        return -1;
    }

    //  TODO: Implement this once queue limits are in-place. If the reply
    //  overloads the buffer, connection should be torn down.
    zmq_assert (reply_pipe->check_write (zmq_msg_size (msg_)));

    //  Push message to the selected pipe.
    reply_pipe->write (msg_);
    reply_pipe->flush ();

    waiting_for_reply = false;
    reply_pipe = NULL;

    //  Detach the message from the data buffer.
    int rc = zmq_msg_init (msg_);
    zmq_assert (rc == 0);

    return 0;
}
コード例 #24
0
void
s_recv_seq (void *socket, ...)
{
    zmq_msg_t msg;
    zmq_msg_init (&msg);

    int more;
    size_t more_size = sizeof(more);

    va_list ap;
    va_start (ap, socket);
    const char * data = va_arg (ap, const char *);

    while (true) {
        int rc = zmq_msg_recv (&msg, socket, 0);
        assert (rc != -1);

        if (!data)
            assert (zmq_msg_size (&msg) == 0);
        else
            assert (strcmp (data, (const char *)zmq_msg_data (&msg)) == 0);

        data = va_arg (ap, const char *);
        bool end = data == SEQ_END;

        rc = zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
        assert (rc == 0);

        assert (!more == end);
        if (end)
            break;
    }
    va_end (ap);

    zmq_msg_close (&msg);
}
コード例 #25
0
ファイル: handler.c プロジェクト: AlexVPopov/mongrel2
static inline int handler_recv_parse(Handler *handler, HandlerParser *parser)
{
    zmq_msg_t *inmsg = NULL;
    check(handler->running, "Called while handler wasn't running, that's not good.");

    inmsg = calloc(sizeof(zmq_msg_t), 1);
    int rc = 0;

    check_mem(inmsg);

    rc = zmq_msg_init(inmsg);
    check(rc == 0, "Failed to initialize message.");

    taskstate("recv");

    rc = mqrecv(handler->recv_socket, inmsg, 0);
    check(rc == 0, "Receive on handler socket failed.");
    check(handler->running, "Handler marked as not running.");

    rc = HandlerParser_execute(parser, zmq_msg_data(inmsg), zmq_msg_size(inmsg));
    check(rc == 1, "Failed to parse message from handler.");

    check(parser->target_count > 0, "Message sent had 0 targets: %.*s",
            (int)zmq_msg_size(inmsg), (char *)zmq_msg_data(inmsg));

    zmq_msg_close(inmsg);
    free(inmsg);
    return 0;

error:
    if(inmsg) {
        zmq_msg_close(inmsg);
        free(inmsg);
    }
    return -1;
}
コード例 #26
0
ファイル: zsocket.c プロジェクト: ajtulloch/lzmq
static int luazmq_skt_recv (lua_State *L) {
  zsocket *skt = luazmq_getsocket(L);
  zmq_msg_t msg;
  int flags = luaL_optint(L,2,0);
  int ret = zmq_msg_init(&msg);
  if(-1 == ret) return luazmq_fail(L, skt);
  ret = zmq_msg_recv(&msg, skt->skt, flags);
  if(-1 == ret){
    zmq_msg_close(&msg);
    return luazmq_fail(L, skt);
  }
  lua_pushlstring(L, zmq_msg_data(&msg), zmq_msg_size(&msg));
  if( zmq_msg_more(&msg) ){
    skt->flags |= LUAZMQ_FLAG_MORE;
    lua_pushboolean(L, 1);
  }
  else{
    skt->flags &= ~LUAZMQ_FLAG_MORE;
    lua_pushboolean(L, 0);
  }

  zmq_msg_close(&msg);
  return 2;
}
コード例 #27
0
ファイル: zsocket.c プロジェクト: ajtulloch/lzmq
static int luazmq_skt_recvx (lua_State *L) {
  zsocket *skt = luazmq_getsocket(L);
  zmq_msg_t msg;
  int flags = luaL_optint(L,2,0);
  int i = 0;
  lua_settop(L, 1);

  while(1){
    int ret = zmq_msg_init(&msg);
    if(-1 == ret){
      ret = luazmq_fail(L, skt);
      {int j;for(j = ret; j >= 0; --j){
        lua_insert(L, 1);
      }}
      return ret + i;
    }

    ret = zmq_msg_recv(&msg, skt->skt, flags);
    if(-1 == ret){
      zmq_msg_close(&msg);
      ret = luazmq_fail(L, skt);
      {int j;for(j = ret; j >= 0; --j){
        lua_insert(L, 1);
      }}
      return ret + i;
    }

    i++;
    lua_checkstack(L, i);
    lua_pushlstring(L, zmq_msg_data(&msg), zmq_msg_size(&msg));
    ret = zmq_msg_more(&msg);
    zmq_msg_close(&msg);
    if(!ret) break;
  }
  return i;
}
コード例 #28
0
ファイル: zsocket.c プロジェクト: ajtulloch/lzmq
static int luazmq_skt_sendv_impl(lua_State *L, int flags) {
  zsocket *skt = luazmq_getsocket(L);
  size_t i, size = 0, top = lua_gettop(L);
  zmq_msg_t msg;
  int ret;

  for(i = 2; i<=top; ++i){
    size_t s;
    luaL_checklstring(L,i,&s);
    size += s;
  }

  if (0 == size){
    ret = zmq_msg_init(&msg);
  }
  else {
    ret = zmq_msg_init_size(&msg, size);
  }
  if(-1 == ret) return luazmq_fail(L, skt);

  {
    size_t pos;
    for(pos = 0, i = 2; i<=top; ++i){
      const char *data = luaL_checklstring(L,i,&size);
      memcpy((char*)zmq_msg_data(&msg) + pos, data, size);
      pos += size;
    }
  }

  ret = zmq_msg_send(&msg, skt->skt, flags);
  zmq_msg_close(&msg);

  if(-1 == ret) return luazmq_fail(L, skt);
  return luazmq_pass(L);

}
コード例 #29
0
ファイル: test.c プロジェクト: DaisyCoder/kasicass
void pair_callback(int _, short __, void *pull)
{
	zmq_msg_t msg;
	uint32_t events;
	size_t len;

	len = sizeof(events);
	zmq_getsockopt(pull, ZMQ_EVENTS, &events, &len);

	if ( events & ZMQ_POLLIN )
	{	
		while (1)
		{
			zmq_msg_init(&msg);
			if ( zmq_recv(pull, &msg, ZMQ_NOBLOCK) == -1 )
			{
				zmq_msg_close(&msg);
				break;
			}
			printf("recv: %s\n", (char *)zmq_msg_data(&msg));
			zmq_msg_close(&msg);
		}
	}
}
コード例 #30
0
ファイル: table_server.c プロジェクト: abhay123lp/audioscout
/* aux function to worker threads for sending the results */
static int send_results(void *skt, uint8_t threadnb, uint32_t id, float cs){

    syslog(LOG_DEBUG,"SEND: send thr = %u, id = %u, cs = %f", threadnb, id, cs);
    sendmore_msg_vsm(skt, &threadnb, sizeof(uint8_t));
    sendmore_msg_vsm(skt, &id, sizeof(uint32_t));
    send_msg_vsm(skt, &cs, sizeof(float));

    int err =0;
    zmq_msg_t msg;
    zmq_msg_init(&msg);
    time_t curr_time;
    time(&curr_time);
    do {
      err = zmq_recv(skt, &msg, ZMQ_NOBLOCK);
      sleep(1);
    } while (err && time(NULL) < curr_time + 10 );
    if (!err){
      syslog(LOG_DEBUG,"SEND: reply recieved, msg size = %d", zmq_msg_size(&msg));
    } else {
      syslog(LOG_DEBUG,"SEND: no reply recieved");
    }

    return 0;
}