win32.c

/* * Copyright (c) 1996 The Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Network Research * Group at Lawrence Berkeley National Laboratory. * 4. Neither the name of the University nor of the Laboratory may be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * This module contributed by John Brezak <brezak@apollo.hp.com>. * January 31, 1996 * * @(#) $Header$ (LBL) */ #ifdef WIN32 #include <assert.h> #include <io.h> #include <process.h> #include <fcntl.h> #include <windows.h> #include <malloc.h> #include <string.h> #include <stdio.h> #include <time.h> #include <winsock.h> #include <tcl.h> #include "config.h" #include <locale.h> /* forward declarations */ int WinGetUserName(ClientData, Tcl_Interp*, int ac, char**av); int WinGetHostName(ClientData, Tcl_Interp*, int ac, char**av); int WinPutRegistry(ClientData, Tcl_Interp*, int ac, char**av); int WinGetRegistry(ClientData, Tcl_Interp*, int ac, char**av); void TkConsoleCreate(); int TkConsoleInit(Tcl_Interp* interp); int uname(struct utsname *ub) { char *ptr; DWORD version; SYSTEM_INFO sysinfo; char hostname[4096]; version = GetVersion(); GetSystemInfo(&sysinfo); switch (sysinfo.wProcessorArchitecture) { case PROCESSOR_ARCHITECTURE_INTEL: (void)strcpy(ub->machine, "ix86"); break; case PROCESSOR_ARCHITECTURE_MIPS : (void)strcpy(ub->machine, "mips"); break; case PROCESSOR_ARCHITECTURE_ALPHA: (void)strcpy(ub->machine, "alpha"); break; case PROCESSOR_ARCHITECTURE_PPC: (void)strcpy(ub->machine, "ppc"); break; default: (void)strcpy(ub->machine, "unknown"); break; } if (version < 0x80000000) { (void)strcpy(ub->version, "NT"); } else if (LOBYTE(LOWORD(version))<4) { (void)strcpy(ub->version, "Win32s"); } else /* Win95 */ { (void)strcpy(ub->version, "Win95"); } (void)sprintf(ub->release, "%u.%u", (DWORD)(LOBYTE(LOWORD(version))), (DWORD)(HIBYTE(LOWORD(version)))); (void)strcpy(ub->sysname, "Windows"); if (gethostname(hostname, sizeof(hostname)) == 0) { if (ptr = strchr(hostname, '.')) *ptr = '\0'; } else { perror("uname: gethostname failed"); strcpy(hostname, "FAILURE"); } strncpy(ub->nodename, hostname, sizeof(ub->nodename)); ub->nodename[_SYS_NMLN - 1] = '\0'; return 0; } int strcasecmp(const char *s1, const char *s2) { return stricmp(s1, s2); } uid_t getuid(void) { return 1; } gid_t getgid(void) { return 0; } int gethostid(void) { /*XXX*/ return 0; } __inline int nice(int pri) { return 0; } extern void TkWinXInit(HINSTANCE hInstance); extern int main(int argc, const char *argv[]); extern int __argc; extern char **__argv; static char argv0[255]; /* Buffer used to hold argv0. */ char *__progname = "mash"; void ShowMessage(int level, char *msg) { MessageBeep(level); MessageBox(NULL, msg, __progname, level | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND); } int SetupConsole() { /* * stuff from knowledge base Q105305 (see that for details) * open a console and do the work around to get the console to work in all * cases */ int hCrt; FILE *hf=0; const COORD screenSz = {80, 5000}; /* size of console buffer */ AllocConsole(); hf=0; hCrt = _open_osfhandle( (long)GetStdHandle(STD_OUTPUT_HANDLE), _O_TEXT); if (hCrt!=-1) hf = _fdopen(hCrt, "w"); if (hf!=0) *stdout = *hf; if (hCrt==-1 || hf==0 || 0!=setvbuf(stdout, NULL, _IONBF, 0)) { ShowMessage(MB_ICONINFORMATION, "unable to mount reroute stdout"); return FALSE; } SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), screenSz); hf=0; hCrt = _open_osfhandle( (long)GetStdHandle(STD_ERROR_HANDLE), _O_TEXT); if (hCrt!=-1) hf = _fdopen(hCrt, "w"); if (hf!=0) *stderr = *hf; if (hCrt==-1 || hf==0 || 0!=setvbuf(stderr, NULL, _IONBF, 0)) { ShowMessage(MB_ICONINFORMATION, "reroute stderr failed in SetupConsole"); return FALSE; } hf=0; hCrt = _open_osfhandle((long)GetStdHandle(STD_INPUT_HANDLE), _O_TEXT); if (hCrt!=-1) hf = _fdopen(hCrt, "r"); if (hf!=0) *stdin = *hf; if (hCrt==-1 || hf==0 || 0!=setvbuf(stdin, NULL, _IONBF, 0)) { ShowMessage(MB_ICONINFORMATION, "reroute stdin failed in SetupConsole"); return FALSE; } return TRUE; } int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) { char *p; WSADATA WSAdata; int retcode; setlocale(LC_ALL, "C"); /* XXX * initialize our socket interface plus the tcl 7.5 socket * interface (since they redefine some routines we call). * eventually we should just call the tcl sockets but at * the moment that's hard to set up since they only support * tcp in the notifier. */ if (WSAStartup(MAKEWORD (1, 1), &WSAdata)) { perror("Windows Sockets init failed"); abort(); } /* TclHasSockets(NULL); TkWinXInit(hInstance); */ /* * Increase the application queue size from default value of 8. * At the default value, cross application SendMessage of WM_KILLFOCUS * will fail because the handler will not be able to do a PostMessage! * This is only needed for Windows 3.x, since NT dynamically expands * the queue. */ SetMessageQueue(64); GetModuleFileName(NULL, argv0, 255); p = argv0; __progname = strrchr(p, '/'); if (__progname != NULL) { __progname++; } else { __progname = strrchr(p, '\\'); if (__progname != NULL) { __progname++; } else { __progname = p; } } if (__argc>1) { SetupConsole(); } retcode=main(__argc, (const char**)__argv); if (retcode!=0) { assert(FALSE); /* don't die without letting user know why */ } return retcode; } #if 0 static char szTemp[4096]; int printf(const char *fmt, ...) { int retval; va_list ap; va_start (ap, fmt); retval = vsprintf(szTemp, fmt, ap); OutputDebugString(szTemp); ShowMessage(MB_ICONINFORMATION, szTemp); va_end (ap); return(retval); } int fprintf(FILE *f, const char *fmt, ...) { int retval; va_list ap; va_start (ap, fmt); if (f == stderr) { retval = vsprintf(szTemp, fmt, ap); OutputDebugString(szTemp); ShowMessage(MB_ICONERROR, szTemp); va_end (ap); } else retval = vfprintf(f, fmt, ap); return(retval); } void perror(const char *msg) { DWORD cMsgLen; CHAR *msgBuf; DWORD dwError = GetLastError(); cMsgLen = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER | 40, NULL, dwError, MAKELANGID(0, SUBLANG_ENGLISH_US), (LPTSTR) &msgBuf, 512, NULL); if (!cMsgLen) fprintf(stderr, "%s%sError code %lu\n", msg?msg:"", msg?": ":"", dwError); else { fprintf(stderr, "%s%s%s\n", msg?msg:"", msg?": ":"", msgBuf); LocalFree((HLOCAL)msgBuf); } } int WinPutsCmd(clientData, interp, argc, argv) ClientData clientData; /* ConsoleInfo pointer. */ Tcl_Interp *interp; /* Current interpreter. */ int argc; /* Number of arguments. */ char **argv; /* Argument strings. */ { int i, newline; char *fileId; i = 1; newline = 1; if ((argc >= 2) && (strcmp(argv[1], "-nonewline") == 0)) { newline = 0; i++; } if ((i < (argc-3)) || (i >= argc)) { Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " ?-nonewline? ?fileId? string\"", (char *) NULL); return TCL_ERROR; } /* * The code below provides backwards compatibility with an old * form of the command that is no longer recommended or documented. */ if (i == (argc-3)) { if (strncmp(argv[i+2], "nonewline", strlen(argv[i+2])) != 0) { Tcl_AppendResult(interp, "bad argument \"", argv[i+2], "\": should be \"nonewline\"", (char *) NULL); return TCL_ERROR; } newline = 0; } if (i == (argc-1)) { fileId = "stdout"; } else { fileId = argv[i]; i++; } if (strcmp(fileId, "stdout") == 0 || strcmp(fileId, "stderr") == 0) { char *result; int level; if (newline) { int len = strlen(argv[i]); result = ckalloc(len+2); memcpy(result, argv[i], len); result[len] = '\n'; result[len+1] = 0; } else { result = argv[i]; } if (strcmp(fileId, "stdout") == 0) { level = MB_ICONINFORMATION; } else { level = MB_ICONERROR; } OutputDebugString(result); ShowMessage(level, result); if (newline) ckfree(result); return TCL_OK; } else { extern int Tcl_PutsCmd(ClientData clientData, Tcl_Interp *interp, int argc, char **argv); return (Tcl_PutsCmd(clientData, interp, argc, argv)); } } #endif int WinGetUserName(clientData, interp, argc, argv) ClientData clientData; Tcl_Interp *interp; /* Current interpreter. */ int argc; /* Number of arguments. */ char *argv[]; /* Argument strings. */ { char user[256]; int size = sizeof(user); if (!GetUserName(user, &size)) { Tcl_AppendResult(interp, "GetUserName failed", NULL); return TCL_ERROR; } Tcl_AppendResult(interp, user, NULL); return TCL_OK; } int WinGetHostName(clientData, interp, argc, argv) ClientData clientData; Tcl_Interp *interp; /* Current interpreter. */ int argc; /* Number of arguments. */ char *argv[]; /* Argument strings. */ { char hostname[MAXGETHOSTSTRUCT]; if (SOCKET_ERROR == gethostname(hostname, MAXGETHOSTSTRUCT)) { Tcl_AddErrorInfo(interp, "gethostname failed!"); } Tcl_AppendResult(interp, hostname, NULL); return TCL_OK; } static HKEY regroot(root) char *root; { if (strcasecmp(root, "HKEY_LOCAL_MACHINE") == 0) return HKEY_LOCAL_MACHINE; else if (strcasecmp(root, "HKEY_CURRENT_USER") == 0) return HKEY_CURRENT_USER; else if (strcasecmp(root, "HKEY_USERS") == 0) return HKEY_USERS; else if (strcasecmp(root, "HKEY_CLASSES_ROOT") == 0) return HKEY_CLASSES_ROOT; else return NULL; } int WinGetRegistry(clientData, interp, argc, argv) ClientData clientData; Tcl_Interp *interp; /* Current interpreter. */ int argc; /* Number of arguments. */ char **argv; /* Argument strings. */ { HKEY hKey, hRootKey; DWORD dwType; DWORD len, retCode; CHAR *regRoot, *regPath, *keyValue, *keyData; int retval = TCL_ERROR; if (argc != 3) { Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], "key value\"", (char *) NULL); return TCL_ERROR; } regRoot = argv[1]; keyValue = argv[2]; regPath = strchr(regRoot, '\\'); *regPath++ = '\0'; if ((hRootKey = regroot(regRoot)) == NULL) { Tcl_AppendResult(interp, "Unknown registry root \"", regRoot, "\"", NULL); return (TCL_ERROR); } retCode = RegOpenKeyEx(hRootKey, regPath, 0, KEY_READ, &hKey); if (retCode == ERROR_SUCCESS) { retCode = RegQueryValueEx(hKey, keyValue, NULL, &dwType, NULL, &len); if (retCode == ERROR_SUCCESS && dwType == REG_SZ && len) { keyData = (CHAR *) ckalloc(len); retCode = RegQueryValueEx(hKey, keyValue, NULL, NULL, keyData, &len); if (retCode == ERROR_SUCCESS) { Tcl_AppendResult(interp, keyData, NULL); free(keyData); retval = TCL_OK; } } RegCloseKey(hKey); } if (retval == TCL_ERROR) { Tcl_AppendResult(interp, "Cannot find registry entry \"", regRoot, "\\", regPath, "\\", keyValue, "\"", NULL); } return (retval); } int WinPutRegistry(clientData, interp, argc, argv) ClientData clientData; Tcl_Interp *interp; /* Current interpreter. */ int argc; /* Number of arguments. */ char **argv; /* Argument strings. */ { HKEY hKey, hRootKey; DWORD retCode; CHAR *regRoot, *regPath, *keyValue, *keyData; DWORD new; int result = TCL_OK; if (argc != 4) { Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], "key value data\"", (char *) NULL); return TCL_ERROR; } regRoot = argv[1]; keyValue = argv[2]; keyData = argv[3]; regPath = strchr(regRoot, '\\'); *regPath++ = '\0'; if ((hRootKey = regroot(regRoot)) == NULL) { Tcl_AppendResult(interp, "Unknown registry root \"", regRoot, "\"", NULL); return (TCL_ERROR); } retCode = RegCreateKeyEx(hRootKey, regPath, 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &new); if (retCode == ERROR_SUCCESS) { retCode = RegSetValueEx(hKey, keyValue, 0, REG_SZ, keyData, strlen(keyData)); if (retCode != ERROR_SUCCESS) { Tcl_AppendResult(interp, "unable to set key \"", regRoot, "\\", regPath, "\" with value \"", keyValue, "\"", (char *) NULL); result = TCL_ERROR; } RegCloseKey(hKey); } else { Tcl_AppendResult(interp, "unable to create key \"", regRoot, "\\", regPath, "\"", (char *) NULL); result = TCL_ERROR; } return (result); } int platformInit(Tcl_Interp* interp) { /* tcl.CreateCommand("puts", WinPutsCmd, (ClientData)0); */ Tcl_CreateCommand(interp, "getusername", WinGetUserName, (ClientData)0, (Tcl_CmdDeleteProc*)0); Tcl_CreateCommand(interp, "gethostname", WinGetHostName, (ClientData)0, (Tcl_CmdDeleteProc*)0); Tcl_CreateCommand(interp, "putregistry", WinPutRegistry, (ClientData)0, (Tcl_CmdDeleteProc*)0); Tcl_CreateCommand(interp, "getregistry", WinGetRegistry, (ClientData)0, (Tcl_CmdDeleteProc*)0); #ifndef NO_TK /* * Initialize the console only if we are running as an interactive * application. */ if (0==strcmp(Tcl_GetVar(interp, "tcl_interactive", TCL_GLOBAL_ONLY), "1")) { /* * Create the console channels and install them as the standard * channels. All I/O will be discarded until TkConsoleInit is * called to attach the console to a text widget. */ TkConsoleCreate(); if (TkConsoleInit(interp) == TCL_ERROR) { fprintf(stderr, "error calling TkConsoleInit\n"); } } #endif return TCL_OK; } #endif

Decapsulator.cc

#include "Decapsulator.h" #include "ip.h" #include "packet.h" #include "encap.h" static class DecapsulatorClass : public TclClass { public: DecapsulatorClass() : TclClass("Agent/Decapsulator") {} TclObject* create(int, const char*const*) { return (new Decapsulator()); } } class_decapsulator; int Decapsulator::off_encap_= 0; //static variable, will be set in TCL Decapsulator::Decapsulator() : Agent(PT_ENCAPSULATED) { bind("off_encap_", &off_encap_); } Packet* const Decapsulator::decapPacket(Packet* const p) { hdr_cmn* ch= (hdr_cmn*)p->access(hdr_cmn::offset_); if (ch->ptype() == PT_ENCAPSULATED) { hdr_encap* eh= (hdr_encap*)p->access(off_encap_); return eh->decap(); } return 0; } void Decapsulator::recv(Packet* p, Handler* h) { Packet *decap_p= decapPacket(p); if (decap_p) { send(decap_p, h); Packet::free(p); return; } send(p, h); }

Encapsulator.cc

#include "packet.h" #include "ip.h" #include "Encapsulator.h" #include "encap.h" static class EncapsulatorClass : public TclClass { public: EncapsulatorClass() : TclClass("Agent/Encapsulator") {} TclObject* create(int, const char*const*) { return (new Encapsulator()); } } class_encapsulator; Encapsulator::Encapsulator() : Agent(PT_ENCAPSULATED), d_target_(0) { bind("status_", &status_); bind("off_encap_", &off_encap_); bind("overhead_", &overhead_); } int Encapsulator::command(int argc, const char*const* argv) { Tcl& tcl = Tcl::instance(); if (argc == 2) { if (strcmp(argv[1], "decap-target") == 0) { if (d_target_ != 0) tcl.result(d_target_->name()); return (TCL_OK); } } else if (argc == 3) { if (strcmp(argv[1], "decap-target") == 0) { d_target_ = (NsObject*)TclObject::lookup(argv[2]); // even if it's zero, it's OK, we'll just not send to such // a target then. return (TCL_OK); } } return (Agent::command(argc, argv)); } void Encapsulator::recv(Packet* p, Handler* h) { if (d_target_) { Packet *copy_p= p->copy(); d_target_->recv(copy_p, h); } if (status_) { Packet* ep= allocpkt(); //sizeof(Packet*)); hdr_encap* eh= (hdr_encap*)ep->access(off_encap_); eh->encap(p); //Packet** pp= (Packet**) encap_p->accessdata(); //*pp= p; hdr_cmn* ch_e= (hdr_cmn*)ep->access(off_cmn_); hdr_cmn* ch_p= (hdr_cmn*)p->access(off_cmn_); ch_e->ptype()= PT_ENCAPSULATED; ch_e->size()= ch_p->size() + overhead_; ch_e->timestamp()= ch_p->timestamp(); send(ep, h); } else send(p, h); //forward the packet as it is }

ack-recons.cc

acto-adc.cc

actp-adc.cc

adaptive-receiver.cc

adc.cc

address.cc

agent.cc

alloc-address.cc

antenna.cc

app.cc

arp.cc

bi-connector.cc

cbq.cc

cbr_traffic.cc

channel.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (c) 1996 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Computer Systems * Engineering Group at Lawrence Berkeley Laboratory and the Daedalus * research group at UC Berkeley. * 4. Neither the name of the University nor of the Laboratory may be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * Contributed by Giao Nguyen, http://daedalus.cs.berkeley.edu/~gnguyen */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (UCB)"; #endif //#include "template.h" #include <float.h> #include "trace.h" #include "delay.h" #include "object.h" #include "packet.h" #include "mac.h" #include "channel.h" #include "list.h" #include "phy.h" #include "wireless-phy.h" #include "mobilenode.h" #include "ip.h" #include "dsr/hdr_sr.h" #include "gridkeeper.h" static class ChannelClass : public TclClass { public: ChannelClass() : TclClass("Channel") {} TclObject* create(int, const char*const*) { return (new Channel); } } class_channel; /*static class DuplexChannelClass : public TclClass { public: DuplexChannelClass() : TclClass("Channel/Duplex") {} TclObject* create(int, const char*const*) { return (new DuplexChannel); } } class_channel_duplex; */ static class WirelessChannelClass : public TclClass { public: WirelessChannelClass() : TclClass("Channel/WirelessChannel") {} TclObject* create(int, const char*const*) { return (new WirelessChannel); } } class_Wireless_channel; /* ================================================================== NS Initialization Functions =================================================================*/ static int ChannelIndex = 0; Channel::Channel() : TclObject() { index_ = ChannelIndex++; LIST_INIT(&ifhead_); bind_time("delay_", &delay_); } int Channel::command(int argc, const char*const* argv) { if (argc == 3) { TclObject *obj; if( (obj = TclObject::lookup(argv[2])) == 0) { fprintf(stderr, "%s lookup failed\n", argv[1]); return TCL_ERROR; } if (strcmp(argv[1], "trace-target") == 0) { trace_ = (Trace*) obj; return (TCL_OK); } else if(strcmp(argv[1], "addif") == 0) { ((Phy*) obj)->insertchnl(&ifhead_); ((Phy*) obj)->setchnl(this); return TCL_OK; } // add interface for grid_keeper_ /*else if(strncasecmp(argv[1], "grid_keeper", 5) == 0) { grid_keeper_ = (GridKeeper*)obj; return TCL_OK; }*/ } else if (argc == 2) { Tcl& tcl = Tcl::instance(); if (strcmp(argv[1], "trace-target") == 0) { tcl.resultf("%s", trace_->name()); return (TCL_OK); } else if(strcmp(argv[1], "id") == 0) { tcl.resultf("%d", index_); return TCL_OK; } } return TclObject::command(argc, argv); } void Channel::recv(Packet* p, Handler* h) { // Scheduler& s = Scheduler::instance(); // hdr_cmn::access(p)->direction() = hdr_cmn::UP; // s.schedule(target_, p, txstop_ + delay_ - s.clock()); sendUp(p, (Phy*)h); } void Channel::sendUp(Packet* p, Phy *tifp) { Scheduler &s = Scheduler::instance(); Phy *rifp = ifhead_.lh_first; Node *tnode = tifp->node(); Node *rnode = 0; Packet *newp; double propdelay = 0.0; struct hdr_cmn *hdr = HDR_CMN(p); hdr->direction() = hdr_cmn::UP; if (GridKeeper::instance()) { int i; GridKeeper* gk = GridKeeper::instance(); int size = gk->size_; MobileNode **outlist = new MobileNode *[size]; // memset(outlist, 0, size * sizeof(MobileNode *)); int out_index = gk->get_neighbors((MobileNode*)tnode, outlist); for (i=0; i < out_index; i ++) { newp = p->copy(); rnode = outlist[i]; propdelay = get_pdelay(tnode, rnode); rifp = (rnode->ifhead_).lh_first; for(; rifp; rifp = rifp->nextnode()){ if (rifp->channel() == this){ s.schedule(rifp, newp, propdelay); break; } } } delete [] outlist; } else { for( ; rifp; rifp = rifp->nextchnl()) { rnode = rifp->node(); if(rnode == tnode) continue; /* * Each node needs to get their own copy of this packet. * Since collisions occur at the receiver, we can have * two nodes canceling and freeing the *same* simulation * event. * */ newp = p->copy(); propdelay = get_pdelay(tnode, rnode); /* * Each node on the channel receives a copy of the * packet. The propagation delay determines exactly * when the receiver's interface detects the first * bit of this packet. */ s.schedule(rifp, newp, propdelay); } } Packet::free(p); } double Channel::get_pdelay(Node* /*tnode*/, Node* /*rnode*/) { // Dummy function return delay_; } void Channel::dump(void) { Phy *n; fprintf(stdout, "Network Interface List\n"); for(n = ifhead_.lh_first; n; n = n->nextchnl() ) n->dump(); fprintf(stdout, "--------------------------------------------------\n"); } // Wireless extensions class MobileNode; WirelessChannel::WirelessChannel(void) : Channel() {} double WirelessChannel::get_pdelay(Node* tnode, Node* rnode) { // Scheduler &s = Scheduler::instance(); MobileNode* tmnode = (MobileNode*)tnode; MobileNode* rmnode = (MobileNode*)rnode; double propdelay = 0; propdelay = tmnode->propdelay(rmnode); assert(propdelay >= 0.0); if (propdelay == 0.0) { /* if the propdelay is 0 b/c two nodes are on top of each other, move them slightly apart -dam 7/28/98 */ propdelay = 2 * DBL_EPSILON; //printf ("propdelay 0: %d->%d at %f\n", // tmnode->address(), rmnode->address(), s.clock()); } return propdelay; } // send(): // The packet occupies the channel for the transmission time, txtime // If collision occur (>1 pkts overlap), corrupt all pkts involved // by setting the error bit or discard them // int Channel::send(Packet* p, Phy *tifp) // { // // without collision, return 0 // Scheduler& s = Scheduler::instance(); // double now = s.clock(); // // busy = time when the channel are still busy with earlier tx // double busy = max(txstop_, cwstop_); // // txstop = when the channel is no longer busy from this tx // txstop_ = max(busy, now + txtime); // // now < busy => collision // // mark the pkt error bit, EF_COLLISION // // drop if there is a drop target, drop_ // if (now < busy) { // // if still transmit earlier packet, pkt_, then corrupt it // if (pkt_ && pkt_->time_ > now) { // hdr_cmn::access(pkt_)->error() |= EF_COLLISION; // if (drop_) { // s.cancel(pkt_); // drop(pkt_); // pkt_ = 0; // } // } // // corrupts the current packet p, and drop if drop_ exists // hdr_cmn::access(p)->error() |= EF_COLLISION; // if (drop_) { // drop(p); // return 1; // } // } // // if p was not dropped, call recv() or hand it to trace_ if present // pkt_ = p; // trace_ ? trace_->recv(p, 0) : recv(p, 0); // return 0; // } // contention(): // The MAC calls this Channel::contention() to enter contention period // It determines when the contention window is over, cwstop_, // and schedule a callback to the MAC for the actual send() // void Channel::contention(Packet* p, Handler* h) // { // Scheduler& s = Scheduler::instance(); // double now = s.clock(); // if (now > cwstop_) { // cwstop_ = now + delay_; // numtx_ = 0; // } // numtx_++; // s.schedule(h, p, cwstop_ - now); // } // jam(): // Jam the channel for a period txtime // Some MAC protocols use this to let other MAC detect collisions // int Channel::jam(double txtime) // { // // without collision, return 0 // double now = Scheduler::instance().clock(); // if (txstop_ > now) { // txstop_ = max(txstop_, now + txtime); // return 1; // } // txstop_ = now + txtime; // return (now < cwstop_); // } // int DuplexChannel::send(Packet* p, double txtime) // { // double now = Scheduler::instance().clock(); // txstop_ = now + txtime; // trace_ ? trace_->recv(p, 0) : recv(p, 0); // return 0; // } // void DuplexChannel::contention(Packet* p, Handler* h) // { // Scheduler::instance().schedule(h, p, delay_); // numtx_ = 1; // }

chost.cc

classifier-addr.cc

classifier-bst.cc

classifier-hash.cc

classifier-mac.cc

classifier-mcast.cc

classifier-mpath.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * classifier-mpath.cc * * Copyright (C) 1997 by USC/ISI * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, advertising * materials, and other materials related to such distribution and use * acknowledge that the software was developed by the University of * Southern California, Information Sciences Institute. The name of the * University may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (USC/ISI)"; #endif #include "classifier.h" class MultiPathForwarder : public Classifier { public: MultiPathForwarder() : ns_(0) {} virtual int classify(Packet*) { int cl; int fail = ns_; do { cl = ns_++; ns_ %= (maxslot_ + 1); } while (slot_[cl] == 0 && ns_ != fail); return cl; } private: int ns_; }; static class MultiPathClass : public TclClass { public: MultiPathClass() : TclClass("Classifier/MultiPath") {} TclObject* create(int, const char*const*) { return (new MultiPathForwarder()); } } class_multipath;

classifier-port.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * classifier-port.cc * Copyright (C) 1999 by USC/ISI * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, advertising * materials, and other materials related to such distribution and use * acknowledge that the software was developed by the University of * Southern California, Information Sciences Institute. The name of the * University may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * * @(#) $Header$ (USC/ISI) */ #ifndef lint static const char rcsid[] = "@(#) $Header$"; #endif #include "classifier-port.h" int PortClassifier::classify(Packet *p) { // Port classifier returns the destination port. No shifting // or masking is required since in the 32-bit addressing, // ports are stored in a seperate variable. hdr_ip* iph = hdr_ip::access(p); return iph->dport(); }; static class PortClassifierClass : public TclClass { public: PortClassifierClass() : TclClass("Classifier/Port") {} TclObject* create(int, const char*const*) { return (new PortClassifier()); } } class_address_classifier; static class ReservePortClassifierClass : public TclClass { public: ReservePortClassifierClass() : TclClass("Classifier/Port/Reserve") {} TclObject* create(int, const char*const*) { return (new ReservePortClassifier()); } } class_reserve_port_classifier; int ReservePortClassifier::command(int argc, const char*const* argv) { // Tcl& tcl = Tcl::instance(); if (argc == 3 && strcmp(argv[1],"reserve-port") == 0) { reserved_ = atoi(argv[2]); alloc((maxslot_ = reserved_ - 1)); return(TCL_OK); } return (Classifier::command(argc, argv)); } void ReservePortClassifier::clear(int slot) { slot_[slot] = 0; if (slot == maxslot_) { while (--maxslot_ >= reserved_ && slot_[maxslot_] == 0) ; } } int ReservePortClassifier::getnxt(NsObject *nullagent) { int i; for (i=reserved_; i < nslot_; i++) if (slot_[i]==0 || slot_[i]==nullagent) return i; i=nslot_; alloc(nslot_); return i; }

classifier-virtual.cc

classifier.cc

cmu-trace.cc

codeword.cc

/* * (c) 1997-98 StarBurst Communications Inc. * * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * Author: Christoph Haenle, chris@cs.vu.nl * File: codeword.cc * Last change: Dec 07, 1998 * * This software may freely be used only for non-commercial purposes */ #include "config.h" // for memcpy... #include "codeword.h" #include <assert.h> #include <stdlib.h> // due to definition of NULL #include <stdio.h> // due to printf static unsigned char minbit_array[256]; static unsigned char bitcount_array[256]; // because of the lack of static initialization on class-basis in C++, // this is a workaround. static int dummy = initialize_codeword(); // list of primitive polynomials over GF(2). CW_PATTERN_t Codeword::primitive_polynomial[Codeword::MAX_DEGREE+1] = { "1", // 1 (group size 1) "11", // 1+x "111", // 1+x+x^2 "1011", // 1+x+x^3 (group size 4) "10011", // 1+x+x^4 "100101", // 1+x^2+x^5 "1100111", // 1+x+x^2+x^5+x^6 "11100101", // 1+x^2+x^5+x^6+x^7 (group size 8) "101101001", // 1+x^3+x^5+x^6+x^8 "1100010011", // 1+x^1+x^4+x^8+x^9 "11101001101", // 1+x^2+x^3+x^6+x^8+x^9+x^10 "110010011011", // 1+x+x^3+x^4+x^7+x^10+x^11 "1001010111001", // 1+x^3+x^4+x^5+x^7+x^9+x^12 "11000001111001", // 1+x^3+x^4+x^5+x^6+x^12+x^13 "110100100101111", // 1+x+x^2+x^3+x^5+x^8+x^11+x^13+x^14 "1100010011000101", // 1+x^2+x^6+x^7+x^10+x^14+x^15 (group size 16) "11101010001010101", // 1+x^2+x^4+x^6+x^10+x^12+x^14+x^15+x^16 "101101011001011011", // 1+x+x^3+x^4+x^6+x^9+x^10+x^12+x^14+x^15+x^17 "1101101001010011011", // 1+x+x^3+x^4+x^7+x^9+x^12+x^14+x^15+x^17+x^18 "11100101101010010011", "101010101101010010011", // 1+x+x^4+x^7+x^9+x^11+x^12+x^14+x^16+x^18+x^20 "1100010101110010011001", "10100100110001101011001", "101001011000010110110111", "1010101010100101110110001", "11001000110011010101011001", "100011000010001110100111011", // group size: 27 "1100110100111010101010100011", // 1+x+x^5+x^7+x^9+x^11+x^13+x^15+x^16+x^17+x^20+x^22+x^23+x^26+x^27 "10100110100111010101010100011", // 1+x+x^5+x^7+x^9+x^11+x^13+x^15+x^16+x^17+x^20+x^22+x^23+x^26+x^28 "100110011000111010101010100011", // 1+x+x^5+x^7+x^9+x^11+x^13+x^15+x^16+x^17+x^21+x^22+x^25+x^26+x^29 "1010100101000111010110100100011", // 1+x+x^5+x^8+x^10+x^11+x^13+x^15+x^16+x^17+x^21+x^23+x^26+x^28+x^30 "10110010100101100011010011011011", // 1+x+x^3+x^4+x^6+x^7+x^10+x^12+x^13+x^17+x^18+x^20+x^23+x^25+x^28+x^29+x^31 (group size 32) "0", // invalid, group size currently not supported "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1101100011100110100100111001001010110010100101010100100111011011" // 1+x+x^3+x^4+x^6+x^7+x^8+x^11+x^14+x^16+x^18+x^20+x^23+x^25+x^28+x^29+x^31+x^33+x^36+x^39+x^40+x^41+x^44+x^47+x^49+x^50+x^53+x^54+x^55+x^59+x^60+x^62+x^63 (group size 64) }; // to generate primitive polynomials, see for example // http://www-kommsys.fernuni-hagen.de/~rieke/primitiv/test.phtml.en Codeword::Codeword() : k(1), n(1), cw_index(0), cw_pat(0), cw_saved(0) { } void Codeword::setSourceWordLen(unsigned long k_) { k = k_; n = ((CW_PATTERN_t) 1) << (k-1); cw_index = (unsigned long) 0; cw_pat = 1; cw_saved = 0; assert(k <= 8 * sizeof(CW_PATTERN_t)); if(k > MAX_DEGREE + 1 || primitive_polynomial[k-1] == 0) { fprintf(stderr, "codeword.cc: sorry, the group size %lu is not supported.\n", (unsigned long) k); exit(0); } if(k > 8 * sizeof(CW_PATTERN_t)) { fprintf(stderr, "codeword.cc: sorry, the group size %lu that you selected\n", (unsigned long) k); fprintf(stderr, "requires a datatype of at least %lu bits. To achieve this,\n", (unsigned long) k); fprintf(stderr, "adjust Codeword::size in file \"codeword.h\" accordingly.\n"); exit(0); } } // systematic code, with optimization hack, originally derived from Reed-Muller codes of // order 1. CW_PATTERN_t Codeword::getNextCwPat() { assert(cw_pat != 0); // or else prior call to setSourceWordLen(...) has not been made CW_PATTERN_t ret; CW_PATTERN_t cw_tmp; // step 1 if(cw_index != 0) { cw_pat <<= 1; if(cw_pat >= n) { cw_pat ^= primitive_polynomial[k-1]; assert(cw_pat < n); } } // step 2 if(cw_index == k) { cw_saved = cw_pat; cw_tmp = n-1; } else if(cw_pat == n-1) cw_tmp = cw_saved; else cw_tmp = cw_pat; // step 3 if(cw_index < k) ret = (CW_PATTERN_t) 1 << cw_index; else ret = (cw_tmp << 1) | 1; // step 4 cw_index = (cw_index + 1) & (n-1); // "& (n-1)" is equivalent to "% n" here return ret; } void init_bitcount_array(unsigned char* arr, unsigned int nb_bits) { unsigned long bitcount_array_size = ((unsigned long) 1) << nb_bits; unsigned long i; unsigned int bit; int count; assert(sizeof(unsigned long) == 4); // we need this for the following assert(0 < nb_bits && nb_bits <= 32); // or else this function must be revised assert(arr != NULL); for(i = 0; i < bitcount_array_size; ++i) { count = 0; // to avoid warning: unsigned value >= 0 is always 1 // for(bit = 0; 0 <= bit && bit < nb_bits; bit++) { for(bit = 0; bit < nb_bits; bit++) { if(i & ((unsigned long) 1 << bit)) { count++; } } arr[i] = count; } } void init_minbit_array(unsigned char* arr, unsigned int minbits) { unsigned int minbit_array_size = (unsigned int) 1 << minbits; unsigned int i; unsigned int bit; assert(minbits == 8); // or else minbit(...) needs a revision! assert(arr != NULL); for(i = 0; i < minbit_array_size; ++i) { // to avoid warning: unsigned value >= 0 is always 1 //for(bit = 0; 0 <= bit && bit < minbits; bit++) { for(bit = 0; bit < minbits; bit++) { if(i & ((unsigned int) 1 << bit)) { arr[i] = (unsigned char) bit; break; } } } } // returns bit position of least significant bit in cw_pat unsigned int minbit(unsigned long val) { unsigned int i; assert(val); for(i = 0; val; ++i) { assert(i < sizeof(CW_PATTERN_t)); if(val & 255) { return minbit_array[(unsigned int) (val & 255)] + 8*i; } val >>= 8; } assert(false); // value is 0 return 0; // compiler, be quiet. } // counts number of bits in cw_pat unsigned int bitcount(unsigned long val) { unsigned int res = 0; while(val) { res += bitcount_array[(unsigned int) (val & 255)]; val >>= 8; } return res; } /* function to be called once at the beginning */ int initialize_codeword() { assert(sizeof(minbit_array) / sizeof(unsigned char) == 256); init_minbit_array(minbit_array, 8); init_bitcount_array(bitcount_array, 8); return 0; } // constructor: ExtraLongUInt::ExtraLongUInt() { memset(value, 0, sizeof(value)); } // constructor: create from "binary-string" (string of 0's and 1's): ExtraLongUInt::ExtraLongUInt(const char* val) { const unsigned int len = strlen(val); char digit; assert(len <= 8 * sizeof(value)); // or else overflow memset(value, 0, sizeof(value)); for(unsigned int i = 0; i < len; ++i) { digit = val[len - 1 - i]; assert(digit == '0' || digit == '1'); // or else val is not a binary number if(digit == '1') { value[i / (8 * sizeof(unsigned long))] |= (unsigned long) 1 << (i % (8 * sizeof(unsigned long))); } } } // constructor: ExtraLongUInt::ExtraLongUInt(int val) { assert(val >= 0); memset(value, 0, sizeof(value)); value[0] = val; } // constructor: ExtraLongUInt::ExtraLongUInt(unsigned int val) { memset(value, 0, sizeof(value)); value[0] = val; } // constructor: ExtraLongUInt::ExtraLongUInt(unsigned long val) { memset(value, 0, sizeof(value)); value[0] = val; } bool ExtraLongUInt::operator == (const ExtraLongUInt& other) const { for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { if(value[i] != other.value[i]) { return false; } } return true; } bool ExtraLongUInt::operator != (const ExtraLongUInt& other) const { return (*this == other) ? false : true; } bool ExtraLongUInt::operator < (const ExtraLongUInt& other) const { unsigned int i; for(i = sizeof(value) / sizeof(unsigned long) - 1; value[i] == other.value[i] && i > 0; --i) { } return value[i] < other.value[i] ? true : false; } bool ExtraLongUInt::operator > (const ExtraLongUInt& other) const { unsigned int i; for(i = sizeof(value) / sizeof(unsigned long) - 1; value[i] == other.value[i] && i > 0; --i) { } return value[i] > other.value[i] ? true : false; } bool ExtraLongUInt::operator <= (const ExtraLongUInt& other) const { return (*this > other) ? false : true; } bool ExtraLongUInt::operator >= (const ExtraLongUInt& other) const { return (*this < other) ? false : true; } ExtraLongUInt ExtraLongUInt::operator + (const ExtraLongUInt& other) const { ExtraLongUInt res = 0; unsigned long c = 0; const int shift = 8 * sizeof(unsigned long) - 1; const unsigned long msb_mask = (unsigned long) 1 << shift; const unsigned long lsbs_mask = ~msb_mask; unsigned long x, y; for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { x = value[i]; y = other.value[i]; res.value[i] = (x & lsbs_mask) + (y & lsbs_mask) + c; c = ((x >> shift) + (y >> shift) + (res.value[i] >> shift)) >> 1; res.value[i] ^= (x & msb_mask) ^ (y & msb_mask); } return res; } ExtraLongUInt ExtraLongUInt::operator - (const ExtraLongUInt& other) const { return *this + ~other + 1; } ExtraLongUInt ExtraLongUInt::operator & (const ExtraLongUInt& other) const { ExtraLongUInt res; for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { res.value[i] = value[i] & other.value[i]; } return res; } ExtraLongUInt ExtraLongUInt::operator | (const ExtraLongUInt& other) const { ExtraLongUInt res; for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { res.value[i] = value[i] | other.value[i]; } return res; } ExtraLongUInt ExtraLongUInt::operator ^ (const ExtraLongUInt& other) const { ExtraLongUInt res; for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { res.value[i] = value[i] ^ other.value[i]; } return res; } ExtraLongUInt ExtraLongUInt::operator ~() const { ExtraLongUInt res; for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { res.value[i] = ~value[i]; } return res; } bool ExtraLongUInt::operator ! () const { for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { if(value[i]) { return false; } } return true; } ExtraLongUInt ExtraLongUInt::operator << (unsigned int bits) const { ExtraLongUInt res = 0; const int index = bits / (8 * sizeof(unsigned long)); const int shifts = bits % (8 * sizeof(unsigned long)); unsigned int i; if(sizeof(value) > index * sizeof(unsigned long)) { if(shifts == 0) { // this is because (1 >> 32) is not 0 (gcc) memcpy(&res.value[index], value, sizeof(value) - index * sizeof(unsigned long)); } else { const unsigned long mask = (~(unsigned long) 0) >> shifts; assert(sizeof(value) >= sizeof(unsigned long)); res.value[index] = (value[0] & mask) << shifts; for(i = index + 1; i < sizeof(value) / sizeof(unsigned long); ++i) { res.value[i] = ((value[i - index ] & mask) << shifts) | (value[i - index-1] >> ((8 * sizeof(unsigned long)) - shifts)); } } } return res; } ExtraLongUInt ExtraLongUInt::operator >> (unsigned int bits) const { ExtraLongUInt res = 0; const int index = bits / (8 * sizeof(unsigned long)); const int shifts = bits % (8 * sizeof(unsigned long)); unsigned int i; if(sizeof(value) > index * sizeof(unsigned long)) { if(shifts == 0) { // this is because (1 >> 32) is not 0 (gcc) memcpy(res.value, &value[index], sizeof(value) - index * sizeof(unsigned long)); } else { const unsigned long mask = (~(unsigned long) 0) >> (8 * sizeof(unsigned long) - shifts); assert(sizeof(value) >= sizeof(unsigned long)); for(i = 0; i < sizeof(value) / sizeof(unsigned long) - index - 1; ++i) { res.value[i] = (value[i+index ] >> shifts) | ((value[i+index+1] & mask) << ((8 * sizeof(unsigned long)) - shifts)); } res.value[i] = value[i+index] >> shifts; } } return res; } ExtraLongUInt ExtraLongUInt::operator << (const ExtraLongUInt& bits) const { return *this << bits.value[0]; } ExtraLongUInt ExtraLongUInt::operator >> (const ExtraLongUInt& bits) const { return *this >> bits.value[0]; } const ExtraLongUInt& ExtraLongUInt::operator <<= (unsigned int bits) { *this = *this << bits; return *this; } const ExtraLongUInt& ExtraLongUInt::operator >>= (unsigned int bits) { *this = *this >> bits; return *this; } const ExtraLongUInt& ExtraLongUInt::operator &= (const ExtraLongUInt& other) { *this = *this & other; return *this; } const ExtraLongUInt& ExtraLongUInt::operator |= (const ExtraLongUInt& other) { *this = *this | other; return *this; } const ExtraLongUInt& ExtraLongUInt::operator ^= (const ExtraLongUInt& other) { *this = *this ^ other; return *this; } void ExtraLongUInt::print(char* buf) const { int i, fin; for(i = 8 * sizeof(value) - 1; !(value[i / (8 * sizeof(unsigned long))] & ((unsigned long) 1 << (i % (8 * sizeof(unsigned long))))) && i > 0; --i) ; for(fin = i; i >= 0; --i) { buf[fin-i] = (value[i / (8 * sizeof(unsigned long))] & (unsigned long) 1 << (i % (8 * sizeof(unsigned long)))) ? '1' : '0'; } buf[fin+1] = '\0'; } unsigned int ExtraLongUInt::bitcount() const { unsigned int res = 0; for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { res += ::bitcount(value[i]); } return res; } unsigned int ExtraLongUInt::minbit() const { for(unsigned int i = 0; i < sizeof(value) / sizeof(unsigned long); ++i) { if(value[i]) { return i * 8 * sizeof(unsigned long) + ::minbit(value[i]); } } assert(false); // value is 0 return 0; // compiler, be quiet. } // returns bit position of least significant bit in cw_pat unsigned int minbit(const ExtraLongUInt& val) { return val.minbit(); } // returns bit position of least significant bit in cw_pat unsigned int bitcount(const ExtraLongUInt& val) { return val.bitcount(); }

connector.cc

consrcvr.cc

ctrMcast.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * ctrMcast.cc * Copyright (C) 1997 by USC/ISI * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, advertising * materials, and other materials related to such distribution and use * acknowledge that the software was developed by the University of * Southern California, Information Sciences Institute. The name of the * University may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * * Contributed by Polly Huang (USC/ISI), http://www-scf.usc.edu/~bhuang * */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (USC/ISI)"; #endif #include "agent.h" #include "ip.h" #include "ctrMcast.h" int hdr_CtrMcast::offset_; static class CtrMcastHeaderClass : public PacketHeaderClass { public: CtrMcastHeaderClass() : PacketHeaderClass("PacketHeader/CtrMcast", sizeof(hdr_CtrMcast)) { bind_offset(&hdr_CtrMcast::offset_); } } class_CtrMcast_hdr; class CtrMcastEncap : public Agent { public: CtrMcastEncap() : Agent(PT_CtrMcast_Encap) { bind("off_CtrMcast_", &off_CtrMcast_); } int command(int argc, const char*const* argv); void recv(Packet* p, Handler*); protected: int off_CtrMcast_; }; class CtrMcastDecap : public Agent { public: CtrMcastDecap() : Agent(PT_CtrMcast_Decap) { bind("off_CtrMcast_", &off_CtrMcast_); } int command(int argc, const char*const* argv); void recv(Packet* p, Handler*); protected: int off_CtrMcast_; }; static class CtrMcastEncapclass : public TclClass { public: CtrMcastEncapclass() : TclClass("Agent/CtrMcast/Encap") {} TclObject* create(int, const char*const*) { return (new CtrMcastEncap); } } class_CtrMcastEncap; static class CtrMcastDecapclass : public TclClass { public: CtrMcastDecapclass() : TclClass("Agent/CtrMcast/Decap") {} TclObject* create(int, const char*const*) { return (new CtrMcastDecap); } } class_CtrMcastDecap; int CtrMcastEncap::command(int argc, const char*const* argv) { return Agent::command(argc, argv); } int CtrMcastDecap::command(int argc, const char*const* argv) { return Agent::command(argc, argv); } void CtrMcastEncap::recv(Packet* p, Handler*) { hdr_CtrMcast* ch = (hdr_CtrMcast*)p->access(off_CtrMcast_); hdr_ip* ih = (hdr_ip*)p->access(off_ip_); ch->src() = ih->saddr(); ch->group() = ih->daddr(); ch->flowid() = ih->flowid(); ih->saddr() = addr(); ih->sport() = port(); ih->daddr() = daddr(); ih->dport() = dport(); ih->flowid() = fid_; target_->recv(p); } void CtrMcastDecap::recv(Packet* p, Handler*) { hdr_CtrMcast* ch = (hdr_CtrMcast*)p->access(off_CtrMcast_); hdr_ip* ih = (hdr_ip*)p->access(off_ip_); ih->saddr() = ch->src(); ih->daddr() = ch->group(); ih->flowid() = ch->flowid(); target_->recv(p); }

delay.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (c) 1996-1997 The Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Network Research * Group at Lawrence Berkeley National Laboratory. * 4. Neither the name of the University nor of the Laboratory may be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (LBL)"; #endif #include "delay.h" #include "mcast_ctrl.h" #include "ctrMcast.h" static class LinkDelayClass : public TclClass { public: LinkDelayClass() : TclClass("DelayLink") {} TclObject* create(int /* argc */, const char*const* /* argv */) { return (new LinkDelay); } } class_delay_link; LinkDelay::LinkDelay() : dynamic_(0), itq_(0) { bind_bw("bandwidth_", &bandwidth_); bind_time("delay_", &delay_); } int LinkDelay::command(int argc, const char*const* argv) { if (argc == 2) { if (strcmp(argv[1], "isDynamic") == 0) { dynamic_ = 1; itq_ = new PacketQueue(); return TCL_OK; } } else if (argc == 6) { if (strcmp(argv[1], "pktintran") == 0) { int src = atoi(argv[2]); int grp = atoi(argv[3]); int from = atoi(argv[4]); int to = atoi(argv[5]); pktintran (src, grp); Tcl::instance().evalf("%s puttrace %d %d %d %d %d %d %d %d", name(), total_[0], total_[1], total_[2], total_[3], src, grp, from, to); return TCL_OK; } } return Connector::command(argc, argv); } void LinkDelay::recv(Packet* p, Handler* h) { double txt = txtime(p); Scheduler& s = Scheduler::instance(); if (dynamic_) { Event* e = (Event*)p; e->time_= txt + delay_; itq_->enque(p); // for convinience, use a queue to store packets in transit s.schedule(this, p, txt + delay_); } else { s.schedule(target_, p, txt + delay_); } s.schedule(h, &intr_, txt); } void LinkDelay::send(Packet* p, Handler*) { target_->recv(p, (Handler*) NULL); } void LinkDelay::reset() { Scheduler& s= Scheduler::instance(); if (itq_ && itq_->length()) { Packet *np; // walk through packets currently in transit and kill 'em while ((np = itq_->deque()) != 0) { s.cancel(np); drop(np); } } } void LinkDelay::handle(Event* e) { Packet *p = itq_->deque(); assert(p->time_ == e->time_); send(p, (Handler*) NULL); } void LinkDelay::pktintran(int src, int group) { int reg = 1; int prune = 30; int graft = 31; int data = 0; for (int i=0; i<4; i++) { total_[i] = 0; } if (! dynamic_) return; int len = itq_->length(); while (len) { len--; Packet* p = itq_->lookup(len); hdr_ip* iph = hdr_ip::access(p); if (iph->flowid() == prune) { if (iph->saddr() == src && iph->daddr() == group) { total_[0]++; } } else if (iph->flowid() == graft) { if (iph->saddr() == src && iph->daddr() == group) { total_[1]++; } } else if (iph->flowid() == reg) { hdr_CtrMcast* ch = hdr_CtrMcast::access(p); if (ch->src() == src+1 && ch->group() == group) { total_[2]++; } } else if (iph->flowid() == data) { if (iph->saddr() == src+1 && iph->daddr() == group) { total_[3]++; } } } //printf ("%f %d %d %d %d\n", Scheduler::instance().clock(), total_[0], total_[1], total_[2],total_[3]); }

delaymodel.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * delaymodel.cc * Copyright (C) 1997 by USC/ISI * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, advertising * materials, and other materials related to such distribution and use * acknowledge that the software was developed by the University of * Southern California, Information Sciences Institute. The name of the * University may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * * Contributed by Polly Huang (USC/ISI), http://www-scf.usc.edu/~bhuang * */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (UCB)"; #endif #include "packet.h" #include "delaymodel.h" static class DelayModelClass : public TclClass { public: DelayModelClass() : TclClass("DelayModel") {} TclObject* create(int, const char*const*) { return (new DelayModel); } } class_delaymodel; DelayModel::DelayModel() : Connector(), bandwidth_(0) { } int DelayModel::command(int argc, const char*const* argv) { Tcl& tcl = Tcl::instance(); if (argc == 3) { if (strcmp(argv[1], "ranvar") == 0) { ranvar_ = (RandomVariable*) TclObject::lookup(argv[2]); return (TCL_OK); } else if (strcmp(argv[1], "bandwidth") == 0) { bandwidth_ = atof(argv[2]); return (TCL_OK); } } else if (argc == 2) { if (strcmp(argv[1], "ranvar") == 0) { tcl.resultf("%s", ranvar_->name()); return (TCL_OK); } } return Connector::command(argc, argv); } void DelayModel::recv(Packet* p, Handler*) { double delay = ranvar_->value(); //static int tmp = 0; double txt = txtime(p); Scheduler& s = Scheduler::instance(); //printf ("trans %f, delay %f\n", txt, delay); s.schedule(target_, p, txt + delay); //s.schedule(h, &intr_, txt); }

dem.cc

drop-tail.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (c) 1994 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Computer Systems * Engineering Group at Lawrence Berkeley Laboratory. * 4. Neither the name of the University nor of the Laboratory may be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (LBL)"; #endif #include "drop-tail.h" static class DropTailClass : public TclClass { public: DropTailClass() : TclClass("Queue/DropTail") {} TclObject* create(int, const char*const*) { return (new DropTail); } } class_drop_tail; int DropTail::command(int argc, const char*const* argv) { if (argc == 3) { if (!strcmp(argv[1], "packetqueue-attach")) { delete q_; if (!(q_ = (PacketQueue*) TclObject::lookup(argv[2]))) return (TCL_ERROR); else { pq_ = q_; return (TCL_OK); } } } return Queue::command(argc, argv); } /* * drop-tail */ void DropTail::enque(Packet* p) { q_->enque(p); if (q_->length() >= qlim_) { if (drop_front_) { /* remove from head of queue */ Packet *pp = q_->deque(); drop(pp); } else { q_->remove(p); drop(p); } } } Packet* DropTail::deque() { return q_->deque(); }

drr.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (c) Xerox Corporation 1997. All rights reserved. * * License is granted to copy, to use, and to make and to use derivative * works for research and evaluation purposes, provided that Xerox is * acknowledged in all documentation pertaining to any such copy or derivative * work. Xerox grants no other licenses expressed or implied. The Xerox trade * name should not be used in any advertising without its written permission. * * XEROX CORPORATION MAKES NO REPRESENTATIONS CONCERNING EITHER THE * MERCHANTABILITY OF THIS SOFTWARE OR THE SUITABILITY OF THIS SOFTWARE * FOR ANY PARTICULAR PURPOSE. The software is provided "as is" without * express or implied warranty of any kind. * * These notices must be retained in any copies of any part of this software. * * This file contributed by Sandeep Bajaj <bajaj@parc.xerox.com>, Mar 1997. */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (Xerox)"; #endif #include "config.h" // for string.h #include <stdlib.h> #include "queue.h" class PacketDRR; class DRR; class PacketDRR : public PacketQueue { PacketDRR(): pkts(0),src(-1),bcount(0),prev(0),next(0),deficitCounter(0),turn(0) {} friend DRR; protected : int pkts; int src; //to detect collisions keep track of actual src address int bcount; //count of bytes in each flow to find the max flow; PacketDRR *prev; PacketDRR *next; int deficitCounter; int turn; inline PacketDRR * activate(PacketDRR *head) { if (head) { this->prev = head->prev; this->next = head; head->prev->next = this; head->prev = this; return head; } this->prev = this; this->next = this; return this; } inline PacketDRR * idle(PacketDRR *head) { if (head == this) { if (this->next == this) return 0; this->next->prev = this->prev; this->prev->next = this->next; return this->next; } this->next->prev = this->prev; this->prev->next = this->next; return head; } }; class DRR : public Queue { public : DRR(); virtual int command(int argc, const char*const* argv); Packet *deque(void); void enque(Packet *pkt); int hash(Packet *pkt); void clear(); protected: int buckets_ ; //total number of flows allowed int blimit_; //total number of bytes allowed across all flows int quantum_; //total number of bytes that a flow can send int mask_; /*if set hashes on just the node address otherwise on node+port address*/ int bytecnt ; //cumulative sum of bytes across all flows int pktcnt ; // cumulative sum of packets across all flows int flwcnt ; //total number of active flows PacketDRR *curr; //current active flow PacketDRR *drr ; //pointer to the entire drr struct int off_ip_; inline PacketDRR *getMaxflow (PacketDRR *curr) { //returns flow with max pkts int i; PacketDRR *tmp; PacketDRR *maxflow=curr; for (i=0,tmp=curr; i < flwcnt; i++,tmp=tmp->next) { if (maxflow->bcount < tmp->bcount) maxflow=tmp; } return maxflow; } public: //returns queuelength in packets inline int length () { return pktcnt; } //returns queuelength in bytes inline int blength () { return bytecnt; } }; static class DRRClass : public TclClass { public: DRRClass() : TclClass("Queue/DRR") {} TclObject* create(int, const char*const*) { return (new DRR); } } class_drr; DRR::DRR() { buckets_=16; quantum_=250; drr=0; curr=0; flwcnt=0; bytecnt=0; pktcnt=0; mask_=0; bind("buckets_",&buckets_); bind("blimit_",&blimit_); bind("quantum_",&quantum_); bind("mask_",&mask_); bind ("off_ip_",&off_ip_); } void DRR::enque(Packet* pkt) { PacketDRR *q,*remq; int which; hdr_cmn *ch=(hdr_cmn*)pkt->access(off_cmn_); hdr_ip *iph = (hdr_ip*)pkt->access(off_ip_); if (!drr) drr=new PacketDRR[buckets_]; which= hash(pkt) % buckets_; q=&drr[which]; /*detect collisions here */ int compare=(!mask_ ? ((int)iph->saddr()) : ((int)iph->saddr()&0xfff0)); if (q->src ==-1) q->src=compare; else if (q->src != compare) fprintf(stderr,"Collisions between %d and %d src addresses\n",q->src,(int)iph->saddr()); q->enque(pkt); ++q->pkts; ++pktcnt; q->bcount += ch->size(); bytecnt +=ch->size(); if (q->pkts==1) { curr = q->activate(curr); q->deficitCounter=0; ++flwcnt; } while (bytecnt > blimit_) { Packet *p; hdr_cmn *remch; hdr_ip *remiph; remq=getMaxflow(curr); p=remq->deque(); remch=(hdr_cmn*)p->access(off_cmn_); remiph=(hdr_ip*)p->access(off_ip_); remq->bcount -= remch->size(); bytecnt -= remch->size(); drop(p); --remq->pkts; --pktcnt; if (remq->pkts==0) { curr=remq->idle(curr); --flwcnt; } } } Packet *DRR::deque(void) { hdr_cmn *ch; hdr_ip *iph; Packet *pkt=0; if (bytecnt==0) { //fprintf (stderr,"No active flow\n"); return(0); } while (!pkt) { if (!curr->turn) { curr->deficitCounter+=quantum_; curr->turn=1; } pkt=curr->lookup(0); ch=(hdr_cmn*)pkt->access(off_cmn_); iph= (hdr_ip*)pkt->access(off_ip_); if (curr->deficitCounter >= ch->size()) { curr->deficitCounter -= ch->size(); pkt=curr->deque(); curr->bcount -= ch->size(); --curr->pkts; --pktcnt; bytecnt -= ch->size(); if (curr->pkts == 0) { curr->turn=0; --flwcnt; curr->deficitCounter=0; curr=curr->idle(curr); } return pkt; } else { curr->turn=0; curr=curr->next; pkt=0; } } return 0; // not reached } void DRR::clear() { PacketDRR *q =drr; int i = buckets_; if (!q) return; while (i--) { if (q->pkts) { fprintf(stderr, "Changing non-empty bucket from drr\n"); exit(1); } ++q; } delete[](drr); drr = 0; } /* *Allows one to change blimit_ and bucket_ for a particular drrQ : * * */ int DRR::command(int argc, const char*const* argv) { if (argc==3) { if (strcmp(argv[1], "blimit") == 0) { blimit_ = atoi(argv[2]); if (bytecnt > blimit_) { fprintf (stderr,"More packets in buffer than the new limit"); exit (1); } return (TCL_OK); } if (strcmp(argv[1], "buckets") == 0) { clear(); buckets_ = atoi(argv[2]); return (TCL_OK); } if (strcmp(argv[1],"quantum") == 0) { quantum_ = atoi(argv[2]); return (TCL_OK); } if (strcmp(argv[1],"mask")==0) { mask_= atoi(argv[2]); return (TCL_OK); } } return (Queue::command(argc, argv)); } int DRR::hash(Packet* pkt) { hdr_ip *iph=(hdr_ip*)pkt->access(off_ip_); int i; if (mask_) i = (int)iph->saddr() & (0xfff0); else i = (int)iph->saddr(); return ((i + (i >> 8) + ~(i>>4)) % ((2<<23)-1))+1; // modulo a large prime }

dynalink.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (C) 1997 by USC/ISI * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, advertising * materials, and other materials related to such distribution and use * acknowledge that the software was developed by the University of * Southern California, Information Sciences Institute. The name of the * University may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * */ // Other copyrights might apply to parts of this software and are so // noted when applicable. // // Author: Kannan Varadhan <kannan@isi.edu> // Version Date: Mon Jun 30 15:51:33 PDT 1997 #ifndef lint static const char rcsid[] = "@(#) $Header$ (USC/ISI)"; #endif #include "connector.h" // #include "packet.h" // #include "queue.h" class DynamicLink : public Connector { public: DynamicLink() : down_(0), status_(1) { bind("status_", &status_); } protected: int command(int argc, const char*const* argv); void recv(Packet* p, Handler* h); NsObject* down_; int status_; }; static class DynamicLinkClass : public TclClass { public: DynamicLinkClass() : TclClass("DynamicLink") {} TclObject* create(int, const char*const*) { return (new DynamicLink); } } class_dynamic_link; int DynamicLink::command(int argc, const char*const* argv) { if (argc == 2) { if (strcmp(argv[1], "status?") == 0) { Tcl::instance().result(status_ ? "up" : "down"); return TCL_OK; } } return Connector::command(argc, argv); } void DynamicLink::recv(Packet* p, Handler* h) { if (status_) target_->recv(p, h); else drop(p); }

energy-model.cc

// Contributed by Satish Kumar <kkumar@isi.edu> extern "C" { #include <stdarg.h> #include <float.h> }; #include "energy-model.h" static class EnergyModelClass:public TclClass { public: EnergyModelClass ():TclClass ("EnergyModel") { } TclObject *create (int, const char *const *argv) { return (new EnergyModel (atof(argv[4]),atof(argv[5]),atof(argv[6]))); } } class_energy_model;

errmodel.cc

estimator.cc

expavg-est.cc

expoo.cc

filter.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * filter.cc * Copyright (C) 1998 by USC/ISI * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, advertising * materials, and other materials related to such distribution and use * acknowledge that the software was developed by the University of * Southern California, Information Sciences Institute. The name of the * University may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef lint static const char rcsid[] = "@(#) $Header: /usr/src/mash/repository/vint/ns-2/filter.cc "; #endif #include "packet.h" #include "filter.h" static class FilterClass : public TclClass { public: FilterClass() : TclClass("Filter") {} TclObject* create(int, const char*const*) { return (new Filter); } } class_filter; Filter::Filter() : filter_target_(0) { } Filter::filter_e Filter::filter(Packet* /*p*/) { return PASS; // As simple connector } void Filter::recv(Packet* p, Handler* h) { switch(filter(p)) { case DROP : if (h) h->handle(p); drop(p); break; case DUPLIC : if (filter_target_) filter_target_->recv(p->copy(), h); /* fallthrough */ case PASS : send(p, h); break; case FILTER : if (filter_target_) filter_target_->recv(p, h); break; } } int Filter::command(int argc, const char*const* argv) { Tcl& tcl = Tcl::instance(); if (argc == 2) { if (strcmp(argv[1], "filter-target") == 0) { if (filter_target_ != 0) tcl.result(target_->name()); return TCL_OK; } } else if (argc == 3) { if (strcmp(argv[1], "filter-target") == 0) { filter_target_ = (NsObject*)TclObject::lookup(argv[2]); return TCL_OK; } } return Connector::command(argc, argv); } static class FieldFilterClass : public TclClass { public: FieldFilterClass() : TclClass("Filter/Field") {} TclObject* create(int, const char*const*) { return (new FieldFilter); } } class_filter_field; FieldFilter::FieldFilter() { bind("offset_", &offset_); bind("match_", &match_); } Filter::filter_e FieldFilter::filter(Packet *p) { return (*(int *)p->access(offset_) == match_) ? FILTER : PASS; } /* 10-5-98, Polly Huang, Filters that filter on multiple fields */ static class MultiFieldFilterClass : public TclClass { public: MultiFieldFilterClass() : TclClass("Filter/MultiField") {} TclObject* create(int, const char*const*) { return (new MultiFieldFilter); } } class_filter_multifield; MultiFieldFilter::MultiFieldFilter() : field_list_(0) { } void MultiFieldFilter::add_field(fieldobj *p) { p->next = field_list_; field_list_ = p; } MultiFieldFilter::filter_e MultiFieldFilter::filter(Packet *p) { fieldobj* tmpfield; tmpfield = field_list_; while (tmpfield != 0) { if (*(int *)p->access(tmpfield->offset) == tmpfield->match) tmpfield = tmpfield->next; else return (PASS); } return(FILTER); } int MultiFieldFilter::command(int argc, const char*const* argv) { Tcl& tcl = Tcl::instance(); if (argc == 2) { if (strcmp(argv[1], "filter-target") == 0) { if (filter_target_ != 0) tcl.result(target_->name()); return TCL_OK; } } else if (argc == 3) { if (strcmp(argv[1], "filter-target") == 0) { filter_target_ = (NsObject*)TclObject::lookup(argv[2]); return TCL_OK; } } else if (argc == 4) { if (strcmp(argv[1], "filter-field") == 0) { fieldobj *tmp = new fieldobj; tmp->offset = atoi(argv[2]); tmp->match = atoi(argv[3]); add_field(tmp); return TCL_OK; } } return Connector::command(argc, argv); }

flowmon.cc

fq.cc

fsm.cc

god.cc

gridkeeper.cc

/* * An optimizer for some wireless simulations * * Helps most when some nodes are mostly stationary. * We hope you can share your experience with the gridkeeper with us. * * Ported from Sun's mobility code */ #include "gridkeeper.h" static double d2(double x1, double x2, double y1, double y2) { return ((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)); } /* static class GridHandlerClass : public TclClass { public: GridHandlerClass() : TclClass("GridHandler") {} TclObject* create(int, const char*const*){ return (new GridHandler()); } } class_grid_handler; */ GridHandler::GridHandler() { } void GridHandler::handle(Event *e) { MoveEvent *me = (MoveEvent *)e; MobileNode **pptr; MobileNode * token_ = me->token_; if ((pptr = me->leave_)) { while (*pptr) { if ((*pptr)->address_ == token_->address_) break; pptr = &((*pptr)->next_); } if (!(*pptr)) abort(); else { *pptr = token_->next_; token_->next_ = 0; } } if ((pptr = me->enter_)) { if (token_->next_) abort(); // can't be in more than one grid token_->next_ = *pptr; *pptr = token_; } delete me; // dump info in the gridkeeper for debug only // dump(); } GridKeeper* GridKeeper::instance_; static class GridKeeperClass : public TclClass { public: GridKeeperClass() : TclClass("GridKeeper") {} TclObject* create(int, const char*const*) { return (new GridKeeper); } } class_grid_keeper; GridKeeper::GridKeeper() : size_(0),grid_(NULL), dim_x_(0), dim_y_(0) { gh_ = new GridHandler(); } GridKeeper::~GridKeeper() { int i; for (i = 0; i <= dim_x_; i++) { delete [] grid_[i]; } delete [] grid_; } int GridKeeper::command(int argc, const char*const* argv) { int i, grid_x, grid_y; Tcl& tcl = Tcl::instance(); MobileNode *mn; if (argc == 2) { if (strcmp(argv[1], "dump") == 0) { dump(); return (TCL_OK); } } if (argc == 3) { if (strcmp(argv[1], "addnode") == 0) { mn = (MobileNode *)TclObject::lookup(argv[2]); grid_x = aligngrid((int)mn->X, dim_x_); grid_y = aligngrid((int)mn->Y, dim_y_); mn->next_ = grid_[grid_x][grid_y]; grid_[grid_x][grid_y] = mn; size_++; return (TCL_OK); } } if (argc == 4 && strcmp(argv[1], "dimension") == 0) { if (instance_ == 0) instance_ = this; dim_x_ = strtol(argv[2], (char**)0, 0); dim_y_ = strtol(argv[3], (char**)0, 0); if (dim_x_ <= 0 || dim_y_ <= 0) { tcl.result("illegal grid dimension"); return (TCL_ERROR); } grid_ = new MobileNode **[dim_x_]; for (i = 0; i < dim_x_; i++) { grid_[i] = new MobileNode *[dim_y_]; bzero((void *)grid_[i], sizeof(MobileNode *)*dim_y_); } return (TCL_OK); } return (TclObject::command(argc, argv)); } void GridKeeper::new_moves(MobileNode *mn) { double x = mn->X, y = mn->Y; double ss = mn->speed; double vx = (mn->dX)*ss, vy = (mn->dY)*ss; // double interval = mn->position_update_interval; double endx, endy, pother, tm; int i, j, endi, gother, grid_x, grid_y; MoveEvent *me; Scheduler& s = Scheduler::instance(); endx = mn->destX; endy = mn->destY; if (vx > 0) { endi = min(dim_x_-1, (int)endx); for (i = (int)x+1; i <= endi; i++) { tm = (i-x)/vx; pother = vy*tm + y; j = (int)pother; me = new MoveEvent; if (j == pother && j != 0 && j != dim_y_) { if (vy > 0) gother = j - 1; else if (vy < 0) gother = j + 1; else gother = j; } else { gother = j; } me->leave_ = &(grid_[aligngrid(i-1, dim_x_)][aligngrid(gother, dim_y_)]); me->grid_x_ = grid_x = aligngrid(i, dim_x_); me->grid_y_ = grid_y = aligngrid(j, dim_y_); me->enter_ = &(grid_[grid_x][grid_y]); me->token_ = mn; s.schedule(gh_, me, tm); } } else if (vx < 0) { endi = (int)endx; for (i = (int)x; i > endi; i--) { if (i == dim_x_) continue; tm = (i-x)/vx; pother = vy*tm + y; j = (int)pother; me = new MoveEvent; if (j == pother && j != 0 && j != dim_y_) { if (vy > 0) gother = j - 1; else if (vy < 0) gother = j + 1; else gother = j; } else { gother = j; } me->leave_ = &grid_[aligngrid(i, dim_x_)][aligngrid(gother, dim_y_)]; me->grid_x_ = grid_x = aligngrid(i-1, dim_x_); me->grid_y_ = grid_y = aligngrid(j, dim_y_); me->enter_ = &grid_[grid_x][grid_y]; me->token_ = mn; s.schedule(gh_, me, tm); } } if (vy > 0) { endi = min(dim_y_-1, (int)endy); for (j = (int)y+1; j <= endi; j++) { tm = (j-y)/vy; pother = vx*tm + x; i = (int)pother; me = new MoveEvent; if (i == pother && i != 0 && i != dim_x_ && vx != 0) continue; me->leave_ = &grid_[aligngrid(i, dim_x_)][aligngrid(j-1, dim_y_)]; me->grid_x_ = grid_x = aligngrid(i, dim_x_); me->grid_y_ = grid_y = aligngrid(j, dim_y_); me->enter_ = &grid_[grid_x][grid_y]; me->token_ = mn; s.schedule(gh_, me, tm); } } else if (vy < 0) { endi = (int)endy; for (j = (int)y; j > endi; j--) { if (j == dim_y_) continue; tm = (j-y)/vy; pother = vx*tm + x; i = (int)pother; me = new MoveEvent; if (i == pother && i != 0 && i != dim_x_ && vx != 0) continue; me->leave_ = &grid_[aligngrid(i, dim_x_)][aligngrid(j, dim_y_)]; me->grid_x_ = grid_x = aligngrid(i, dim_x_); me->grid_y_ = grid_y = aligngrid(j-1, dim_y_); me->enter_ = &grid_[grid_x][grid_y]; me->token_ = mn; s.schedule(gh_, me, tm); } } } int GridKeeper::get_neighbors(MobileNode* mn, MobileNode **output) { int grid_x, grid_y, index = 0, i, j, ulx, uly, lly, adj; MobileNode *pgd; double mnx, mny, mnr, sqmnr; mn->update_position(); mnx = mn->X; mny = mn->Y; grid_x = aligngrid((int)mn->X, dim_x_); grid_y = aligngrid((int)mn->Y, dim_y_); sqmnr = (mnr = mn->radius_)*mnr; adj = (int)ceil(mnr); ulx = min(dim_x_-1, grid_x + adj); uly = min(dim_y_-1, grid_y + adj); lly = max(0, grid_y - adj); for (i = max(0, grid_x - adj); i <= ulx; i++) { for (j = lly; j <= uly; j++) { for (pgd = grid_[i][j]; pgd != 0; pgd = pgd->next_) { if (mn->address_ == pgd->address_) continue; pgd->update_position(); if (d2(pgd->X, mnx, pgd->Y, mny) < sqmnr) output[index++] = pgd; } } } return index; } void GridKeeper::dump() { int i,j; MobileNode *pgd; for (i = 0; i< dim_x_; i++) { for (j = 0; j < dim_y_; j++) { if (grid_[i][j] == 0) continue; printf("grid[%d][%d]: ",i,j); for (pgd = grid_[i][j]; pgd != 0; pgd = pgd->next_) { printf("%d ",pgd->address_); } printf("\n"); } } printf("-------------------------------\n"); }

hackloss.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ #ifndef lint static const char rcsid[] = "@(#) $Header$"; #endif #include "connector.h" #include "packet.h" #include "queue.h" class HackLossyLink : public Connector { public: HackLossyLink() : down_(0), src_(0), dst_(0), fid_(0), ctr_(0), nth_(0){ bind("off_ip_", &off_ip_); } protected: int command(int argc, const char*const* argv); void recv(Packet* p, Handler* h); NsObject* down_; int src_, dst_, fid_; int ctr_, nth_; int off_ip_; }; static class HackLossyLinkClass : public TclClass { public: HackLossyLinkClass() : TclClass("HackLossyLink") {} TclObject* create(int, const char*const*) { return (new HackLossyLink); } } class_dynamic_link; int HackLossyLink::command(int argc, const char*const* argv) { if (strcmp(argv[1], "down-target") == 0) { NsObject* p = (NsObject*)TclObject::lookup(argv[2]); if (p == 0) { Tcl::instance().resultf("no object %s", argv[2]); return TCL_ERROR; } down_ = p; return TCL_OK; } if (strcmp(argv[1], "show-params") == 0) { Tcl::instance().resultf("src_ = %d, dst_ = %d, fid_ = %d, nth_ = %d", src_, dst_, fid_, nth_); return TCL_OK; } if (strcmp(argv[1], "set-params") == 0) { src_ = atoi(argv[2]); dst_ = atoi(argv[3]); fid_ = atoi(argv[4]); return TCL_OK; } if (strcmp(argv[1], "nth") == 0) { nth_ = atoi(argv[2]); return TCL_OK; } return Connector::command(argc, argv); } void HackLossyLink::recv(Packet* p, Handler* h) { hdr_ip* iph = (hdr_ip*) p->access(off_ip_); if (nth_ && (iph->flowid() == fid_) && (iph->saddr() == src_) && (iph->daddr() == dst_) && ((++ctr_ % nth_) == 0)) down_->recv(p); // XXX Why no handler? else target_->recv(p, h); }

hb-adc.cc

integrator.cc

ip.cc

ivs.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (c) 1996-1997 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Computer Systems * Engineering Group at Lawrence Berkeley Laboratory. * 4. Neither the name of the University nor of the Laboratory may be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (LBL)"; #endif #include <stdlib.h> #include <math.h> #include "message.h" #include "trace.h" #include "agent.h" /* ivs data packet; ctrl packets are sent back as "messages" */ struct hdr_ivs { double ts_; /* timestamp sent at source */ u_int8_t S_; u_int8_t R_; u_int8_t state_; u_int8_t rshft_; u_int8_t kshft_; u_int16_t key_; double maxrtt_; int seqno_; static int offset_; inline static int& offset() { return offset_; } inline static hdr_ivs* access(Packet* p) { return (hdr_ivs*) p->access(offset_); } /* per-field member functions */ double& ts() { return (ts_); } u_int8_t& S() { return (S_); } u_int8_t& R() { return (R_); } u_int8_t& state() { return (state_); } u_int8_t& rshft() { return (rshft_); } u_int8_t& kshft() { return (kshft_); } u_int16_t& key() { return (key_); } double& maxrtt() { return (maxrtt_); } int& seqno() { return (seqno_); } }; int hdr_ivs::offset_; static class IvsHeaderClass : public PacketHeaderClass { public: IvsHeaderClass() : PacketHeaderClass("PacketHeader/IVS", sizeof(hdr_ivs)) { bind_offset(&hdr_ivs::offset_); } } class_ivshdr; class IvsSource : public Agent { public: IvsSource(); protected: void reset(); void recv(Packet *pkt, Handler*); void sendpkt(); int S_; int R_; int state_; #define ST_U 0 #define ST_L 1 #define ST_C 2 int rttShift_; int keyShift_; int key_; double maxrtt_; int off_ivs_; int off_msg_; }; struct Mc_Hole { int start; int end; double time; Mc_Hole* next; }; class IvsReceiver : public Agent { public: IvsReceiver(); int command(int argc, const char*const* argv); protected: void recv(Packet *pkt, Handler*); void update_ipg(double now); int lossMeter(double timeDiff, u_int32_t seq, double maxrtt); void upcall_respond(double ts, int matchS); void upcall_rtt_solicit(double ts, int rshift); int state_; u_int32_t nextSeq_; double timeMean_; double timeVar_; double ipg_; /* interpkt gap (estimator) */ Mc_Hole* head_; Mc_Hole* tail_; double lastPktTime_; int ignoreR_; double lastTime_; /* last time a resp pkt sent */ int key_; int off_ivs_; int off_msg_; }; static class IvsSourceClass : public TclClass { public: IvsSourceClass() : TclClass("Agent/IVS/Source") {} TclObject* create(int, const char*const*) { return (new IvsSource()); } } class_ivs_source; static class IvsReceiverClass : public TclClass { public: IvsReceiverClass() : TclClass("Agent/IVS/Receiver") {} TclObject* create(int, const char*const*) { return (new IvsReceiver()); } } class_ivs_receiver; IvsSource::IvsSource() : Agent(PT_MESSAGE), S_(0), R_(0), state_(ST_U), rttShift_(0), keyShift_(0), key_(0), maxrtt_(0) { bind("S_", &S_); bind("R_", &R_); bind("state_", &state_); bind("rttShift_", &rttShift_); bind("keyShift_", &keyShift_); bind("key_", &key_); bind("maxrtt_", &maxrtt_); bind("off_ivs_", &off_ivs_); bind("off_msg_", &off_msg_); } void IvsSource::reset() { } /* * main reception path - should only see acks, otherwise the * network connections are misconfigured */ void IvsSource::recv(Packet* pkt, Handler*) { char wrk[128];/*XXX*/ Tcl& tcl = Tcl::instance(); hdr_msg *q = (hdr_msg*)pkt->access(off_msg_); sprintf(wrk, "%s handle {%s}", name(), q->msg()); tcl.eval(wrk); Packet::free(pkt); } #ifdef notdef void IvsSource::probe_timeout() { rndStart_ = now; if (keyShift_ == 15) { if (key_ == 0) { if (solicitedResponses_ == 0) estReceivers_ = 0; /* * Got through a round without being LOADED. * increase send rate. */ if (state_ == ST_U) increase(); /* Reset keys et al */ S_ = 1; state_ = ST_U; /*XXX*/ setRttSolicit(mcstate); solicitedResponses_ = 0; keyShift_ = startShift_; /*XXX do all this in tcl? */ setkey(); } else { mcstate->hdr.key = 0; } } else { if (probeTimeout_ > 0) ++keyShift_; } sched(pktTime + 2 * maxrtt_, IVS_TIMER_PROBE); } #endif void IvsSource::sendpkt() { Packet* pkt = allocpkt(); hdr_ivs *p = (hdr_ivs*)pkt->access(off_ivs_); /*fill in ivs fields */ p->ts() = Scheduler::instance().clock(); p->S() = S_; p->R() = R_; p->state() = state_; p->rshft() = rttShift_; p->kshft() = keyShift_; p->key() = key_; p->maxrtt() = maxrtt_; target_->recv(pkt, (Handler *)0); } IvsReceiver::IvsReceiver() : Agent(PT_MESSAGE), state_(ST_U), nextSeq_(0), timeMean_(0.), timeVar_(0.),/*XXX*/ ipg_(0.), head_(0), tail_(0), lastPktTime_(0.), ignoreR_(0), lastTime_(0.), key_(0) { bind("ignoreR_", &ignoreR_); bind("key_", &key_); bind("state_", &state_); bind("packetSize_", &size_); bind("off_ivs_", &off_ivs_); bind("off_msg_", &off_msg_); } inline void IvsReceiver::update_ipg(double v) { /* Update the estimated interpacket gap */ ipg_ = (15 * ipg_ + v) / 16; } /* * timestamp comes in milliseconds since start of connection according to * remote clock * now is milliseconds since start of connection * rtt in milliseconds * This congestion meter is not terribly good at figuring out when the net is * loaded, since the loss of a packet over a rtt is a transitory event * Eventually we ought to have a memory thing, that records state once a * maxrtt, with thresholds to decide current state */ int IvsReceiver::lossMeter(double timeDiff, u_int32_t seq, double maxrtt) { /* * The congestion signal is calculated here by measuring the loss in a * given period of packets - if the threshold for lost packets is * passed then signal Congested. If there are no lost packets, * then we are at UNLOADED, else LOADED */ /* if sequence number is next, increase expected number */ double now = Scheduler::instance().clock(); if (nextSeq_ == 0) nextSeq_ = seq + 1; else if (seq == nextSeq_) nextSeq_++; else if (seq > nextSeq_) { #ifdef notdef if (trace_ != 0) { sprintf(trace_->buffer(), "d %g %d", lastPktTime_, seq - nextSeq_); trace_->dump(); } #endif /* This is definitely a hole */ Mc_Hole* hole = new Mc_Hole; hole->time = now; hole->start = nextSeq_; hole->end = seq - 1; hole->next = 0; /* Now add it to the list */ if (head_ == NULL) { head_ = hole; tail_ = hole; } else { tail_->next = hole; tail_ = hole; } nextSeq_ = seq + 1; } else { /* XXX can't happen in current ns simulations */ fprintf(stderr, "ns: ivs rcvr: seq number went backward\n"); abort(); } /* update the calculation of the variance in the rtt */ /* get the time averaged mean of the difference */ if (timeMean_ == 0) timeMean_ = timeDiff; else timeMean_ = (7 * timeMean_ + timeDiff) / 8; timeDiff -= timeMean_; if (timeDiff < 0) timeDiff = -timeDiff; timeVar_ = (7 * timeVar_ + timeDiff) / 8; int lostPkts = 0; /* * Check down the list of holes, discarding those that before * now-rttvar-rtt, counting those that fall within * now-rttvar to now-rttvar-rtt */ if (head_ == 0) return (ST_U); Mc_Hole *cur = head_, *prev = NULL; double validEnd = now - 2 * timeVar_; double validStart = validEnd - maxrtt; /* for each hole, if it is older than required, dump it */ /* If it is valid, add the size to the loss count */ /* Go to the next hole */ while (cur != NULL) { if (cur->time < validStart) { if (prev == NULL) head_ = cur->next; else prev->next = cur->next; delete cur; if (prev == NULL) cur = head_; else cur = prev->next; } else { if (cur->time < validEnd) lostPkts += cur->end - cur->start + 1; prev = cur; cur = cur->next; } } /* * Update the moving average calculation of the number of holes, if * nowMs is another rtt away */ double pps = (ipg_ != 0) ? maxrtt / ipg_ : 0.; /*XXX*/ #ifdef notdef if (trace_ != 0) { double now = Scheduler::instance().clock(); sprintf(trace_->buffer(), "%.17g %g", now, (double)lostPkts / pps); trace_->dump(); } #endif /*XXX*/ #define LOSSCONGTH 15 #define LOSSLOADTH 5 /* If the rtt is smaller than the ipg, set the thresholds to 0,1,2 */ if ((pps * LOSSCONGTH) / 100 < 2) pps = 200 / LOSSCONGTH; if (lostPkts <= (LOSSLOADTH * pps) / 100) return (ST_U); else if (lostPkts <= (LOSSCONGTH * pps) / 100) return (ST_L); else return (ST_C); } void IvsReceiver::recv(Packet* pkt, Handler*) { hdr_ivs *p = (hdr_ivs*)pkt->access(off_ivs_); double now = Scheduler::instance().clock(); if (lastPktTime_ == 0.) { lastPktTime_ = now; Packet::free(pkt); return; } update_ipg(now - lastPktTime_); double ts = p->ts(); int prevState = state_; state_ = lossMeter(now - ts, p->seqno(), p->maxrtt()); lastPktTime_ = now; /* If soliciting rtt */ if (p->R() && !ignoreR_) /* upcall into tcl */ upcall_rtt_solicit(ts, p->rshft()); /* * send a response if we're congested and its over an rtt since * we last sent one OR * any response is solicited to estimate size and we match the key OR * we're LOADED and we match the key and its over an rtt since we last * sent a response */ if (now - lastTime_ < p->maxrtt() && state_ <= prevState) { Packet::free(pkt); return; } int shift = p->kshft(); int match; if (p->key() == 0) match = 1; else match = (key_ >> shift) == (p->key() >> shift); int matchS = match ? p->S() : 0; if (state_ == ST_C || matchS || (match && state_ == ST_L)) { upcall_respond(ts, matchS); lastTime_ = now; } Packet::free(pkt); } void IvsReceiver::upcall_respond(double ts, int matchS) { Tcl::instance().evalf("%s respond %.17g %d", name(), ts, matchS); } void IvsReceiver::upcall_rtt_solicit(double ts, int rshift) { Tcl::instance().evalf("%s solicit-rtt %.17g %d", name(), ts, rshift); } int IvsReceiver::command(int argc, const char*const* argv) { Tcl& tcl = Tcl::instance(); if (argc == 3) { if (strcmp(argv[1], "send") == 0) { Packet* pkt = allocpkt(); hdr_msg* p = (hdr_msg*)pkt->access(off_msg_); const char* s = argv[2]; int n = strlen(s); if (n >= p->maxmsg()) { tcl.result("message too big"); Packet::free(pkt); return (TCL_ERROR); } strcpy(p->msg(), s); target_->recv(pkt, (Handler*)0); return (TCL_OK); } } return (Agent::command(argc, argv)); }

lanRouter.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * lanRouter.cc * Copyright (C) 1998 by USC/ISI * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, advertising * materials, and other materials related to such distribution and use * acknowledge that the software was developed by the University of * Southern California, Information Sciences Institute. The name of the * University may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef lint static const char rcsid[] = "@(#) $Header: /usr/src/mash/repository/vint/ns-2/lanRouter.cc"; #endif #include <tcl.h> #include <iostream.h> #include "lanRouter.h" #include "address.h" #include "ip.h" static class LanRouterClass : public TclClass { public: LanRouterClass() : TclClass("LanRouter") {} TclObject* create(int, const char*const*) { return (new LanRouter()); } } class_mac; int LanRouter::next_hop(Packet *p) { if (switch_ && switch_->classify(p)==1) { return -1; } if (!routelogic_) return -1; hdr_ip* iph= hdr_ip::access(p); char* adst= Address::instance().print_nodeaddr(iph->daddr()); int next_hopIP; if (enableHrouting_) { char* bdst; routelogic_->lookup_hier(lanaddr_, adst, next_hopIP); // hacking: get rid of the last "." bdst = Address::instance().print_nodeaddr(next_hopIP); // bdst[strlen(bdst)-1] = '\0'; Tcl &tcl = Tcl::instance(); tcl.evalf("[Simulator instance] get-node-id-by-addr %s", bdst); sscanf(tcl.result(), "%d", &next_hopIP); delete [] bdst; } else { routelogic_->lookup_flat(lanaddr_, adst, next_hopIP); } delete [] adst; return next_hopIP; } int LanRouter::command(int argc, const char*const* argv) { // Tcl& tcl = Tcl::instance(); if (argc == 3) { // cmd lanaddr <addr> if (strcmp(argv[1], "lanaddr") == 0) { strcpy(lanaddr_, argv[2]); return (TCL_OK); } // cmd routing hier|flat if (strcmp(argv[1], "routing") == 0) { if (strcmp(argv[2], "hier")==0) enableHrouting_= true; else if (strcmp(argv[2], "flat")==0) enableHrouting_= false; else return (TCL_ERROR); return (TCL_OK); } // cmd switch <switch> if (strcmp(argv[1], "switch") == 0) { switch_ = (Classifier*) TclObject::lookup(argv[2]); return (TCL_OK); } // cmd routelogic <routelogic> if (strcmp(argv[1], "routelogic") == 0) { routelogic_ = (RouteLogic*) TclObject::lookup(argv[2]); return (TCL_OK); } } return NsObject::command(argc, argv); }

ll.cc

loss-monitor.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (c) 1994-1997 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Computer Systems * Engineering Group at Lawrence Berkeley Laboratory. * 4. Neither the name of the University nor of the Laboratory may be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (LBL)"; #endif #include "agent.h" #include "config.h" #include "tclcl.h" #include "packet.h" #include "ip.h" #include "rtp.h" class LossMonitor : public Agent { public: LossMonitor(); int command(int argc, const char*const* argv); void recv(Packet* pkt, Handler*); protected: int nlost_; int npkts_; int expected_; int bytes_; int seqno_; double last_packet_time_; int off_rtp_; }; static class LossMonitorClass : public TclClass { public: LossMonitorClass() : TclClass("Agent/LossMonitor") {} TclObject* create(int, const char*const*) { return (new LossMonitor()); } } class_loss_mon; LossMonitor::LossMonitor() : Agent(PT_NTYPE) { bytes_ = 0; nlost_ = 0; npkts_ = 0; expected_ = -1; last_packet_time_ = 0.; seqno_ = 0; bind("nlost_", &nlost_); bind("npkts_", &npkts_); bind("bytes_", &bytes_); bind("lastPktTime_", &last_packet_time_); bind("expected_", &expected_); bind("off_rtp_", &off_rtp_); } void LossMonitor::recv(Packet* pkt, Handler*) { hdr_rtp* p = (hdr_rtp*)pkt->access(off_rtp_); seqno_ = p->seqno(); bytes_ += ((hdr_cmn*)pkt->access(off_cmn_))->size(); ++npkts_; /* * Check for lost packets */ if (expected_ >= 0) { int loss = seqno_ - expected_; if (loss > 0) { nlost_ += loss; Tcl::instance().evalf("%s log-loss", name()); } } last_packet_time_ = Scheduler::instance().clock(); expected_ = seqno_ + 1; Packet::free(pkt); } /* * $proc interval $interval * $proc size $size */ int LossMonitor::command(int argc, const char*const* argv) { if (argc == 2) { if (strcmp(argv[1], "clear") == 0) { expected_ = -1; return (TCL_OK); } } return (Agent::command(argc, argv)); }

mac-802_11.cc

mac-802_3.cc

mac-csma.cc

mac-multihop.cc

mac-timers.cc

mac.cc

mcast_ctrl.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * mcast_ctrl.cc * Copyright (C) 1997 by USC/ISI * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, advertising * materials, and other materials related to such distribution and use * acknowledge that the software was developed by the University of * Southern California, Information Sciences Institute. The name of the * University may not be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * * Contributed by Polly Huang (USC/ISI), http://www-scf.usc.edu/~bhuang */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (LBL)"; #endif #include "agent.h" #include "packet.h" #include "mcast_ctrl.h" class mcastControlAgent : public Agent { public: mcastControlAgent() : Agent(PT_NTYPE) { bind("packetSize_", &size_); bind("off_mcast_ctrl_", &off_mcast_ctrl_); } void recv(Packet* pkt, Handler*) { hdr_mcast_ctrl* ph = (hdr_mcast_ctrl*)pkt->access(off_mcast_ctrl_); hdr_cmn* ch = (hdr_cmn*)pkt->access(off_cmn_); // Agent/Mcast/Control instproc recv type from src group iface Tcl::instance().evalf("%s recv %s %d %d", name(), ph->type(), ch->iface(), ph->args()); Packet::free(pkt); } /* * $proc send $type $src $group */ #define CASE(c,str,type) \ case (c): if (strcmp(argv[2], (str)) == 0) { \ type_ = (type); \ break; \ } else { \ /*FALLTHROUGH*/ \ } int command(int argc, const char*const* argv) { if (argc == 4) { if (strcmp(argv[1], "send") == 0) { switch (*argv[2]) { CASE('p', "prune", PT_PRUNE); CASE('g', "graft", PT_GRAFT); CASE('X', "graftAck", PT_GRAFTACK); CASE('j', "join", PT_JOIN); CASE('a', "assert", PT_ASSERT); default: Tcl& tcl = Tcl::instance(); tcl.result("invalid control message"); return (TCL_ERROR); } Packet* pkt = allocpkt(); hdr_mcast_ctrl* ph = (hdr_mcast_ctrl*)pkt->access(off_mcast_ctrl_); strcpy(ph->type(), argv[2]); ph->args() = atoi(argv[3]); send(pkt, 0); return (TCL_OK); } } return (Agent::command(argc, argv)); } protected: int off_mcast_ctrl_; }; // // Now put the standard OTcl linkage templates here // static class mcastControlHeaderClass : public PacketHeaderClass { public: mcastControlHeaderClass() : PacketHeaderClass("PacketHeader/mcastCtrl", sizeof(hdr_mcast_ctrl)) {} } class_mcast_ctrl_hdr; static class mcastControlClass : public TclClass { public: mcastControlClass() : TclClass("Agent/Mcast/Control") {} TclObject* create(int, const char*const*) { return (new mcastControlAgent()); } } class_mcast_ctrl;

measuremod.cc

message.cc

/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (c) 1994-1997 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Computer Systems * Engineering Group at Lawrence Berkeley Laboratory. * 4. Neither the name of the University nor of the Laboratory may be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef lint static const char rcsid[] = "@(#) $Header$ (LBL)"; #endif #include "agent.h" #include "random.h" #include "message.h" int hdr_msg::offset_; static class MessageHeaderClass : public PacketHeaderClass { public: MessageHeaderClass() : PacketHeaderClass("PacketHeader/Message", sizeof(hdr_msg)) { bind_offset(&hdr_msg::offset_); } } class_msghdr; class MessageAgent : public Agent { public: MessageAgent(); int command(int argc, const char*const* argv); void recv(Packet*, Handler*); }; static class MessageClass : public TclClass { public: MessageClass() : TclClass("Agent/Message") {} TclObject* create(int, const char*const*) { return (new MessageAgent()); } } class_message; MessageAgent::MessageAgent() : Agent(PT_MESSAGE) { bind("packetSize_", &size_); } void MessageAgent::recv(Packet* pkt, Handler*) { hdr_msg* mh = hdr_msg::access(pkt); char wrk[128];/*XXX*/ sprintf(wrk, "%s recv {%s}", name(), mh->msg()); Tcl& tcl = Tcl::instance(); tcl.eval(wrk); Packet::free(pkt); } /* * $proc handler $handler * $proc send $msg */ int MessageAgent::command(int argc, const char*const* argv) { Tcl& tcl = Tcl::instance(); if (argc == 3) { if (strcmp(argv[1], "send") == 0) { Packet* pkt = allocpkt(); hdr_msg* mh = hdr_msg::access(pkt); const char* s = argv[2]; int n = strlen(s); if (n >= mh->maxmsg()) { tcl.result("message too big"); Packet::free(pkt); return (TCL_ERROR); } strcpy(mh->msg(), s); send(pkt, 0); return (TCL_OK); } } return (Agent::command(argc, argv)); }