NS2.26SourcesOriginal: ReservePortClassifier class Reference

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

00042 : 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 }

00031 {
00032         // Port classifier returns the destination port.  No shifting
00033         // or masking is required since in the 32-bit addressing,
00034         // ports are stored in a seperate variable.
00035         hdr_ip* iph = hdr_ip::access(p);
00036         return iph->dport();
00037 };

00066 {
00067         slot_[slot] = 0;
00068         if (slot == maxslot_) {
00069                 while (--maxslot_ >= reserved_ && slot_[maxslot_] == 0)
00070                         ;
00071         }
00072 }

00056 {
00057         if (argc == 3 && strcmp(argv[1],"reserve-port") == 0) {
00058                 reserved_ = atoi(argv[2]);
00059                 alloc((maxslot_ = reserved_ - 1));
00060                 return(TCL_OK);
00061         }
00062         return (Classifier::command(argc, argv));
00063 }

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); }

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

00075 {
00076         int i;
00077         for (i=reserved_; i < nslot_; i++)
00078                 if (slot_[i]==0 || slot_[i]==nullagent)
00079                         return i;
00080         i=nslot_;
00081         alloc(nslot_); 
00082         return i;
00083 }

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 }

00178                                            {
00179         int slot = maxslot_ + 1;
00180         install(slot, node);
00181         return (slot);
00182 }

00061 { return debug_; }

00049 { return maxslot_; }

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

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

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

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
	ReservePortClassifier ()
int	maxslot () const
NsObject *	slot (int slot)
int	mshift (int val)
void	set_default_target (NsObject *obj)
virtual void	recv (Packet p, Handler h)
virtual void	recv (Packet p, const char s)
virtual NsObject *	find (Packet *)
virtual void	do_install (char dst, NsObject target)
int	install_next (NsObject *node)
virtual void	install (int slot, NsObject *)
void	set_table_size (int nn)
virtual void	set_table_size (int level, int nn)
virtual void	recvOnly (Packet *)
virtual void	delay_bind_init_all ()
virtual int	delay_bind_dispatch (const char varName, const char localName, TclObject *tracer)
int	isdebug () const
virtual void	debug (const char *fmt,...)
Protected Member Functions
void	clear (int slot)
int	getnxt (NsObject *)
int	command (int argc, const char const argv)
int	classify (Packet *p)
void	alloc (int)
virtual void	reset ()
void	handle (Event *)
Protected Attributes
int	reserved_
NsObject **	slot_
int	nslot_
int	maxslot_
int	offset_
int	shift_
int	mask_
NsObject *	default_target_
int	nsize_
int	debug_

ReservePortClassifier Class Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation