NS2.26SourcesOriginal: SatMac class Reference

00323                : Mac(), send_timer_(this), recv_timer_(this)
00324 {
00325         bind_bool("trace_collisions_", &trace_collisions_);
00326         bind_bool("trace_drops_", &trace_drops_);
00327 }

00190 { return index_; }

00188 { return bandwidth_; }

00330 {
00331         Tcl& tcl = Tcl::instance();
00332         if(argc == 2) {
00333         }
00334         else if (argc == 3) {
00335                 TclObject *obj;
00336                 if( (obj = TclObject::lookup(argv[2])) == 0) {
00337                         fprintf(stderr, "%s lookup failed\n", argv[1]);
00338                         return TCL_ERROR;                
00339                 }
00340                 if (strcmp(argv[1], "channel") == 0) {
00341                         //channel_ = (Channel*) obj;
00342                         return (TCL_OK);
00343                 }
00344                 if (strcmp(argv[1], "set_drop_trace") == 0) {
00345                         drop_trace_ = (SatTrace *) TclObject::lookup(argv[2]);
00346                         if (drop_trace_ == 0) {
00347                                 tcl.resultf("no such object %s", argv[2]);
00348                                 return (TCL_ERROR);
00349                         }
00350                         return (TCL_OK);
00351                 }
00352                 if (strcmp(argv[1], "set_coll_trace") == 0) {
00353                         coll_trace_ = (SatTrace *) TclObject::lookup(argv[2]);
00354                         if (coll_trace_ == 0) {
00355                                 tcl.resultf("no such object %s", argv[2]);
00356                                 return (TCL_ERROR);
00357                         }
00358                         return (TCL_OK);
00359                 }
00360         }
00361         return Mac::command(argc, argv);
00362 }

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 }

00049 { return downtarget_; }

00145 {
00146         if (drop_ != 0)
00147                 drop_->recv(p, s);
00148         else
00149                 Packet::free(p);
00150 }

00136 {
00137         if (drop_ != 0)
00138                 drop_->recv(p);
00139         else
00140                 Packet::free(p);
00141 }

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

00196                                                             {
00197                 struct hdr_mac *dh = (struct hdr_mac*) hdr;
00198                 if(dst > -2)
00199                         dh->macDA_ = dst;
00200                 return dh->macDA();
00201         }

00202                                                             {
00203                 struct hdr_mac *dh = (struct hdr_mac*) hdr;
00204                 if(src > -2)
00205                         dh->macSA_ = src;
00206                 return dh->macSA();
00207         }

00208                                                                    {
00209                 struct hdr_mac *dh = (struct hdr_mac*) hdr;
00210                 if (type)
00211                         dh->hdr_type_ = type;
00212                 return dh->hdr_type();
00213         }

00223                                   { 
00224                 return (netif_ && uptarget_ && downtarget_); 
00225         }

00061 { return debug_; }

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

00132 {
00133         if (hdr_cmn::access(p)->direction() == hdr_cmn::UP) {
00134                 sendUp(p);
00135                 return;
00136         }
00137 
00138         callback_ = h;
00139         hdr_mac* mh = HDR_MAC(p);
00140         mh->set(MF_DATA, index_);
00141         state(MAC_SEND);
00142         sendDown(p);
00143 }

00174 {
00175         if (p != 0)
00176                 drop(p);
00177         state(MAC_IDLE);
00178         callback_->handle(&intr_);
00179 }

00056                 { downtarget_->recv(p, h); }

00381 {
00382         Scheduler& s = Scheduler::instance();
00383         double txt;
00384         // LINK_HDRSIZE is defined in satlink.h.  This is the size of header
00385         // information for all layers below IP.  Alternatively, one could
00386         // derive this information dynamically from packet headers. 
00387         int packetsize_ = HDR_CMN(p)->size() + LINK_HDRSIZE;
00388         if (bandwidth_ != 0)
00389                 txt = txtime(packetsize_);
00390         // For convenience, we encode the transmit time in the Mac header
00391         // The packet will be held (for collision detection) for txtime 
00392         // at the receiving mac.
00393         HDR_MAC(p)->txtime() = txt;
00394         downtarget_->recv(p, this);
00395         // Callback for when this packet's transmission will be done
00396         s.schedule(&hRes_, &intr_, txt);
00397 }

00058                 { uptarget_->recv(p, h); }

00365 {
00366         hdr_mac* mh = HDR_MAC(p);
00367         int dst = this->hdr_dst((char*)mh); // mac destination address
00368         
00369         if (((u_int32_t)dst != MAC_BROADCAST) && (dst != index_)) {
00370                 drop(p);
00371                 return;
00372         }
00373         // First bit of packet has arrived-- wait for 
00374         // (txtime + delay_) before sending up
00375         Scheduler::instance().schedule(uptarget_, p, delay_ + mh->txtime());
00376 }

00192 { return state_ = (MacState) m; }

00191 { return state_; }

00184                                         {
00185                 return 8. * (MAC_HDR_LEN + \
00186                              (HDR_CMN(p))->size()) / bandwidth_;
00187         }

00181                                         {
00182                 return (8. * bytes / bandwidth_);
00183         }

00048 { return uptarget_; }


Public Member Functions
	SatMac ()
void	sendDown (Packet *p)
void	sendUp (Packet *p)
virtual void	send_timer ()
virtual void	recv_timer ()
virtual void	recv (Packet p, Handler h)
virtual void	recv (Packet p, const char s)
virtual void	resume (Packet *p=0)
virtual void	installTap (Tap *t)
double	txtime (int bytes)
double	txtime (Packet *p)
double	bandwidth () const
int	addr ()
MacState	state ()
MacState	state (int m)
virtual int	hdr_dst (char *hdr, int dst=-2)
virtual int	hdr_src (char *hdr, int src=-2)
virtual int	hdr_type (char *hdr, u_int16_t type=0)
NsObject *	uptarget ()
NsObject *	downtarget ()
virtual void	drop (Packet *p)
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
int	command (int argc, const char const argv)
virtual void	sendDown (Packet p, Handler h)
virtual void	sendUp (Packet p, Handler h)
virtual int	initialized ()
virtual void	drop (Packet p, const char s)
virtual void	reset ()
void	handle (Event *)
Protected Attributes
MacSendTimer	send_timer_
MacRecvTimer	recv_timer_
SatTrace *	drop_trace_
int	trace_drops_
SatTrace *	coll_trace_
int	trace_collisions_
int	index_
double	bandwidth_
double	delay_
int	abstract_
Phy *	netif_
Tap *	tap_
LL *	ll_
Channel *	channel_
Handler *	callback_
MacHandlerResume	hRes_
MacHandlerSend	hSend_
Event	intr_
MacState	state_
Packet *	pktRx_
Packet *	pktTx_
NsObject *	uptarget_
NsObject *	downtarget_
NsObject *	drop_
int	debug_

SatMac Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation