arzmq-sys 0.6.3

Low-level bindings to the zeromq library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

#include "protoApp.h"
#include "protoSocket.h"

class UdpTest : public ProtoApp
{
    public:
        UdpTest();
        ~UdpTest();

        /**
        * Override from ProtoApp or NsProtoSimAgent base
        */
        bool OnStartup(int argc, const char*const* argv);
        /**
        * Override from ProtoApp or NsProtoSimAgent base
        */
        bool ProcessCommands(int argc, const char*const* argv) {return true;}
        /**
        * Override from ProtoApp or NsProtoSimAgent base
        */
        void OnShutdown();
     
        

    private:
        void OnTxTimeout(ProtoTimer& theTimer);
        void OnClientSocketEvent(ProtoSocket&       theSocket, 
                               ProtoSocket::Event   theEvent);
        void OnServerSocketEvent(ProtoSocket&       theSocket, 
                               ProtoSocket::Event   theEvent);

        // ProtoTimer/ UDP socket demo members
        ProtoTimer          tx_timer;
        ProtoSocket         server_socket;
        ProtoSocket         client_socket;
}; // end class UdpTest



// Our application instance 
PROTO_INSTANTIATE_APP(UdpTest) 

UdpTest::UdpTest()
: server_socket(ProtoSocket::UDP), 
  client_socket(ProtoSocket::UDP)
{    
    tx_timer.SetListener(this, &UdpTest::OnTxTimeout);
    client_socket.SetNotifier(&GetSocketNotifier());
    client_socket.SetListener(this, &UdpTest::OnClientSocketEvent);
    server_socket.SetNotifier(&GetSocketNotifier());
    server_socket.SetListener(this, &UdpTest::OnServerSocketEvent);
}

UdpTest::~UdpTest()
{
    
}

bool UdpTest::OnStartup(int argc, const char*const* argv)
{
	if (argc > 1)
    {
        // Act as client (sender)
        client_socket.Bind(6000 + argc - 2);
        tx_timer.SetInterval(1.0);
        tx_timer.SetRepeat(-1.0);
        ActivateTimer(tx_timer);
        TRACE("udptest: Client startup ..\n");
    }    
    else
    {
        // Act as server (receiver)
        /*server_socket.Open(0, ProtoAddress::IPv4, false);
        server_socket.SetReuse(true);
        server_socket.Bind(5000);*/
        
        ProtoAddress addr;
        addr.ConvertFromString("127.0.0.1");
        addr.SetPort(6000);
        client_socket.Open(0, ProtoAddress::IPv4, false);
        client_socket.SetReuse(true);
        client_socket.Bind(5000);
        client_socket.Connect(addr);

		// Toggle server
		/*server_socket.Close();*/
		server_socket.Open(0, ProtoAddress::IPv4, false);
		server_socket.SetReuse(true);
		server_socket.Bind(5000);
		TRACE("udptest: Server startup ..\n");
    }
    return true;
}  // end UdpTest::OnStartup()

void UdpTest::OnShutdown()
{
    if (tx_timer.IsActive()) tx_timer.Deactivate();
    client_socket.Close();
    server_socket.Close();
    
}  // end UdpTest::OnShutdown()


void UdpTest::OnTxTimeout(ProtoTimer& /*theTimer*/)
{
    ProtoAddress dst;
    dst.ConvertFromString("127.0.0.1");
    dst.SetPort(5000);
    char buffer[256];
	sprintf(buffer, "Hi, this is client %d\n", client_socket.GetPort());
    unsigned int buflen = strlen(buffer) + 1;
    client_socket.SendTo(buffer, buflen, dst);
    TRACE("udptest: Client %d sent message to server ..\n", client_socket.GetPort());

}  // end UdpTest::OnTxTimeout()


void UdpTest::OnClientSocketEvent(ProtoSocket&       theSocket, 
                                  ProtoSocket::Event theEvent)
{
    if (ProtoSocket::RECV == theEvent)
    {
        char buffer[1024];
        unsigned int buflen = 1024;
        ProtoAddress src;
        theSocket.RecvFrom(buffer, buflen, src);
		if (buflen > 0)
			TRACE("udptest: server's client socket received: %s", buffer);
    }
    
}  // end UdpTest::OnClientSocketEvent()


void UdpTest::OnServerSocketEvent(ProtoSocket&       theSocket, 
                                 ProtoSocket::Event theEvent)
{
     if (ProtoSocket::RECV == theEvent)
    {
        char buffer[1024];
        unsigned int buflen = 1024;
        ProtoAddress src;
        theSocket.RecvFrom(buffer, buflen, src);
		if (buflen > 0)
			TRACE("udptest: server's server socket received: %s", buffer);
    }
}  // end UdpTest::OnServerSocketEvent()