Host.cpp

Go to the documentation of this file.

#include "stdinc.h"
#include "Host.h"

using namespace forest;


int main(int argc, char *argv[]) {
                ipa_t myIpAdr, rtrIpAdr;
                int repeatFlag, delta, finTime;

                if (argc != 6 ||
                    (myIpAdr = Np4d::ipAddress(argv[1])) == 0 ||
                    (rtrIpAdr = Np4d::ipAddress(argv[2])) == 0 ||
                    sscanf(argv[3],"%d", &repeatFlag) != 1 ||
                    sscanf(argv[4],"%d", &delta) != 1 ||
                    sscanf(argv[5],"%d", &finTime) != 1)
                                fatal("usage: fHost myIpAdr routerIpAdr repeatCnt "
                                      "delta finTime");

                Host host(myIpAdr,rtrIpAdr);
                if (!host.init()) fatal("Host:: initialization failure");
                host.run((repeatFlag ? true : false), delta, 1000000*finTime);
}

namespace forest {

// Constructor for Host, allocates space and initializes private data
Host::Host(ipa_t mipa, ipa_t ripa) : myIpAdr(mipa) , rtrIpAdr(ripa) {
                nPkts = 10000;
                ps = new PacketStore(nPkts+1, nPkts+1);
}

Host::~Host() { delete ps; }

bool Host::init() {
                sock = Np4d::datagramSocket();

                return  sock >= 0 &&
                Np4d::bind4d(sock, myIpAdr, 0) &&
                                Np4d::nonblock(sock);
}

void Host::run(bool repeatFlag, uint32_t delta, uint32_t finishTime) {
// Run the host. If repeatFlag is false, then all repeat specifications
// are ignored. Delta is the minimum time between packets.
// FinishTime and delta are expressed in microseconds.

                int i, pause, cnt, np;
                pktx px;
                const int MAXEVENTS = 200;
                struct { bool sendFlag; uint32_t time; int pkt;} events[MAXEVENTS];
                int evCnt = 0;
                int nRcvd = 0; int nSent = 0;   // counts of received and sent packets
                bool didNothing;
                struct { int pause, p, cnt, iter; } pkt[nPkts+1];

                // read packets from file into packetStore
                np = 0;
                while (np < nPkts) {
                                px = ps->alloc();
                                if (px == Null) fatal("Host::run: too many packets");
                                if (!readPacket(px,pause,cnt)) break;
                                pkt[np].pause = pause;
                                if (pause >= 0) {
                                                pkt[np++].p = px;
                                } else if (repeatFlag) {
                                                if (pause + np < 0) pause = -np;
                                                pkt[np].cnt = cnt; pkt[np++].iter = cnt;
                                                ps->free(px);
                                } else {
                                                ps->free(px);
                                }
                }
                if (np == 0) return;

                uint32_t now;                   // free-running microsecond count
                uint32_t nextTime;              // time next packet is to go out
                struct timeval ct, pt; // current and previous time values
                if (gettimeofday(&ct, NULL) < 0)
                                fatal("Host::run: gettimeofday failure");
                i = 0;          // index in pkt[] of next outgoing packet
                now = 0; nextTime = 1000000;
                while (now <= finishTime) {
                                // receive packet if any and record statistics
                                didNothing = true;
                                // input processing
                                px = receive();
                                Packet& p = ps->getPacket(px);
                                if (px != Null) {
                                                didNothing = false;
                                                nRcvd++;
                                                p.unpack();
                                                if (evCnt < MAXEVENTS) {
                                                                events[evCnt].sendFlag = false;
                                                                events[evCnt].time = now;
                                                                events[evCnt].pkt = px;
                                                                evCnt++;
                                                } else {
                                                                ps->free(px);
                                                }
                                }

                                // send next packet
                                if (i < np && now >= nextTime) {
                                                send(pkt[i].p);
                                                didNothing = false;
                                                nSent++;
                                                if (evCnt < MAXEVENTS) {
                                                                pktx px1 = ps->clone(pkt[i].p);
                                                                events[evCnt].sendFlag = true;
                                                                events[evCnt].time = now;
                                                                events[evCnt].pkt = px1;
                                                                evCnt++;
                                                }
                                                i++;
                                                while (i < np && pkt[i].pause < 0) { // repeat spec
                                                                if (pkt[i].cnt <= 0) { // repeat forever
                                                                                i += pkt[i].pause;
                                                                } else if (pkt[i].iter <= 0) {
                                                                                pkt[i].iter = pkt[i].cnt;
                                                                                i += 1;
                                                                } else {
                                                                                pkt[i].iter -= 1;
                                                                                i += pkt[i].pause;
                                                                }
                                                }
                                                if (i < np) nextTime += max(delta,pkt[i].pause);
                                }
                                // update time variables
                                pt = ct;
                                if (gettimeofday(&ct,Null) < 0)
                                                fatal("Host::run: gettimeofday failure");
                                now += (ct.tv_sec == pt.tv_sec ?
                           ct.tv_usec - pt.tv_usec :
                           ct.tv_usec + (1000000 - pt.tv_usec)
                                                );
                                if (!didNothing) continue;

                                // if next packet not due to go soon, sleep until almost time
                                if (now + 500 >= nextTime) continue;
                                struct timespec sleeptime, rem;
                                sleeptime.tv_sec = 0;
                                if (nextTime - (now + 500) < 2500)
                                                sleeptime.tv_nsec = (nextTime - (now + 500))*1000;
                                else
                                                sleeptime.tv_nsec = 2500000;
                                nanosleep(&sleeptime,&rem);
                                // update time variables again following sleep
                                pt = ct;
                                if (gettimeofday(&ct,Null) < 0)
                                                fatal("Host::run: gettimeofday failure");
                                now += (ct.tv_sec == pt.tv_sec ?
                           ct.tv_usec - pt.tv_usec :
                           ct.tv_usec + (1000000 - pt.tv_usec)
                                                );
                }

                // print recorded events
                for (int i = 0; i < evCnt; i++) {
                                if (events[i].sendFlag) 
                                                cout << "send[";
                                else
                                                cout << "recv[";
                                cout << setw(2) << setw(8) << events[i].time << "] ";
                                px = events[i].pkt;
                                string s;
                                Packet& p = ps->getPacket(px);
                                cout << p.toString(s);
                }
                cout << endl;
                cout << nRcvd << " packets received, " << nSent << " packets sent, "; 
}

bool Host::readPacket(pktx px, int& pause, int& cnt) {
// Read an input packet from stdin and return it in p.
        Misc::skipBlank(cin);
        if (!Misc::readNum(cin,pause)) return false;
        if (pause < 0) {
                if (!Misc::readNum(cin,cnt)) cnt = 0;
                Misc::cflush(cin,'\n');
                return true;
        }
        Packet& p = ps->getPacket(px);
        bool success = p.read(cin);
        Misc::cflush(cin,'\n');
        return success;
}

void Host::send(pktx px) {
// Send packet and recycle storage.
                Packet& p = ps->getPacket(px);
                int rv = Np4d::sendto4d(sock,(void *) p.buffer, p.length,
                                                                rtrIpAdr, Forest::ROUTER_PORT);
                if (rv == -1) fatal("Host::send: failure in sendto");
}

int Host::receive() { 
// Return next waiting packet or Null if there is none. 
                int nbytes;       // number of bytes in received packet

                pktx px = ps->alloc();
                if (px == Null) return Null;
                Packet& p = ps->getPacket(px);

                ipa_t remoteIp; ipp_t remotePort;
        nbytes = Np4d::recvfrom4d(sock, p.buffer, 1500,
                                  remoteIp, remotePort);
        if (nbytes < 0) {
                if (errno == EWOULDBLOCK) {
                        ps->free(px); return Null;
                }
                fatal("Host::receive: error in recvfrom call");
        }

        p.bufferLen = nbytes;
        p.tunIp = remoteIp;
        p.tunPort = remotePort;

        return px;
}

} // ends namespace