Debian Codegraph @

protolib/src/sim/opnet/11.5/opnetProtoSimProcess.ex.cpp

raw
1 #include "opnetProtoSimProcess.h"
2 #include "mgen.h"
3
4
5 extern "C"
6 {
7 #include "oms_pr.h"
8 #include "udp_api.h"
9 #include "ip_addr_v4.h"
10 #include "ip_rte_v4.h"
11 }
12
13 OpnetProtoSimProcess::OpnetProtoSimProcess()
14 {
15
16 }
17
18 OpnetProtoSimProcess::~OpnetProtoSimProcess(void)
19 {
20
21 }
22
23 ProtoSimAgent::SocketProxy* OpnetProtoSimProcess::OpenSocket(ProtoSocket& theSocket)
24 {
25 #ifdef OP_DEBUG1
26 printf("\topnetProtosimProcess.pr.c - OpnetProtoSimProcess::OpenSocket() with udp_id = %d\n",
27 udp_process_id);
28 #endif
29 UdpSocketProxy* udpProxy;
30 TcpSocketProxy* tcpProxy;
31 if (theSocket.GetProtocol() == theSocket.TCP)
32 {
33 tcpProxy = new TcpSocketProxy(this);
34 if (tcpProxy)
35 {
36 tcpProxy->AttachSocket(theSocket);
37 socket_proxy_list.Prepend(*tcpProxy);
38 return tcpProxy;
39 }
40 else
41 {
42 fprintf(stderr, "OpnetProtoSimProcess::OpenSocket() new SocketAgent error\n");
43 return NULL;
44 }
45 }
46 else
47 {
48 udpProxy = new UdpSocketProxy(this); // JPH
49 if (udpProxy)
50 {
51 udpProxy->AttachSocket(theSocket);
52 socket_proxy_list.Prepend(*udpProxy);
53 return udpProxy;
54 }
55 else
56 {
57 fprintf(stderr, "OpnetProtoSimProcess::OpenSocket() new SocketAgent error\n");
58 return NULL;
59 }
60 }
61 } // end OpnetProtoSimProcess::OpenSocket()
62
63 void OpnetProtoSimProcess::CloseSocket(ProtoSocket& theSocket)
64 {
65 #ifdef OP_DEBUG1
66 printf("\topnetProtosimProcess.pr.c - OpnetProtoSimProcess::CloseSocket()\n");
67 #endif
68 SocketProxy* socketProxy = static_cast<SocketProxy*>(theSocket.GetHandle());
69 // (TBD) Do we to do any OPNET cleanup here???
70 if (theSocket.GetProtocol() == theSocket.TCP)
71 {
72 ApiT_Tcp_App_Handle hndl = *(((TcpSocketProxy*)socketProxy)->sim_process->GetTcpHandle());
73 tcp_connection_close(hndl);
74 }
75 socket_proxy_list.Remove(*socketProxy);
76 } // end OpnetProtoSimProcess::CloseSocket()
77
78 void OpnetProtoSimProcess::OnReceive(int strm_indx) // JPH 4/11/06 added strm_indx
79 {
80 #ifdef OP_DEBUG1
81 printf("\topnetProtosimProcess.pr.c - OpnetProtoSimProcess::OnReceive()\n");
82 #endif
83 // Get packet from stream ZERO
84 Ici* iciPtr = op_intrpt_ici();
85 if (OPC_NIL != iciPtr)
86 {
87 // 1) Get packet dest port and find which local socket it goes to
88 int localPort;
89 int connId;
90 char iciformat[32];
91 op_ici_format(iciPtr,iciformat);
92 //if (!strcmp(iciformat,"tcp_status_ind_mgen"))
93 if (!strcmp(iciformat,"tcp_status_ind"))
94 {
95 /********* TCP ******************************/
96 op_ici_attr_get(iciPtr, "conn_id", &connId);
97 SocketProxy* socketProxy = socket_proxy_list.FindProxyByConn(connId);
98 if (socketProxy)
99 {
100 Packet* pkt = op_pk_get(strm_indx);
101
102 ReceivePacketMonitor(iciPtr, pkt);
103
104 char* recvData;
105 op_pk_fd_get(pkt, 0, &recvData);
106 // Get recv packet length
107 unsigned int recvLen = op_pk_bulk_size_get(pkt) / 8;
108 // Get source addr/port
109 //IpT_Address remoteAddr;
110 //op_ici_attr_get(iciPtr, "rem_addr", &remoteAddr);
111 //int remotePort;
112 //op_ici_attr_get(iciPtr, "rem_port", &remotePort);
113 //IpT_Address localAddr;
114 //op_ici_attr_get(iciPtr, "local_addr", &localAddr);
115 //op_ici_attr_get(iciPtr, "local_port", &localPort);
116 ProtoAddress srcAddr;
117 //srcAddr.SimSetAddress(remoteAddr);
118 //srcAddr.SetPort(remotePort);
119 ProtoAddress dstAddr;
120 //dstAddr.SimSetAddress(localAddr);
121 //dstAddr.SetPort(localPort);
122 // Pass packet content/info to socket proxy
123 static_cast<TcpSocketProxy*>(socketProxy)->OnReceive(recvData, recvLen, srcAddr, dstAddr);
124 op_prg_mem_free(recvData);
125 op_pk_destroy(pkt);
126 }
127 }
128 else if (!strcmp(iciformat,"udp_command_v3"))
129 {
130 /********* UDP ******************************/
131 op_ici_attr_get(iciPtr, "local_port", &localPort);
132 SocketProxy* socketProxy = socket_proxy_list.FindProxyByPort(localPort);
133 if (socketProxy)
134 {
135 Packet* pkt = op_pk_get(strm_indx); // JPH 4/11/06 added strm_indx
136
137 ReceivePacketMonitor(iciPtr, pkt); // JPH 2/16/06
138
139 // LP - 3-8-04 - added
140 //#ifdef OPNET_OLSR
141 // record_receiving_stat(Pkt);
142 //#endif // end LP
143 // Get recv packet payload
144 char* recvData;
145 op_pk_fd_get(pkt, 0, &recvData);
146 // Get recv packet length
147 int recvLen = op_pk_bulk_size_get(pkt) / 8;
148 // Get source addr/port
149 IpT_Address remoteAddr;
150 op_ici_attr_get(iciPtr, "rem_addr", &remoteAddr);
151 int remotePort;
152 op_ici_attr_get(iciPtr, "rem_port", &remotePort);
153 IpT_Address localAddr;
154
155 op_ici_attr_get(iciPtr, "src_addr", &localAddr);
156 #ifdef OP_DEBUG1
157 printf("\topnetProtosimProcess.pr.c - OpnetProtoSimProcess::OnReceive() - remoteAdd - %u, localAdrr = %u, rec_lgn = %d\n",
158 remoteAddr, localAddr, recvLen);
159 #endif
160 ProtoAddress srcAddr;
161 srcAddr.SimSetAddress(remoteAddr);
162 srcAddr.SetPort(remotePort);
163 ProtoAddress dstAddr;
164 dstAddr.SimSetAddress(localAddr);
165 dstAddr.SetPort(localPort);
166 // Pass packet content/info to socket proxy
167 static_cast<UdpSocketProxy*>(socketProxy)->OnReceive(recvData, recvLen, srcAddr, dstAddr);
168 op_prg_mem_free(recvData);
169 op_pk_destroy(pkt);
170 }
171 }
172 else if (!strcmp(iciformat,"sink_command"))
173 {
174 Packet* pkt = op_pk_get(strm_indx); // JPH 4/11/06 added strm_indx
175
176 ReceivePacketMonitor(iciPtr, pkt); // JPH 2/16/06
177
178 // Get recv packet payload
179 char* recvData;
180 op_pk_fd_get(pkt, 0, &recvData);
181 // Get recv packet length
182 int recvLen = op_pk_bulk_size_get(pkt) / 8;
183 // Get source addr/port
184 IpT_Address remoteAddr;
185 op_ici_attr_get(iciPtr, "rem_addr", &remoteAddr);
186 int remotePort;
187 op_ici_attr_get(iciPtr, "rem_port", &remotePort);
188 IpT_Address localAddr;
189
190 op_ici_attr_get(iciPtr, "src_addr", &localAddr);
191 #ifdef OP_DEBUG1
192 printf("\topnetProtosimProcess.pr.c - OpnetProtoSimProcess::OnReceive() - remoteAdd - %u, localAdrr = %u, rec_lgn = %d\n",
193 remoteAddr, localAddr, recvLen);
194 #endif
195 ProtoAddress srcAddr;
196 srcAddr.SimSetAddress(remoteAddr);
197 srcAddr.SetPort(remotePort);
198 ProtoAddress dstAddr;
199 dstAddr.SimSetAddress(localAddr);
200 dstAddr.SetPort(localPort);
201 // Pass packet content/info to mgen sink
202 HandleMgenMessage(recvData,recvLen,srcAddr);
203 op_prg_mem_free(recvData);
204 op_pk_destroy(pkt);
205 }
206 else
207 {
208 // Generate an error and end simulation.
209 op_sim_end ("Error: DoReceive() Unrecognized ici format", "", "", "");
210 }
211 }
212 else
213 {
214 // Generate an error and end simulation.
215 op_sim_end ("Error: DoReceive() OPC_NIL cmd", "", "", "");
216 }
217 } // end OpnetProtoSimProcess::OnReceive()
218
219
220
221 /**********************************************************************************************/
222 /************************** UdpSocketProxy *******************************************/
223
224
225 // LP 6-21-04 - replaced for new Ici parameter
226 /*
227 OpnetProtoSimProcess::UdpSocketProxy::UdpSocketProxy(Objid udpProcessId)
228 : udp_process_id(udpProcessId),
229 mcast_ttl(255), mcast_loopback(false),
230 recv_data(NULL), recv_data_len(0)
231 */
232 OpnetProtoSimProcess::UdpSocketProxy::UdpSocketProxy(OpnetProtoSimProcess* simProcess) // JPH
233 : sim_process(simProcess),
234 mcast_ttl(255), mcast_loopback(false),
235 recv_data(NULL), recv_data_len(0), udp_command_ici(NULL)
236
237 // end LP
238 {
239 #ifdef OP_DEBUG2
240 printf("\topnetProtosimProcess.pr.c - OpnetProtoSimProcess::UdpSocketProxy::UdpSocketProxy(udpId = %ld)\n",
241 udpProcessId);
242 #endif
243 }
244
245
246
247 OpnetProtoSimProcess::UdpSocketProxy::~UdpSocketProxy()
248 {
249 // LP 6-21-04 - added
250 op_ici_destroy (udp_command_ici);
251 // end LP
252 }
253
254
255
256 bool OpnetProtoSimProcess::UdpSocketProxy::Bind(UINT16& thePort)
257 {
258 #ifdef OP_DEBUG1
259 printf("\topnetProtosimProcess.pr.c - OpnetProtoSimProcess::UdpSocketProxy::Bind, udp_process_id = %d)\n",
260 sim_process->udp_process_id);
261 #endif
262 // (TBD) What happens if (0 == thePort) ???
263
264 // LP 6-21-04 - replaced for new Udp_command_ici
265 /*
266 Ici* cmd = op_ici_create("udp_command_v3");
267 op_ici_attr_set(cmd, "local_port", (int)thePort);
268 op_ici_install(cmd);
269 */
270 udp_command_ici = op_ici_create("udp_command_v3");
271 op_ici_attr_set(udp_command_ici, "local_port", (int)thePort);
272 op_ici_install(udp_command_ici);
273
274 // end LP
275
276 op_intrpt_force_remote(UDPC_COMMAND_CREATE_PORT, sim_process->GetUdpProcId()); // JPH
277 return true;
278 } // end OpnetProtoSimProcess::SocketAgent::Bind()
279
280
281
282
283 bool OpnetProtoSimProcess::UdpSocketProxy::SendTo(const char* buffer,
284 unsigned int& buflen,
285 const ProtoAddress& dstAddr)
286 {
287 #ifdef OP_DEBUG1
288 printf("\tOpnetProtoSimProcess::UdpSocketProxy::SendTo: local_port %d, rem_port %d, rem_addr_%u\n",
289 proto_socket->GetPort(), dstAddr.GetPort(), dstAddr.SimGetAddress()); // LP 2-10-04
290 #endif
291 // (TBD) error check Opnet API calls ...
292 Packet* pkt = op_pk_create(buflen*8);
293 char* payload = (char*) op_prg_mem_copy_create((void*)buffer, buflen);
294 op_pk_fd_set(pkt, 0, OPC_FIELD_TYPE_STRUCT, payload, 0,
295 op_prg_mem_copy_create, op_prg_mem_free, buflen);
296
297 // LP - the following can be set up later to be created once as a permanent member of
298 // the OpnetProtoSimProcess. Ici parameter can be updated anytime later when it
299 // is used. That will help to reduce the time to create Ici, then deleted at UDP
300
301 // LP 6-21-04 - replaced to reduce memory usage
302 /*
303 Ici* cmd = op_ici_create("udp_command_v3");
304 op_ici_attr_set(cmd, "local_port", proto_socket->GetPort());
305 op_ici_attr_set(cmd, "rem_port", dstAddr.GetPort());
306 op_ici_attr_set(cmd, "rem_addr", dstAddr.SimGetAddress());
307 op_ici_install(cmd);
308 */
309
310 op_ici_attr_set(udp_command_ici, "local_port", proto_socket->GetPort());
311 op_ici_attr_set(udp_command_ici, "rem_port", dstAddr.GetPort());
312 op_ici_attr_set(udp_command_ici, "rem_addr", dstAddr.SimGetAddress());
313 op_ici_install(udp_command_ici);
314
315 // end LP
316
317 sim_process->TransmitPacketMonitor(udp_command_ici, pkt); // JPH
318
319 op_pk_send_forced(pkt, 0);
320 return true;
321 } // end OpnetProtoSimProcess::UdpSocketProxy::SendTo()
322
323
324
325 bool OpnetProtoSimProcess::UdpSocketProxy::RecvFrom(char* buffer,
326 unsigned int& numBytes,
327 ProtoAddress& srcAddr)
328 {
329 #ifdef OP_DEBUG1
330 printf("\tOpnetProtoSimProcess::UdpSocketProxy::RecvFrom\n");
331 #endif
332 if (recv_data)
333 {
334 if (numBytes >= recv_data_len)
335 {
336 numBytes = recv_data_len;
337
338 memcpy(buffer, recv_data, numBytes);
339 op_prg_mem_free (recv_data); // LP 6-25-04 - added
340 srcAddr = src_addr;
341 recv_data = NULL;
342 recv_data_len = 0;
343 return true;
344 }
345 else
346 {
347 PLOG(PL_ERROR, "OpnetProtoSimProcess::UdpSocketProxy::RecvFrom buffer too small\n");
348 numBytes = 0;
349 return false;
350 }
351 }
352 else
353 {
354 PLOG(PL_WARN, "OpnetProtoSimProcess::UdpSocketProxy::RecvFrom no data ready\n");
355 numBytes = 0;
356 return false;
357 }
358 } // end OpnetProtoSimProcess::UdpSocketProxy::RecvFrom()
359
360
361
362 bool OpnetProtoSimProcess::UdpSocketProxy::JoinGroup(const ProtoAddress& groupAddr)
363 {
364 // (TBD)
365 return true;
366 } // end OpnetProtoSimProcess::SocketAgent::JoinGroup()
367
368
369 bool OpnetProtoSimProcess::UdpSocketProxy::LeaveGroup(const ProtoAddress& groupAddr)
370 {
371 // (TBD)
372 return true;
373 } // end OpnetProtoSimProcess::SocketAgent::LeaveGroup()
374
375
376 void OpnetProtoSimProcess::UdpSocketProxy::OnReceive(char* recvData,
377 unsigned int recvLen,
378 const ProtoAddress& srcAddr,
379 const ProtoAddress& dstAddr)
380 {
381 #ifdef OP_DEBUG1
382 printf("\tOpnetProtoSimProcess::UdpSocketProxy::OnReceive - RecvLen = %u\n", recvLen); // LP 6-8-04
383 #endif
384 // (TBD) filter out loopback multicast traffic
385
386 // LP 6-10-04 - replaced
387 // recv_data = recvData;
388 recv_data = (char*) op_prg_mem_copy_create((void*)recvData, recvLen);
389
390 // end LP
391
392 recv_data_len = recvLen;
393 src_addr = srcAddr;
394 if (proto_socket)
395 proto_socket->OnNotify(ProtoSocket::NOTIFY_INPUT);
396 } // end OpnetProtoSimProcess::UdpSocketProxy::OnReceive()
397
398
399
400
401 /**********************************************************************************************/
402 /************************** TcpSocketProxy *******************************************/
403
404
405 OpnetProtoSimProcess::TcpSocketProxy::TcpSocketProxy(OpnetProtoSimProcess* simProcess)
406 : sim_process(simProcess),
407 recv_data(NULL), recv_data_len(0), tcp_command_ici(NULL)
408 {
409 #ifdef OP_DEBUG2
410 printf("\topnetProtosimProcess.pr.c - OpnetProtoSimProcess::TcpSocketProxy::TcpSocketProxy()\n");
411 #endif
412 }
413
414
415 OpnetProtoSimProcess::TcpSocketProxy::~TcpSocketProxy()
416 {
417 op_ici_destroy (tcp_command_ici);
418 }
419
420
421 bool OpnetProtoSimProcess::TcpSocketProxy::Bind(UINT16& thePort)
422 {
423 local_port = thePort;
424 return true;
425 }
426
427
428 bool OpnetProtoSimProcess::TcpSocketProxy::Connect(const ProtoAddress& dstAddr)
429 {
430 // Open an active connection to dstAddr.
431 ApiT_Tcp_App_Handle* hndl_ptr = sim_process->GetTcpHandle();
432 IpT_Address rem_addr = dstAddr.SimGetAddress();
433 TcpT_Port rem_port = GetPort(); // Assume that the remote port number is the same as the local port number.
434 IpT_Address local_addr = GetTcpHostAddress().SimGetAddress();
435 TcpT_Port loc_port = GetPort();
436 int command = TCPC_COMMAND_OPEN_ACTIVE;
437 int ip_qos = 0;
438 int tcp_conn_id =
439 tcp_connection_with_source_open (hndl_ptr, rem_addr, rem_port, local_addr, loc_port, command, ip_qos);
440 if (tcp_conn_id == TCPC_CONN_ID_INVALID)
441 return false;
442 else
443 {
444 proto_socket->SetState(ProtoSocket::CONNECTED);
445 //tcp_receive_command_send(hndl,1);
446 conn_id = tcp_conn_id;
447 return true;
448 }
449 }
450
451
452 bool OpnetProtoSimProcess::TcpSocketProxy::Accept(ProtoSocket* theSocket)
453 {
454 theSocket->GetDestination() = GetTcpRemAddress(); // Set src address logged by CONNECT
455 ProtoSocket* socket = GetSocket();
456 socket->GetDestination() = GetTcpRemAddress(); // Set src address logged by RECV
457 return true;
458 }
459
460
461 bool OpnetProtoSimProcess::TcpSocketProxy::Listen(UINT16 thePort)
462 {
463 // Open a passive connection.
464 ApiT_Tcp_App_Handle* hndl_ptr = sim_process->GetTcpHandle();
465 IpT_Address rem_addr = 0;
466 TcpT_Port rem_port = TCPC_PORT_UNSPEC;
467 IpT_Address local_addr = GetTcpHostAddress().SimGetAddress();
468 TcpT_Port loc_port = GetPort();
469 int command = TCPC_COMMAND_OPEN_PASSIVE;
470 int ip_qos = 0;
471 int tcp_conn_id =
472 tcp_connection_with_source_open (hndl_ptr, rem_addr, rem_port, local_addr, loc_port, command, ip_qos);
473 if (tcp_conn_id == TCPC_CONN_ID_INVALID)
474 return false;
475 else
476 {
477 tcp_receive_command_send(*hndl_ptr,1);
478 conn_id = tcp_conn_id;
479 return true;
480 }
481 }
482
483
484 bool OpnetProtoSimProcess::TcpSocketProxy::SendTo(const char* buffer,
485 unsigned int& buflen,
486 const ProtoAddress& dstAddr)
487 {
488 ApiT_Tcp_App_Handle* hndl_ptr = sim_process->GetTcpHandle();
489 Packet* pkt = op_pk_create(buflen*8);
490 char* payload = (char*) op_prg_mem_copy_create((void*)buffer, buflen);
491 op_pk_fd_set(pkt, 0, OPC_FIELD_TYPE_STRUCT, payload, 0,
492 op_prg_mem_copy_create, op_prg_mem_free, buflen);
493 Ici* dummy_ici;
494 sim_process->TransmitPacketMonitor(dummy_ici, pkt); // JPH
495 tcp_data_send(*hndl_ptr,pkt);
496 return true;
497 }
498
499
500 bool OpnetProtoSimProcess::TcpSocketProxy::Send(const char* buffer,
501 unsigned int& numBytes)
502 {
503 // Dummy
504 return false;
505 }
506
507
508 bool OpnetProtoSimProcess::TcpSocketProxy::RecvFrom(char* buffer,
509 unsigned int& numBytes,
510 ProtoAddress& srcAddr)
511 {
512 if (recv_data)
513 {
514 if (numBytes >= recv_data_len)
515 {
516 numBytes = recv_data_len;
517
518 memcpy(buffer, recv_data, numBytes);
519 op_prg_mem_free (recv_data);
520 srcAddr = src_addr;
521 recv_data = NULL;
522 recv_data_len = 0;
523 return true;
524 }
525 else
526 {
527 PLOG(PL_ERROR, "OpnetProtoSimProcess::TcpSocketProxy::RecvFrom buffer too small\n");
528 numBytes = 0;
529 return false;
530 }
531 }
532 else
533 {
534 PLOG(PL_WARN, "OpnetProtoSimProcess::TcpSocketProxy::RecvFrom no data ready\n");
535 numBytes = 0;
536 return false;
537 }
538 }
539
540
541 bool OpnetProtoSimProcess::TcpSocketProxy::Recv(char* buffer,
542 unsigned int& numBytes)
543 {
544 ApiT_Tcp_App_Handle* hndl_ptr = sim_process->GetTcpHandle();
545 tcp_receive_command_send(*hndl_ptr,1);
546 recv_data = (char*) op_prg_mem_copy_create((void*)buffer, numBytes);
547
548 recv_data_len = numBytes;
549 if (proto_socket)
550 proto_socket->OnNotify(ProtoSocket::NOTIFY_INPUT);
551 return true;
552 }
553
554
555 void OpnetProtoSimProcess::TcpSocketProxy::OnReceive(char* recvData,
556 unsigned int recvLen,
557 const ProtoAddress& srcAddr,
558 const ProtoAddress& dstAddr)
559 {
560 ApiT_Tcp_App_Handle* hndl_ptr = sim_process->GetTcpHandle();
561 tcp_receive_command_send(*hndl_ptr,1);
562 recv_data = (char*) op_prg_mem_copy_create((void*)recvData, recvLen);
563 recv_data_len = recvLen;
564 src_addr = srcAddr;
565 if (proto_socket)
566 proto_socket->OnNotify(ProtoSocket::NOTIFY_INPUT);
567 } // end OpnetProtoSimProcess::TcpSocketProxy::OnReceive()
568
569
570 bool OpnetProtoSimProcess::TcpSocketProxy::JoinGroup(const ProtoAddress& groupAddr)
571 {
572 // definition of virtual function needed
573 return true;
574 } // end OpnetProtoSimProcess::SocketAgent::JoinGroup()
575
576
577 bool OpnetProtoSimProcess::TcpSocketProxy::LeaveGroup(const ProtoAddress& groupAddr)
578 {
579 // definition of virtual function needed
580 return true;
581 } // end OpnetProtoSimProcess::SocketAgent::LeaveGroup()
582
583
584 ProtoSimAgent::SocketProxy* OpnetProtoSimProcess::TcpSocketProxy::TcpSockList::FindProxyByConn(int connId)
585 {
586 TcpSocketProxy* next = (TcpSocketProxy*)SocketProxy::List::head;
587 while (next)
588 {
589 if (next->GetConn() == connId)
590 return (SocketProxy*)next;
591 else
592 next = (TcpSocketProxy*)next->GetNext();
593 }
594 return NULL;
595 } // end OpnetProtoSimProcess::TcpSocketProxy::TcpSockList::FindProxyByConn()
596
597
598