Debian Codegraph @

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