#include <cSocketRTScheduler.h>

Inheritance diagram for inet::cSocketRTScheduler:

Public Member Functions
	cSocketRTScheduler ()
	Constructor. More...

virtual	~cSocketRTScheduler ()
	Destructor. More...

virtual void	startRun () override
	Called at the beginning of a simulation run. More...

virtual void	endRun () override
	Called at the end of a simulation run. More...

virtual void	executionResumed () override
	Recalculates "base time" from current wall clock time. More...

void	setInterfaceModule (cModule mod, const char dev, const char *filter)
	To be called from the module which wishes to receive data from the socket. More...

virtual cEvent *	guessNextEvent () override
	Returns the first event in the Future Event Set. More...

virtual cEvent *	takeNextEvent () override
	Scheduler function – it comes from the cScheduler interface. More...

virtual void	putBackEvent (cEvent *event) override
	Scheduler function – it comes from the cScheduler interface. More...

void	sendBytes (unsigned char buf, size_t numBytes, struct sockaddr from, socklen_t addrlen)
	Send on the currently open connection. More...

Static Public Attributes
static std::vector< cModule * >	modules

static std::vector< pcap_t * >	pds

static std::vector< int >	datalinks

static std::vector< int >	headerLengths

static timeval	baseTime

Protected Member Functions
virtual bool	receiveWithTimeout (long usec)

virtual int	receiveUntil (const timeval &targetTime)

Protected Attributes
int	fd

Constructor & Destructor Documentation

inet::cSocketRTScheduler::cSocketRTScheduler ( )

Constructor.

                                        : cScheduler()
 {
     fd = INVALID_SOCKET;
 }

inet::cSocketRTScheduler::~cSocketRTScheduler ( )

virtual

Destructor.

70 {

71 }

Member Function Documentation

void inet::cSocketRTScheduler::endRun ( )

overridevirtual

Called at the end of a simulation run.

 {
     close(fd);
     fd = INVALID_SOCKET;
 
     for (uint16 i = 0; i < pds.size(); i++) {
         pcap_stat ps;
         if (pcap_stats(pds.at(i), &ps) < 0)
             throw cRuntimeError("cSocketRTScheduler::endRun(): Cannot query pcap statistics: %s", pcap_geterr(pds.at(i)));
         else
             EV << modules.at(i)->getFullPath() << ": Received Packets: " << ps.ps_recv << " Dropped Packets: " << ps.ps_drop << ".\n";
         pcap_close(pds.at(i));
     }
 
     pds.clear();
     modules.clear();
     pds.clear();
     datalinks.clear();
     headerLengths.clear();
 }

void inet::cSocketRTScheduler::executionResumed ( )

overridevirtual

Recalculates "base time" from current wall clock time.

 {
     gettimeofday(&baseTime, nullptr);
     baseTime = timeval_substract(baseTime, sim->getSimTime().dbl());
 }

cEvent * inet::cSocketRTScheduler::guessNextEvent ( )

overridevirtual

Returns the first event in the Future Event Set.

 {
     return FES(sim)->peekFirst();
 }

void inet::cSocketRTScheduler::putBackEvent ( cEvent * event )

overridevirtual

Scheduler function – it comes from the cScheduler interface.

 {
     FES(sim)->putBackFirst(event);
 }

int inet::cSocketRTScheduler::receiveUntil ( const timeval & targetTime )

protectedvirtual

Referenced by takeNextEvent().

 {
     // if there's more than 2*UI_REFRESH_TIME to wait, wait in UI_REFRESH_TIME chunks
     // in order to keep UI responsiveness by invoking getEnvir()->idle()
     timeval curTime;
     gettimeofday(&curTime, nullptr);
     while (targetTime.tv_sec-curTime.tv_sec >=2 ||
            timeval_diff_usec(targetTime, curTime) >= 2*UI_REFRESH_TIME)
     {
         if (receiveWithTimeout(UI_REFRESH_TIME))
             return 1;
         if (getEnvir()->idle())
             return -1;
         gettimeofday(&curTime, nullptr);
     }
 
     // difference is now at most UI_REFRESH_TIME, do it at once
     long usec = timeval_diff_usec(targetTime, curTime);
     if (usec>0)
         if (receiveWithTimeout(usec))
             return 1;
     return 0;
 }

bool inet::cSocketRTScheduler::receiveWithTimeout ( long usec )

protectedvirtual

Referenced by receiveUntil().

 {
     bool found;
     struct timeval timeout;
     int32 n;
 #ifdef __linux__
     int32 fd[FD_SETSIZE], maxfd;
     fd_set rdfds;
 #endif
 
     found = false;
     timeout.tv_sec = 0;
     timeout.tv_usec = usec;
 #ifdef __linux__
     FD_ZERO(&rdfds);
     maxfd = -1;
     for (uint16 i = 0; i < pds.size(); i++) {
         fd[i] = pcap_get_selectable_fd(pds.at(i));
         if (fd[i] > maxfd)
             maxfd = fd[i];
         FD_SET(fd[i], &rdfds);
     }
     if (select(maxfd + 1, &rdfds, nullptr, nullptr, &timeout) < 0) {
         return found;
     }
 #endif
     for (uint16 i = 0; i < pds.size(); i++) {
 #ifdef __linux__
         if (!(FD_ISSET(fd[i], &rdfds)))
             continue;
 #endif // ifdef __linux__
         if ((n = pcap_dispatch(pds.at(i), 1, packet_handler, (uint8 *)&i)) < 0)
             throw cRuntimeError("cSocketRTScheduler::pcap_dispatch(): An error occured: %s", pcap_geterr(pds.at(i)));
         if (n > 0)
             found = true;
     }
 #ifndef __linux__
     if (!found)
         select(0, nullptr, nullptr, nullptr, &timeout);
 #endif
     return found;
 }

void inet::cSocketRTScheduler::sendBytes	(	unsigned char *	buf,
		size_t	numBytes,
		struct sockaddr *	from,
		socklen_t	addrlen
	)

Send on the currently open connection.

Referenced by inet::ExtInterface::handleMessage().

 {
     if (fd == INVALID_SOCKET)
         throw cRuntimeError("cSocketRTScheduler::sendBytes(): no raw socket.");
 
     int sent = sendto(fd, (char *)buf, numBytes, 0, to, addrlen);    //note: no ssize_t on MSVC
 
     if ((size_t)sent == numBytes)
         EV << "Sent an IP packet with length of " << sent << " bytes.\n";
     else
         EV << "Sending of an IP packet FAILED! (sendto returned " << sent << " (" << strerror(errno) << ") instead of " << numBytes << ").\n";
 }

void inet::cSocketRTScheduler::setInterfaceModule	(	cModule *	mod,
		const char *	dev,
		const char *	filter
	)

To be called from the module which wishes to receive data from the socket.

The method must be called from the module's initialize() function.

Referenced by inet::ExtInterface::initialize().

 {
     char errbuf[PCAP_ERRBUF_SIZE];
     struct bpf_program fcode;
     pcap_t *pd;
     int32 datalink;
     int32 headerLength;
 
     if (!mod || !dev || !filter)
         throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): arguments must be non-nullptr");
 
     /* get pcap handle */
     memset(&errbuf, 0, sizeof(errbuf));
     if ((pd = pcap_create(dev, errbuf)) == nullptr)
         throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): Cannot create pcap device, error = %s", errbuf);
     else if (strlen(errbuf) > 0)
         EV << "cSocketRTScheduler::setInterfaceModule(): pcap_open_live returned warning: " << errbuf << "\n";
 
     /* apply the immediate mode to pcap */
     if (pcap_set_immediate_mode(pd, 1) != 0)
             throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): Cannot set immediate mode to pcap device");
 
     if (pcap_activate(pd) != 0)
         throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): Cannot activate pcap device");
 
     /* compile this command into a filter program */
     if (pcap_compile(pd, &fcode, (char *)filter, 0, 0) < 0)
         throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): Cannot compile pcap filter: %s", pcap_geterr(pd));
 
     /* apply the compiled filter to the packet capture device */
     if (pcap_setfilter(pd, &fcode) < 0)
         throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): Cannot apply compiled pcap filter: %s", pcap_geterr(pd));
 
     if ((datalink = pcap_datalink(pd)) < 0)
         throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): Cannot query pcap link-layer header type: %s", pcap_geterr(pd));
 
 #ifndef __linux__
     if (pcap_setnonblock(pd, 1, errbuf) < 0)
         throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): Cannot put pcap device into non-blocking mode, error: %s", errbuf);
 #endif
 
     switch (datalink) {
         case DLT_NULL:
             headerLength = 4;
             break;
 
         case DLT_EN10MB:
             headerLength = 14;
             break;
 
         case DLT_SLIP:
             headerLength = 24;
             break;
 
         case DLT_PPP:
             headerLength = 24;
             break;
 
         default:
             throw cRuntimeError("cSocketRTScheduler::setInterfaceModule(): Unsupported datalink: %d", datalink);
     }
     modules.push_back(mod);
     pds.push_back(pd);
     datalinks.push_back(datalink);
     headerLengths.push_back(headerLength);
 
     EV << "Opened pcap device " << dev << " with filter " << filter << " and datalink " << datalink << ".\n";
 }

void inet::cSocketRTScheduler::startRun ( )

overridevirtual

Called at the beginning of a simulation run.

 {
     gettimeofday(&baseTime, nullptr);
 
     // Enabling sending makes no sense when we can't receive...
     fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
     if (fd == INVALID_SOCKET)
         throw cRuntimeError("cSocketRTScheduler: Root privileges needed");
     const int32 on = 1;
     if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on)) < 0)
         throw cRuntimeError("cSocketRTScheduler: couldn't set sockopt for raw socket");
 }

cEvent * inet::cSocketRTScheduler::takeNextEvent ( )

overridevirtual

Scheduler function – it comes from the cScheduler interface.

 {
     timeval targetTime;
 
     // calculate target time
     cEvent *event = FES(sim)->peekFirst();
     if (!event) {
         targetTime.tv_sec = LONG_MAX;
         targetTime.tv_usec = 0;
     }
     else {
         // use time of next event
         simtime_t eventSimtime = event->getArrivalTime();
         targetTime = timeval_add(baseTime, eventSimtime.dbl());
     }
 
     // if needed, wait until that time arrives
     timeval curTime;
     gettimeofday(&curTime, nullptr);
     if (timeval_greater(targetTime, curTime))
     {
         int status = receiveUntil(targetTime);
         if (status == -1)
             return nullptr; // interrupted by user
         if (status == 1)
             event = FES(sim)->peekFirst(); // received something
     }
     else {
         // we're behind -- customized versions of this class may
         // alert if we're too much behind, whatever that means
         timeval diffTime = timeval_substract(curTime, targetTime);
         EV << "We are behind: " << diffTime.tv_sec + diffTime.tv_usec * 1e-6 << " seconds\n";
     }
     cEvent *tmp = FES(sim)->removeFirst();
     ASSERT(tmp == event);
     return event;
 }