ns2 Network Simulator 2.29: ReservePortClassifier Class Reference

00064 {ONCE= -2, TWICE= -1};

00070 : PortClassifier(), reserved_(0) {}

00080 {
00081     NsObject** old = slot_;
00082     int n = nslot_;
00083     if (old == 0) 
00084         if (nsize_ != 0) {
00085             //printf("classifier %x set to %d....%dth visit\n", this, nsize_, i++);
00086             nslot_ = nsize_;
00087         }
00088         else {
00089             //printf("classifier %x set to 32....%dth visit\n", this, j++);
00090             nslot_ = 32;
00091         }
00092     while (nslot_ <= slot) 
00093         nslot_ <<= 1;
00094     slot_ = new NsObject*[nslot_];
00095     memset(slot_, 0, nslot_ * sizeof(NsObject*));
00096     for (int i = 0; i < n; ++i)
00097         slot_[i] = old[i];
00098     delete [] old;
00099 }

00121 {
00122     return getnxt (nullagent);
00123 }

00057 {
00058     // Port classifier returns the destination port.  No shifting
00059     // or masking is required since in the 32-bit addressing,
00060     // ports are stored in a seperate variable.
00061     hdr_ip* iph = hdr_ip::access(p);
00062     return iph->dport();
00063 };

00092 {
00093         slot_[slot] = 0;
00094         if (slot == maxslot_) {
00095                 while (--maxslot_ >= reserved_ && slot_[maxslot_] == 0)
00096                         ;
00097         }
00098 }

00082 {
00083         if (argc == 3 && strcmp(argv[1],"reserve-port") == 0) {
00084                 reserved_ = atoi(argv[2]);
00085                 alloc((maxslot_ = reserved_ - 1));
00086                 return(TCL_OK);
00087         }
00088         return (Classifier::command(argc, argv));
00089 }

00103 {
00104     if (!debug_)
00105         return;
00106     va_list ap;
00107     va_start(ap, fmt);
00108     vprintf(fmt, ap);
00109 }

00064 {
00065     if (delay_bind_bool(varName, localName, "debug_", &debug_, tracer)) 
00066         return TCL_OK;
00067     return TclObject::delay_bind_dispatch(varName, localName, tracer);
00068 }

00058 {
00059     delay_bind_init_one("debug_");
00060 }

00066                                                          {
00067         int slot = atoi(dst);
00068         install(slot, target); }

00160 {
00161     NsObject* node = NULL;
00162     int cl = classify(p);
00163     if (cl < 0 || cl >= nslot_ || (node = slot_[cl]) == 0) { 
00164         if (default_target_) 
00165             return default_target_;
00166         /*
00167          * Sigh.  Can't pass the pkt out to tcl because it's
00168          * not an object.
00169          */
00170         Tcl::instance().evalf("%s no-slot %ld", name(), cl);
00171         if (cl == TWICE) {
00172             /*
00173              * Try again.  Maybe callback patched up the table.
00174              */
00175             cl = classify(p);
00176             if (cl < 0 || cl >= nslot_ || (node = slot_[cl]) == 0)
00177                 return (NULL);
00178         }
00179     }
00180     return (node);
00181 }

00101 {
00102         int i;
00103         for (i=reserved_; i < nslot_; i++)
00104                 if (slot_[i]==0 || slot_[i]==nullagent)
00105                         return i;
00106         i=nslot_;
00107         alloc(nslot_); 
00108         return i;
00109 }

00092 {
00093     recv((Packet*)e);
00094 }

00103 {
00104     if (slot >= nslot_)
00105         alloc(slot);
00106     slot_[slot] = p;
00107     if (slot >= maxslot_)
00108         maxslot_ = slot;
00109 }

00183                                            {
00184     int slot = maxslot_ + 1;
00185     install(slot, node);
00186     return (slot);
00187 }

00061 { return debug_; }

00049 { return maxslot_; }

00055 { return ((val >> shift_) & mask_); }

00097 {
00098     Packet::free(p);
00099 }

00141 {
00142     NsObject* node = find(p);
00143     if (node == NULL) {
00144         /*
00145          * XXX this should be "dropped" somehow.  Right now,
00146          * these events aren't traced.
00147          */
00148         Packet::free(p);
00149         return;
00150     }
00151     node->recv(p,h);
00152 }

00056                                                   { 
00057         default_target_ = obj;
00058     }

00075 {
00076     nsize_ = nn;
00077 }

00050                                     {
00051         if ((slot >= 0) && (slot < nslot_))
00052             return slot_[slot];
00053         return 0;
00054     }


Public Types
enum	classify_ret { ONCE = -2, TWICE = -1 }
Public Member Functions
int	allocPort (NsObject *)
virtual void	debug (const char *fmt,...)
virtual int	delay_bind_dispatch (const char varName, const char localName, TclObject *tracer)
virtual void	delay_bind_init_all ()
virtual void	do_install (char dst, NsObject target)
virtual NsObject *	find (Packet *)
virtual void	install (int slot, NsObject *)
int	install_next (NsObject *node)
int	isdebug () const
int	maxslot () const
int	mshift (int val)
virtual void	recv (Packet p, const char s)
virtual void	recv (Packet p, Handler h)
virtual void	recvOnly (Packet *)
	ReservePortClassifier ()
void	set_default_target (NsObject *obj)
virtual void	set_table_size (int level, int nn)
void	set_table_size (int nn)
NsObject *	slot (int slot)
Protected Member Functions
void	alloc (int)
int	classify (Packet *p)
void	clear (int slot)
int	command (int argc, const char const argv)
int	getnxt (NsObject *)
void	handle (Event *)
virtual void	reset ()
Protected Attributes
int	debug_
NsObject *	default_target_
int	mask_
int	maxslot_
int	nsize_
int	nslot_
int	offset_
int	reserved_
int	shift_
NsObject **	slot_

ReservePortClassifier Class Reference

Detailed Description

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation