NS2.26SourcesOriginal: BcastAddressClassifier class Reference

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

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 }

00042                                          {
00043         hdr_ip* iph = hdr_ip::access(p);
00044         return mshift(iph->daddr());
00045 };

00112 {
00113         slot_[slot] = 0;
00114         if (slot == maxslot_) {
00115                 while (--maxslot_ >= 0 && slot_[maxslot_] == 0)
00116                         ;
00117         }
00118 }

00140 {
00141         // Tcl& tcl = Tcl::instance();
00142 
00143         if (argc == 3 && strcmp(argv[1],"bcast-receiver") == 0) {
00144                 bcast_recver_ = (NsObject*)TclObject::lookup(argv[2]);
00145                 return(TCL_OK);
00146         }
00147         return (AddressClassifier::command(argc, argv));
00148 }

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

00111 {
00112         NsObject* node = NULL;
00113         int cl = classify(p);
00114         if (cl < 0 || cl >= nslot_ || (node = slot_[cl]) == 0) {
00115                 if (cl == BCAST_ADDR_MASK) {
00116                         // limited broadcast; assuming no such packet
00117                         // would be delivered back to sender
00118                         return bcast_recver_;
00119                 }
00120                 if (default_target_) 
00121                         return default_target_;
00122  
00123                 /*
00124                  * Sigh.  Can't pass the pkt out to tcl because it's
00125                  * not an object.
00126                  */
00127                 Tcl::instance().evalf("%s no-slot %d", name(), cl);
00128                 /*
00129                  * Try again.  Maybe callback patched up the table.
00130                  */
00131                 cl = classify(p);
00132                 if (cl < 0 || cl >= nslot_ || (node = slot_[cl]) == 0)
00133                         return (NULL);
00134         }
00135  
00136         return (node);
00137 }

00121 {
00122         int i;
00123         for (i=0; i < nslot_; i++)
00124                 if (slot_[i]==0 || slot_[i]==nullagent)
00125                         return i;
00126         i=nslot_;
00127         alloc(nslot_);
00128         return i;
00129 }

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
	BcastAddressClassifier ()
NsObject *	find (Packet *)
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 void	clear (int slot)
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
virtual int	command (int argc, const char const argv)
virtual int	classify (Packet *p)
virtual int	getnxt (NsObject *)
void	alloc (int)
virtual void	reset ()
void	handle (Event *)
Protected Attributes
NsObject *	bcast_recver_
NsObject **	slot_
int	nslot_
int	maxslot_
int	offset_
int	shift_
int	mask_
NsObject *	default_target_
int	nsize_
int	debug_

BcastAddressClassifier Class Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation