Example #1
0
value hx_zmq_construct_socket (value context_handle,value type)
{
	val_is_kind(context_handle,k_zmq_context_handle);
	if (!val_is_int(type)) {
		val_throw(alloc_int(EINVAL));
		return alloc_null();
	}
		
	void *s = zmq_socket (val_data(context_handle),val_int(type));
	int err = zmq_errno();
	
	if (s == NULL) {
		val_throw (alloc_int(err));
		return alloc_null();
	}
	
	// See: http://nekovm.org/doc/ffi#abstracts_and_kinds
	value v =  alloc_abstract(k_zmq_socket_handle,s);
	val_gc(v,finalize_socket);		// finalize_socket is called when the abstract value is garbage collected
	return v;
	
}
Example #2
0
bool ztop::InitialService(std::vector<std::pair<std::string, std::string>> servicePair, ztop*pztop)
{

	auto lambda_setsocket = [](std::pair<std::string, std::string>& sPair, ztop*pztop){
		void*s = zmq_socket(pztop->ctx, ZMQ_PUSH);
		int rc = zmq_bind(s, sPair.second.c_str());
		if (rc != -1)
		{
			pztop->pairs.insert(std::make_pair(sPair.first, s));
			pztop->vItems.push_back({ s, 0, ZMQ_POLLIN, 0 });
/*			pztop->jobSendSoketSets.insert(s);*/
			std::cerr << sPair.first << " start success:" << sPair.second << std::endl;
		}
		else
			std::cerr << __FUNCTION__ << ":"<<"service not start,with err:=====>" << zmq_strerror(zmq_errno());
	};
	for_each(servicePair.begin(), servicePair.end(), [&](std::pair<std::string, std::string>& sPair){
		lambda_setsocket(sPair, pztop);
	});

	return true;
}
Example #3
0
int create_sub_socket(void* ctx) {
	std::stringstream conn;
	conn << "tcp://" << g_sip << ":" << g_port_sub;
	void * sub = zmq_socket(ctx, ZMQ_SUB);
	int rc = zmq_connect(sub, conn.str().c_str());
	assert(rc == 0);
	if (rc != 0) {
		std::cerr << "Error Connect to " << conn.str() << " errno " << errno << std::endl;
		zmq_close(sub);
		exit(EXIT_FAILURE);
	}

	char temp[256] = { 0 };
	sprintf(temp, "%s ", g_sn);
	printf("Subscribe id: %s\n", temp);
	rc = zmq_setsockopt(sub, ZMQ_SUBSCRIBE, temp, strlen(temp));
	assert(rc == 0);
	rc = zmq_setsockopt(sub, ZMQ_SUBSCRIBE, "ALL ", strlen("ALL "));
	assert(rc == 0);
	g_sub_socket = sub;
	return 0;
}
Example #4
0
//********************************************************************************
// Function: redirect_count
//
// Description: Recieve Control Plane redirect count.
//********************************************************************************
static int32_t redirect_count(void)
{
    void *context = zmq_ctx_new ();
    void *requester = zmq_socket(context, ZMQ_REQ);

    int32_t timeo{};
    zmq_setsockopt(requester, ZMQ_LINGER, (void*) &timeo, sizeof(timeo));

    char buffer[64];
    sprintf(buffer, "tcp://localhost:%d", TCPLANE_SERVICE);
    zmq_connect(requester, buffer);

    sprintf(buffer, "%d", redirectCount);
    zmq_send(requester, buffer, strlen(buffer), 0);

    size_t size = timed_read(requester, buffer, sizeof(buffer), READ_TIMEOUT);
    if(size)
        size = atoi(buffer);    
    zmq_close(requester);
    zmq_ctx_destroy(context);
    return size;
}
Example #5
0
File: server.c Project: eselyavka/C
int main (void)
{
    void *context = zmq_ctx_new ();
    void *responder = zmq_socket (context, ZMQ_REP);
    int i=1;
    char skeystr[] = "JTKVSB%%)wK0E.X)V>+}o?pNmC{O&4W4b!Ni{Lh6";
    uint8_t server_key [32];
    zmq_z85_decode (server_key, skeystr);
    zmq_setsockopt(responder, ZMQ_CURVE_SERVER, &i, sizeof(i));
    zmq_setsockopt(responder, ZMQ_CURVE_SECRETKEY, &server_key, sizeof(server_key));
    int rc = zmq_bind (responder, "tcp://*:55555");
    assert (rc == 0);

    while (1) {
        char buffer [10];
        zmq_recv (responder, buffer, 10, 0);
        printf ("Received Hello\n");
        sleep (1);
        zmq_send (responder, "World", 5, 0);
    }
    return 0;
}
Example #6
0
// .split worker task
// While this example runs in a single process, that is just to make
// it easier to start and stop the example. Each thread has its own
// context and conceptually acts as a separate process.
// This is the worker task, using a REQ socket to do load-balancing.
// Because s_send and s_recv can't handle 0MQ binary identities, we
// set a printable text identity to allow routing.
static void *worker_task(void *args)
{
    void *context = zmq_ctx_new();
    void *worker = zmq_socket(context, ZMQ_REQ);

#if (defined (WIN32))
    s_set_id(worker, (intptr_t)args);
    zmq_connect(worker, "tcp://localhost:5673"); // backend
#else
    s_set_id(worker);
    zmq_connect(worker, "ipc://backend.ipc");
#endif

    // Tell broker we're ready for work
    s_send(worker, "READY");

    while (1) {
        // Read and save all frames until we get an empty frame
        // In this example there is only 1, but there could be more
        char *identity = s_recv(worker);
        char *empty = s_recv(worker);
        assert(*empty == 0);
        free(empty);

        // Get request, send reply
        char *request = s_recv(worker);
        printf("Worker: %s from %s\n", request, identity);
        free(request);

        s_sendmore(worker, identity);
        s_sendmore(worker, "");
        s_send(worker, "OK");
        free(identity);
    }

    zmq_close(worker);
    zmq_ctx_destroy(context);
    return NULL;
}
Example #7
0
int main (void)
{
    setup_test_environment ();
    void *ctx = zmq_ctx_new ();
    assert (ctx);

    void *sock = zmq_socket (ctx, ZMQ_PUB);
    assert (sock);

    int rc = zmq_connect (sock, "tcp://localhost:1234");
    assert (rc == 0);

    rc = zmq_connect (sock, "tcp://[::1]:1234");
    assert (rc == 0);

    rc = zmq_connect (sock, "tcp://localhost:invalid");
    assert (rc == -1);

    rc = zmq_connect (sock, "tcp://in val id:1234");
    assert (rc == -1);

    rc = zmq_connect (sock, "tcp://");
    assert (rc == -1);

    rc = zmq_connect (sock, "tcp://192.168.0.200:*");
    assert (rc == -1);

    rc = zmq_connect (sock, "invalid://localhost:1234");
    assert (rc == -1);
    assert (errno == EPROTONOSUPPORT);

    rc = zmq_close (sock);
    assert (rc == 0);

    rc = zmq_ctx_term (ctx);
    assert (rc == 0);

    return 0;
}
Example #8
0
File: zmq_a.c Project: 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;
}
        bool SubscriberZMQ::_onInit(TUInt port)
        {
            m_context = zmq_ctx_new();
            if (m_context == 0)
            {
                zmqlog("Error occurred during zmq_ctx_new()");
                return false;
            } 
            
            m_socket = zmq_socket(m_context, ZMQ_SUB);
            if (m_socket == 0)
            {
                zmqlog("Error occurred during zmq_socket()");
                clear();
                return false;
            } 
            
            TChar address[100] = {'\0'};
            sprintf(address, "tcp://localhost:%u", port);
            int result = zmq_connect(m_socket, address);

            if (result != 0)
            {
                zmqlog("Error occurred during zmq_init()");
                clear();
                return false;
            }
            
            const TString& subscribeId = getSubscribeId();
            result = zmq_setsockopt (m_socket, ZMQ_SUBSCRIBE, subscribeId.c_str(), subscribeId.length() - 1);
            if (result != 0)
            {
                zmqlog("Error occurred during zmq_setsockopt");
                clear();
                return false;
            }
            
            return true;
        }
Example #10
0
int main ()
{
    void *ctx = zmq_init (1);
    assert (ctx);

    void *dealer = zmq_socket (ctx, ZMQ_DEALER);
    assert (dealer);
    int rc = zmq_connect (dealer, "tcp://localhost:2211");
    assert (rc == 0);

    while (1) {
        //  Send signal to parent
        zmq_msg_t msg;
        zmq_msg_init (&msg);
        zmq_sendmsg (dealer, &msg, 0);
        zmq_msg_close (&msg);

        //  Do some work
        sleep (1);
    }
    return 0;
}
Example #11
0
int main(void)
{
    void *context = zmq_ctx_new();
    
    //Socket to connect to Server
    void *requester = zmq_socket(context, ZMQ_REQ);
    zmq_connect(requester, "tcp://localhost:8888");
    
    int request_nbr;
    for(request_nbr = 0; request_nbr != 10; request_nbr++)
    {
        s_send(requester, "Hello");
        char* string = s_recv(requester);
        printf("Received reply %d [%s] \n", request_nbr, string);
        free(string);
    }
    
    zmq_close(requester);
    zmq_ctx_destroy(context);
    
    return 0;
}
void main(){

    fprintf(stdout,"#####  Client-1 is running - C Broker Test  #####\n");

    void *context = zmq_ctx_new ();
    void *requester = zmq_socket (context, ZMQ_PUSH);
    zmq_connect (requester, "tcp://127.0.0.1:5559");

    char *str_message="i am client-1";
    int request_number;

    //sending 1000000 requests from client
    for (request_number = 1; request_number <= 1000000; request_number++) {

        zstr_send (requester, str_message);

    }

    zmq_close (requester);
    zmq_ctx_destroy (context);

}
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;
}
Example #14
0
JNIEXPORT void JNICALL
Java_org_zeromq_ZMQ_00024Socket_construct (JNIEnv *env, jobject obj, jobject context, jint type)
{
    void *s = get_socket (env, obj);
    if (s)
        return;

    void *c = fetch_context (env, context);
    if (c == NULL) {
        raise_exception (env, EINVAL);
        return;
    }

    s = zmq_socket (c, type);
    int err = zmq_errno();

    if (s == NULL) {
        raise_exception (env, err);
        return;
    }
    put_socket(env, obj, s);
}
Example #15
0
int main(void)
{
    // Prepare our context and socket
    void *context = zmq_ctx_new();
    void *receiver = zmq_socket(context, ZMQ_PULL);
    zmq_bind(receiver, "tcp://*:5558");

    // Wait for start of batch
    char *string = s_recv(receiver);
    free(string);
    printf("start of batch\n");

    // Start our clock now
    int64_t start_time = s_clock();

    // Process 100 confirmations
    int task_nbr;
    for(task_nbr=0; task_nbr<100; task_nbr++)
    {
        char *string = s_recv(receiver);
        free(string);
        if(task_nbr % 10 == 0)
        {
            printf(":");
        }
        else
        {
            printf(".");
        }
        fflush(stdout);
    }

    // Calculate and report duration of batch
    printf("\nTotal elapsed time: %d msec\n", (int)(s_clock() - start_time));
    
    zmq_close(receiver);
    zmq_ctx_destroy(context);
    return 0;
}
Example #16
0
int main(void)
{
  void *ctx = zmq_ctx_new();
  void *sock = zmq_socket(ctx, ZMQ_ROUTER);
  int rc = zmq_bind(sock, "tcp://127.0.0.1:5555");
  assert(0 == rc);

  char buf[128];
  int recvBytes = 0;
  while (1) {
    // recv  id
    recvBytes = zmq_recv(sock, buf, sizeof(buf), 0);
    if (0 < recvBytes) {
      // send it back
      printf("recv id bytes=%d\n", recvBytes);

      zmq_send(sock, buf, recvBytes, ZMQ_SNDMORE);
    }

    // delimiter emtpy frame
    recvBytes = zmq_recv(sock, buf, sizeof(buf), 0);
    assert(0 == recvBytes);

    recvBytes = zmq_recv(sock, buf, sizeof(buf), 0);
    // actual message
    if (0 < recvBytes) {
      // send it back
      buf[recvBytes] = '\0';
      printf("recv msg %s, bytes=%d\n", buf, recvBytes);

      zmq_send(sock, "", 0, ZMQ_SNDMORE);
      zmq_send(sock, buf, recvBytes, 0);
    }
  }

  zmq_close(sock);
  zmq_ctx_destroy(ctx);
  return 0;
}
Example #17
0
int main (void)
{
    void *context = zmq_ctx_new ();
    void *socket = zmq_socket (context, ZMQ_REP);
    zmq_bind (socket, "tcp://*:5555");

    s_catch_signals ();
    while (true) {
        //  Blocking read will exit on a signal
        zmq_msg_t message;
        zmq_msg_init (&message);
        zmq_msg_recv (&message, socket, 0);

        if (s_interrupted) {
            printf ("W: interrupt received, killing server...\n");
            break;
        }
    }
    zmq_close (socket);
    zmq_ctx_destroy (context);
    return 0;
}
Example #18
0
tbg_socket_t *tbg_open(char *server_uri)
{
    int ret;
    tbg_socket_t *tsock = g_new(tbg_socket_t, 1);

    tsock->timeout = TBG_DEFAULT_TIMEOUT;

    tsock->zsocket = zmq_socket(zcontext, ZMQ_DEALER);
    if (tsock->zsocket == NULL) {
        g_free(tsock);
        return NULL;
    }

    ret = zmq_connect (tsock->zsocket, server_uri);
    if (ret != 0) {
        zmq_close(tsock->zsocket);
        g_free(tsock);
        return NULL;
    }

    return tsock;
}
Example #19
0
int register_table(void *ctx, const char *address){
    void *skt = zmq_socket(ctx, ZMQ_REQ);
    assert(skt);
    assert(zmq_connect(skt, address) == 0);

    char *str = strdup(init_str);
    send_msg_data(skt, str, strlen(str)+1, free_fn, NULL);

    int64_t more;
    size_t msg_size, more_size = sizeof(int64_t);
    void *data;
    recieve_msg(skt, &msg_size, &more, &more_size, &data);
    if (msg_size != sizeof(uint8_t)){
	return -1;
    }
    memcpy(&table_number, data, sizeof(uint8_t));
    free(data);
    if (more) flushall_msg_parts(skt);
    assert(zmq_close(skt) == 0);

    return 0;
}
Example #20
0
// REQ socket monitor thread
static void req_socket_monitor (void *ctx)
{
    zmq_event_t event;
    std::string ep ;
    int rc;

    void *s = zmq_socket (ctx, ZMQ_PAIR);
    assert (s);

    rc = zmq_connect (s, "inproc://monitor.req");
    assert (rc == 0);
    while (!read_msg(s, event, ep)) {
        assert (ep == addr);
        switch (event.event) {
            case ZMQ_EVENT_CONNECTED:
                assert (event.value > 0);
                req_socket_events |= ZMQ_EVENT_CONNECTED;
                req2_socket_events |= ZMQ_EVENT_CONNECTED;
                break;
            case ZMQ_EVENT_CONNECT_DELAYED:
                assert (event.value != 0);
                req_socket_events |= ZMQ_EVENT_CONNECT_DELAYED;
                break;
            case ZMQ_EVENT_CLOSE_FAILED:
                assert (event.value != 0);
                req_socket_events |= ZMQ_EVENT_CLOSE_FAILED;
                break;
            case ZMQ_EVENT_CLOSED:
                assert (event.value != 0);
                req_socket_events |= ZMQ_EVENT_CLOSED;
                break;
            case ZMQ_EVENT_DISCONNECTED:
                assert (event.value != 0);
                req_socket_events |= ZMQ_EVENT_DISCONNECTED;
                break;
        }
    }
    zmq_close (s);
}
Example #21
0
int main (void)
{
    setup_test_environment();
    void *ctx = zmq_ctx_new ();
    assert (ctx);

    void *sb = zmq_socket (ctx, ZMQ_REP);
    assert (sb);
    int rc = zmq_bind (sb, "inproc://a");
    assert (rc == 0);

    rc = zmq_unbind (sb, "inproc://a");
    assert (rc == 0);

    rc = zmq_close (sb);
    assert (rc == 0);

    rc = zmq_ctx_term (ctx);
    assert (rc == 0);

    return 0;
}
Example #22
0
int main(int argc, char *argv[]) {

    q_open = r_open = 0;

    if (argc != 2) {
        printf("usage: %s <message>\n", argv[0]);
        exit(-1);
    }

    ctx = zmq_init(1);
    if (ctx < 0) {
        printf("could not create context\n");
        exit(-1);
    }

    s = zmq_socket(ctx, ZMQ_REQ);
    check((long)s,"could not initialize socket");

    printf("connecting...\n");
    check(zmq_connect(s, "tcp://127.0.0.1:5554"),
        "could not connect to server");

    check(zmq_msg_init_data(&query, argv[1], strlen(argv[1]), NULL, NULL),
        "could not initialize message");
    q_open = 1;

    printf("sending...\n");
    check(zmq_send(s, &query, 0), "could not send message\n");

    printf("waiting for result...\n");
    check(zmq_msg_init(&result), "could not initialize message");
    r_open = 1;
    check(zmq_recv(s, &result, 0),
        "could not receive reply");

    printf("got response from server: %s\n", (char *)zmq_msg_data(&result));

    cleanup();
}
Example #23
0
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);
}    
bool CZMQAbstractPublishNotifier::Initialize(void *pcontext)
{
    assert(!psocket);

    // check if address is being used by other publish notifier
    std::multimap<std::string, CZMQAbstractPublishNotifier*>::iterator i = mapPublishNotifiers.find(address);

    if (i==mapPublishNotifiers.end())
    {
        psocket = zmq_socket(pcontext, ZMQ_PUB);
        if (!psocket)
        {
            zmqError("Failed to create socket");
            return false;
        }

        int rc = zmq_bind(psocket, address.c_str());
        if (rc!=0)
        {
            zmqError("Failed to bind address");
            zmq_close(psocket);
            return false;
        }

        // register this notifier for the address, so it can be reused for other publish notifier
        mapPublishNotifiers.insert(std::make_pair(address, this));
        return true;
    }
    else
    {
        LogPrint(BCLog::ZMQ, "zmq: Reusing socket for address %s\n", address);

        psocket = i->second->psocket;
        mapPublishNotifiers.insert(std::make_pair(address, this));

        return true;
    }
}
Example #25
0
// 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;
}
Example #26
0
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");
}
int main (void)
{
    fprintf (stderr, "test_router_mandatory_tipc running...\n");

    void *ctx = zmq_init (1);
    assert (ctx);

    // Creating the first socket.
    void *sa = zmq_socket (ctx, ZMQ_ROUTER);
    assert (sa);

    int rc = zmq_bind (sa, "tipc://{15560,0,0}");
    assert (rc == 0);

    // Sending a message to an unknown peer with the default setting
    rc = zmq_send (sa, "UNKNOWN", 7, ZMQ_SNDMORE);
    assert (rc == 7);
    rc = zmq_send (sa, "DATA", 4, 0);
    assert (rc == 4);

    int mandatory = 1;

    // Set mandatory routing on socket
    rc = zmq_setsockopt (sa, ZMQ_ROUTER_MANDATORY, &mandatory, sizeof (mandatory));
    assert (rc == 0);

    // Send a message and check that it fails
    rc = zmq_send (sa, "UNKNOWN", 7, ZMQ_SNDMORE | ZMQ_DONTWAIT);
    assert (rc == -1 && errno == EHOSTUNREACH);

    rc = zmq_close (sa);
    assert (rc == 0);

    rc = zmq_term (ctx);
    assert (rc == 0);

    return 0 ;
}
Example #28
0
int _tmain(int argc, _TCHAR* argv[])
{
	setlocale(LC_ALL,"Chinese");
	setlocale(LC_ALL,"chs");

	void *m_context;
	void *m_subscriber;
	char m_subAddr[64];

	m_context = zmq_init(1);
	m_subscriber = zmq_socket(m_context,ZMQ_SUB);

	
	char *puberIp = "127.0.0.1";
	WORD port = 8585;

	memset(m_subAddr,0,sizeof(m_subAddr));
	sprintf_s(m_subAddr,"tcp://%s:%d",puberIp,port);

	zmq_connect(m_subscriber,m_subAddr);

	char *option = "642";
	int ret = zmq_setsockopt(m_subscriber,ZMQ_SUBSCRIBE,"642",strlen(option));

	while (1)
	{
		BYTE buffer[1024] = {0};
		DWORD bufLen = sizeof(buffer);
		DWORD gotLen = zmq_recv(m_subscriber,buffer,bufLen,0);

		printf("收到发布信息:%s\n",buffer);
	}

	zmq_close(m_subscriber);
	zmq_term(m_context);

	return 0;
}
Example #29
0
int main (int argc, char *argv [])
{
    fprintf (stderr, "test_router_behavior running...\n");

    void *ctx = zmq_init (1);
    assert (ctx);

    // Creating the first socket.
    void *sa = zmq_socket (ctx, ZMQ_ROUTER);
    assert (sa);
    
    int rc = zmq_bind (sa, "tcp://127.0.0.1:15560");
    assert (rc == 0);

    // Sending a message to an unknown peer with the default behavior.
    rc = zmq_send (sa, "UNKNOWN", 7, ZMQ_SNDMORE);
    assert (rc == 7);
    rc = zmq_send (sa, "DATA", 4, 0);
    assert (rc == 4);

    int behavior = 1;

    // Setting the socket behavior to a new mode.
    rc = zmq_setsockopt (sa, ZMQ_ROUTER_BEHAVIOR, &behavior, sizeof (behavior));
    assert (rc == 0);

    // Sending a message to an unknown peer with verbose behavior.
    rc = zmq_send (sa, "UNKNOWN", 7, ZMQ_SNDMORE | ZMQ_DONTWAIT);
    assert (rc == -1 && errno == EAGAIN);

    rc = zmq_close (sa);
    assert (rc == 0);

    rc = zmq_term (ctx);
    assert (rc == 0);

    return 0 ;
}
void ini_zmq()
{
	void * ctx = zmq_init(1);
	if (!ctx) 
	{
		return;
	}

	void * s = zmq_socket(ctx, ZMQ_PUSH);
	if (!s) 
	{
		return;
	}

	s32 rc = zmq_bind(s, UI_ZMQ_NAME);
	if (rc) 
	{
		return;
	}

	g_zmq_socket = s;
	g_zmq_ui_ctx = ctx;
}