00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "ns3/log.h"
00022 #include "ns3/queue.h"
00023 #include "ns3/simulator.h"
00024 #include "ns3/ethernet-header.h"
00025 #include "ns3/ethernet-trailer.h"
00026 #include "ns3/llc-snap-header.h"
00027 #include "ns3/error-model.h"
00028 #include "ns3/enum.h"
00029 #include "ns3/boolean.h"
00030 #include "ns3/uinteger.h"
00031 #include "ns3/pointer.h"
00032 #include "ns3/trace-source-accessor.h"
00033 #include "csma-net-device.h"
00034 #include "csma-channel.h"
00035
00036 NS_LOG_COMPONENT_DEFINE ("CsmaNetDevice");
00037
00038 namespace ns3 {
00039
00040 NS_OBJECT_ENSURE_REGISTERED (CsmaNetDevice);
00041
00042 TypeId
00043 CsmaNetDevice::GetTypeId (void)
00044 {
00045 static TypeId tid = TypeId ("ns3::CsmaNetDevice")
00046 .SetParent<NetDevice> ()
00047 .AddConstructor<CsmaNetDevice> ()
00048 .AddAttribute ("Address",
00049 "The MAC address of this device.",
00050 Mac48AddressValue (Mac48Address ("ff:ff:ff:ff:ff:ff")),
00051 MakeMac48AddressAccessor (&CsmaNetDevice::m_address),
00052 MakeMac48AddressChecker ())
00053 .AddAttribute ("FrameSize",
00054 "The maximum size of a packet sent over this device.",
00055 UintegerValue (DEFAULT_FRAME_SIZE),
00056 MakeUintegerAccessor (&CsmaNetDevice::SetFrameSize,
00057 &CsmaNetDevice::GetFrameSize),
00058 MakeUintegerChecker<uint16_t> ())
00059 .AddAttribute ("EncapsulationMode",
00060 "The link-layer encapsulation type to use.",
00061 EnumValue (DIX),
00062 MakeEnumAccessor (&CsmaNetDevice::SetEncapsulationMode),
00063 MakeEnumChecker (DIX, "Dix",
00064 LLC, "Llc"))
00065 .AddAttribute ("SendEnable",
00066 "Enable or disable the transmitter section of the device.",
00067 BooleanValue (true),
00068 MakeBooleanAccessor (&CsmaNetDevice::m_sendEnable),
00069 MakeBooleanChecker ())
00070 .AddAttribute ("ReceiveEnable",
00071 "Enable or disable the receiver section of the device.",
00072 BooleanValue (true),
00073 MakeBooleanAccessor (&CsmaNetDevice::m_receiveEnable),
00074 MakeBooleanChecker ())
00075 .AddAttribute ("ReceiveErrorModel",
00076 "The receiver error model used to simulate packet loss",
00077 PointerValue (),
00078 MakePointerAccessor (&CsmaNetDevice::m_receiveErrorModel),
00079 MakePointerChecker<ErrorModel> ())
00080 .AddAttribute ("TxQueue",
00081 "A queue to use as the transmit queue in the device.",
00082 PointerValue (),
00083 MakePointerAccessor (&CsmaNetDevice::m_queue),
00084 MakePointerChecker<Queue> ())
00085 .AddTraceSource ("Rx",
00086 "Trace source indicating reception of packet destined for broadcast, multicast or local address.",
00087 MakeTraceSourceAccessor (&CsmaNetDevice::m_rxTrace))
00088 .AddTraceSource ("Drop",
00089 "Trace source indicating packet discarded due to receiver disabled or error model decision.",
00090 MakeTraceSourceAccessor (&CsmaNetDevice::m_dropTrace))
00091 ;
00092 return tid;
00093 }
00094
00095 CsmaNetDevice::CsmaNetDevice ()
00096 : m_name (""),
00097 m_linkUp (false)
00098 {
00099 NS_LOG_FUNCTION (this);
00100 m_txMachineState = READY;
00101 m_tInterframeGap = Seconds (0);
00102 m_channel = 0;
00103
00104
00105
00106
00107
00108
00109
00110
00111 m_encapMode = DIX;
00112 m_frameSize = DEFAULT_FRAME_SIZE;
00113 m_mtu = MtuFromFrameSize (m_frameSize);
00114 }
00115
00116 CsmaNetDevice::~CsmaNetDevice()
00117 {
00118 NS_LOG_FUNCTION_NOARGS ();
00119 m_queue = 0;
00120 }
00121
00122 void
00123 CsmaNetDevice::DoDispose ()
00124 {
00125 NS_LOG_FUNCTION_NOARGS ();
00126 m_channel = 0;
00127 m_node = 0;
00128 NetDevice::DoDispose ();
00129 }
00130
00131 uint32_t
00132 CsmaNetDevice::MtuFromFrameSize (uint32_t frameSize)
00133 {
00134 NS_LOG_FUNCTION (frameSize);
00135
00136 NS_ASSERT_MSG (frameSize <= std::numeric_limits<uint16_t>::max (),
00137 "CsmaNetDevice::MtuFromFrameSize(): Frame size should be derived from 16-bit quantity: " << frameSize);
00138
00139 uint32_t newSize;
00140
00141 switch (m_encapMode)
00142 {
00143 case DIX:
00144 newSize = frameSize - ETHERNET_OVERHEAD;
00145 break;
00146 case LLC:
00147 {
00148 LlcSnapHeader llc;
00149
00150 NS_ASSERT_MSG ((uint32_t)(frameSize - ETHERNET_OVERHEAD) >= llc.GetSerializedSize (),
00151 "CsmaNetDevice::MtuFromFrameSize(): Given frame size too small to support LLC mode");
00152 newSize = frameSize - ETHERNET_OVERHEAD - llc.GetSerializedSize ();
00153 }
00154 break;
00155 case ILLEGAL:
00156 default:
00157 NS_FATAL_ERROR ("CsmaNetDevice::MtuFromFrameSize(): Unknown packet encapsulation mode");
00158 return 0;
00159 }
00160
00161 return newSize;
00162 }
00163
00164 uint32_t
00165 CsmaNetDevice::FrameSizeFromMtu (uint32_t mtu)
00166 {
00167 NS_LOG_FUNCTION (mtu);
00168
00169 uint32_t newSize;
00170
00171 switch (m_encapMode)
00172 {
00173 case DIX:
00174 newSize = mtu + ETHERNET_OVERHEAD;
00175 break;
00176 case LLC:
00177 {
00178 LlcSnapHeader llc;
00179 newSize = mtu + ETHERNET_OVERHEAD + llc.GetSerializedSize ();
00180 }
00181 break;
00182 case ILLEGAL:
00183 default:
00184 NS_FATAL_ERROR ("CsmaNetDevice::FrameSizeFromMtu(): Unknown packet encapsulation mode");
00185 return 0;
00186 }
00187
00188 return newSize;
00189 }
00190
00191 void
00192 CsmaNetDevice::SetEncapsulationMode (enum EncapsulationMode mode)
00193 {
00194 NS_LOG_FUNCTION (mode);
00195
00196 m_encapMode = mode;
00197 m_mtu = MtuFromFrameSize (m_frameSize);
00198
00199 NS_LOG_LOGIC ("m_encapMode = " << m_encapMode);
00200 NS_LOG_LOGIC ("m_frameSize = " << m_frameSize);
00201 NS_LOG_LOGIC ("m_mtu = " << m_mtu);
00202 }
00203
00204 CsmaNetDevice::EncapsulationMode
00205 CsmaNetDevice::GetEncapsulationMode (void)
00206 {
00207 NS_LOG_FUNCTION_NOARGS ();
00208 return m_encapMode;
00209 }
00210
00211 bool
00212 CsmaNetDevice::SetMtu (uint16_t mtu)
00213 {
00214 NS_LOG_FUNCTION (mtu);
00215
00216 uint32_t newFrameSize = FrameSizeFromMtu (mtu);
00217
00218 if (newFrameSize > std::numeric_limits<uint16_t>::max ())
00219 {
00220 NS_LOG_WARN ("CsmaNetDevice::SetMtu(): Frame size overflow, MTU not set.");
00221 return false;
00222 }
00223
00224 m_frameSize = newFrameSize;
00225 m_mtu = mtu;
00226
00227 NS_LOG_LOGIC ("m_encapMode = " << m_encapMode);
00228 NS_LOG_LOGIC ("m_frameSize = " << m_frameSize);
00229 NS_LOG_LOGIC ("m_mtu = " << m_mtu);
00230
00231 return true;
00232 }
00233
00234 uint16_t
00235 CsmaNetDevice::GetMtu (void) const
00236 {
00237 NS_LOG_FUNCTION_NOARGS ();
00238 return m_mtu;
00239 }
00240
00241 void
00242 CsmaNetDevice::SetFrameSize (uint16_t frameSize)
00243 {
00244 NS_LOG_FUNCTION (frameSize);
00245
00246 m_frameSize = frameSize;
00247 m_mtu = MtuFromFrameSize (frameSize);
00248
00249 NS_LOG_LOGIC ("m_encapMode = " << m_encapMode);
00250 NS_LOG_LOGIC ("m_frameSize = " << m_frameSize);
00251 NS_LOG_LOGIC ("m_mtu = " << m_mtu);
00252 }
00253
00254 uint16_t
00255 CsmaNetDevice::GetFrameSize (void) const
00256 {
00257 return m_frameSize;
00258 }
00259
00260 void
00261 CsmaNetDevice::SetAddress (Mac48Address self)
00262 {
00263 NS_LOG_FUNCTION (self);
00264 m_address = self;
00265 }
00266
00267 void
00268 CsmaNetDevice::SetSendEnable (bool sendEnable)
00269 {
00270 NS_LOG_FUNCTION (sendEnable);
00271 m_sendEnable = sendEnable;
00272 }
00273
00274 void
00275 CsmaNetDevice::SetReceiveEnable (bool receiveEnable)
00276 {
00277 NS_LOG_FUNCTION (receiveEnable);
00278 m_receiveEnable = receiveEnable;
00279 }
00280
00281 bool
00282 CsmaNetDevice::IsSendEnabled (void)
00283 {
00284 NS_LOG_FUNCTION_NOARGS ();
00285 return m_sendEnable;
00286 }
00287
00288 bool
00289 CsmaNetDevice::IsReceiveEnabled (void)
00290 {
00291 NS_LOG_FUNCTION_NOARGS ();
00292 return m_receiveEnable;
00293 }
00294
00295 void
00296 CsmaNetDevice::SetInterframeGap (Time t)
00297 {
00298 NS_LOG_FUNCTION (t);
00299 m_tInterframeGap = t;
00300 }
00301
00302 void
00303 CsmaNetDevice::SetBackoffParams (Time slotTime, uint32_t minSlots, uint32_t maxSlots, uint32_t ceiling, uint32_t maxRetries)
00304 {
00305 NS_LOG_FUNCTION (slotTime << minSlots << maxSlots << ceiling << maxRetries);
00306 m_backoff.m_slotTime = slotTime;
00307 m_backoff.m_minSlots = minSlots;
00308 m_backoff.m_maxSlots = maxSlots;
00309 m_backoff.m_ceiling = ceiling;
00310 m_backoff.m_maxRetries = maxRetries;
00311 }
00312
00313 void
00314 CsmaNetDevice::AddHeader (Ptr<Packet> p, Mac48Address source, Mac48Address dest, uint16_t protocolNumber)
00315 {
00316 NS_LOG_FUNCTION (p << source << dest << protocolNumber);
00317
00318 EthernetHeader header (false);
00319 header.SetSource (source);
00320 header.SetDestination (dest);
00321
00322 EthernetTrailer trailer;
00323
00324 NS_LOG_LOGIC ("p->GetSize () = " << p->GetSize ());
00325 NS_LOG_LOGIC ("m_encapMode = " << m_encapMode);
00326 NS_LOG_LOGIC ("m_mtu = " << m_mtu);
00327 NS_LOG_LOGIC ("m_frameSize = " << m_frameSize);
00328
00329 uint16_t lengthType = 0;
00330 switch (m_encapMode)
00331 {
00332 case DIX:
00333 NS_LOG_LOGIC ("Encapsulating packet as DIX (type interpretation)");
00334
00335
00336
00337 lengthType = protocolNumber;
00338 break;
00339 case LLC:
00340 {
00341 NS_LOG_LOGIC ("Encapsulating packet as LLC (length interpretation)");
00342
00343 LlcSnapHeader llc;
00344 llc.SetType (protocolNumber);
00345 p->AddHeader (llc);
00346
00347
00348
00349
00350 lengthType = p->GetSize ();
00351 NS_ASSERT_MSG (lengthType <= m_frameSize - 18,
00352 "CsmaNetDevice::AddHeader(): 802.3 Length/Type field with LLC/SNAP: "
00353 "length interpretation must not exceed device frame size minus overhead");
00354 }
00355 break;
00356 case ILLEGAL:
00357 default:
00358 NS_FATAL_ERROR ("CsmaNetDevice::AddHeader(): Unknown packet encapsulation mode");
00359 break;
00360 }
00361
00362 NS_LOG_LOGIC ("header.SetLengthType (" << lengthType << ")");
00363 header.SetLengthType (lengthType);
00364 p->AddHeader (header);
00365
00366 trailer.CalcFcs (p);
00367 p->AddTrailer (trailer);
00368 }
00369
00370 bool
00371 CsmaNetDevice::ProcessHeader (Ptr<Packet> p, uint16_t & param)
00372 {
00373 NS_LOG_FUNCTION (p << param);
00374
00375 EthernetTrailer trailer;
00376
00377 p->RemoveTrailer (trailer);
00378 trailer.CheckFcs (p);
00379
00380 EthernetHeader header (false);
00381 p->RemoveHeader (header);
00382
00383 if ((header.GetDestination () != GetBroadcast ()) &&
00384 (header.GetDestination () != GetAddress ()))
00385 {
00386 return false;
00387 }
00388
00389 switch (m_encapMode)
00390 {
00391 case DIX:
00392 param = header.GetLengthType ();
00393 break;
00394 case LLC:
00395 {
00396 LlcSnapHeader llc;
00397 p->RemoveHeader (llc);
00398 param = llc.GetType ();
00399 }
00400 break;
00401 case ILLEGAL:
00402 default:
00403 NS_FATAL_ERROR ("CsmaNetDevice::ProcessHeader(): Unknown packet encapsulation mode");
00404 break;
00405 }
00406 return true;
00407 }
00408
00409 void
00410 CsmaNetDevice::TransmitStart ()
00411 {
00412 NS_LOG_FUNCTION_NOARGS ();
00413
00414 NS_LOG_LOGIC ("m_currentPkt=" << m_currentPkt);
00415 NS_LOG_LOGIC ("UID is " << m_currentPkt->GetUid ());
00416
00417
00418
00419
00420
00421
00422 NS_ASSERT_MSG ((m_txMachineState == READY) || (m_txMachineState == BACKOFF),
00423 "Must be READY to transmit. Tx state is: " << m_txMachineState);
00424
00425
00426
00427
00428 if (IsSendEnabled () == false)
00429 {
00430 return;
00431 }
00432
00433 if (m_channel->GetState () != IDLE)
00434 {
00435
00436
00437
00438 m_txMachineState = BACKOFF;
00439
00440 if (m_backoff.MaxRetriesReached ())
00441 {
00442
00443
00444
00445 TransmitAbort ();
00446 }
00447 else
00448 {
00449 m_backoff.IncrNumRetries ();
00450 Time backoffTime = m_backoff.GetBackoffTime ();
00451
00452 NS_LOG_LOGIC ("Channel busy, backing off for " << backoffTime.GetSeconds () << " sec");
00453
00454 Simulator::Schedule (backoffTime, &CsmaNetDevice::TransmitStart, this);
00455 }
00456 }
00457 else
00458 {
00459
00460
00461
00462 m_txMachineState = BUSY;
00463 Time tEvent = Seconds (m_bps.CalculateTxTime (m_currentPkt->GetSize ()));
00464
00465 NS_LOG_LOGIC ("Schedule TransmitCompleteEvent in " << tEvent.GetSeconds () << "sec");
00466
00467 Simulator::Schedule (tEvent, &CsmaNetDevice::TransmitCompleteEvent, this);
00468
00469 if (m_channel->TransmitStart (m_currentPkt, m_deviceId) == false)
00470 {
00471 NS_LOG_WARN ("Channel transmit start did not work at " << tEvent.GetSeconds () << "sec");
00472 m_txMachineState = READY;
00473 }
00474 else
00475 {
00476
00477
00478
00479 m_backoff.ResetBackoffTime ();
00480 }
00481 }
00482 }
00483
00484
00485 void
00486 CsmaNetDevice::TransmitAbort (void)
00487 {
00488 NS_LOG_FUNCTION_NOARGS ();
00489
00490 NS_LOG_LOGIC ("Pkt UID is " << m_currentPkt->GetUid () << ")");
00491
00492
00493
00494
00495 m_currentPkt = m_queue->Dequeue ();
00496 NS_ASSERT_MSG (m_currentPkt != 0, "No Packet on queue during CsmaNetDevice::TransmitAbort()");
00497
00498
00499
00500
00501 m_backoff.ResetBackoffTime ();
00502 m_txMachineState = READY;
00503 TransmitStart ();
00504 }
00505
00506 void
00507 CsmaNetDevice::TransmitCompleteEvent (void)
00508 {
00509 NS_LOG_FUNCTION_NOARGS ();
00510
00511
00512
00513
00514
00515
00516
00517 NS_ASSERT_MSG (m_txMachineState == BUSY, "Must be BUSY if transmitting");
00518 NS_ASSERT (m_channel->GetState () == TRANSMITTING);
00519 m_txMachineState = GAP;
00520
00521 NS_LOG_LOGIC ("Pkt UID is " << m_currentPkt->GetUid () << ")");
00522 m_channel->TransmitEnd ();
00523
00524 NS_LOG_LOGIC ("Schedule TransmitReadyEvent in " << m_tInterframeGap.GetSeconds () << "sec");
00525
00526 Simulator::Schedule (m_tInterframeGap, &CsmaNetDevice::TransmitReadyEvent, this);
00527 }
00528
00529 void
00530 CsmaNetDevice::TransmitReadyEvent (void)
00531 {
00532 NS_LOG_FUNCTION_NOARGS ();
00533
00534
00535
00536
00537
00538
00539 NS_ASSERT_MSG (m_txMachineState == GAP, "Must be in interframe gap");
00540 m_txMachineState = READY;
00541
00542
00543
00544
00545 if (m_queue->IsEmpty ())
00546 {
00547 return;
00548 }
00549 else
00550 {
00551 m_currentPkt = m_queue->Dequeue ();
00552 NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::TransmitReadyEvent(): IsEmpty false but no Packet on queue?");
00553 TransmitStart ();
00554 }
00555 }
00556
00557 bool
00558 CsmaNetDevice::Attach (Ptr<CsmaChannel> ch)
00559 {
00560 NS_LOG_FUNCTION (this << &ch);
00561
00562 m_channel = ch;
00563
00564 m_deviceId = m_channel->Attach (this);
00565
00566
00567
00568
00569 m_bps = m_channel->GetDataRate ();
00570
00571
00572
00573
00574 m_tInterframeGap = Seconds (m_bps.CalculateTxTime (96/8));
00575
00576
00577
00578
00579 NotifyLinkUp ();
00580 return true;
00581 }
00582
00583 void
00584 CsmaNetDevice::SetQueue (Ptr<Queue> q)
00585 {
00586 NS_LOG_FUNCTION (q);
00587 m_queue = q;
00588 }
00589
00590 void
00591 CsmaNetDevice::SetReceiveErrorModel (Ptr<ErrorModel> em)
00592 {
00593 NS_LOG_FUNCTION (em);
00594 m_receiveErrorModel = em;
00595 }
00596
00597 void
00598 CsmaNetDevice::Receive (Ptr<Packet> packet, Ptr<CsmaNetDevice> senderDevice)
00599 {
00600 NS_LOG_FUNCTION (packet << senderDevice);
00601 NS_LOG_LOGIC ("UID is " << packet->GetUid ());
00602
00603
00604 uint8_t mac[6];
00605 Mac48Address multicast6AllNodes("33:33:00:00:00:01");
00606 Mac48Address multicast6AllRouters("33:33:00:00:00:02");
00607 Mac48Address multicast6AllHosts("33:33:00:00:00:03");
00608 Mac48Address multicast6Node;
00609
00610
00611 GetAddress().CopyTo(mac);
00612 mac[0]=0x33;
00613 mac[1]=0x33;
00614
00615 multicast6Node.CopyFrom(mac);
00616
00617
00618
00619
00620
00621
00622 if (senderDevice == this)
00623 {
00624 return;
00625 }
00626
00627
00628
00629
00630 if (IsReceiveEnabled () == false)
00631 {
00632 m_dropTrace (packet);
00633 return;
00634 }
00635
00636
00637
00638
00639
00640 Ptr<Packet> originalPacket = packet->Copy ();
00641
00642 EthernetTrailer trailer;
00643 packet->RemoveTrailer (trailer);
00644 trailer.CheckFcs (packet);
00645
00646 EthernetHeader header (false);
00647 packet->RemoveHeader (header);
00648
00649 NS_LOG_LOGIC ("Pkt source is " << header.GetSource ());
00650 NS_LOG_LOGIC ("Pkt destination is " << header.GetDestination ());
00651
00652 if (m_receiveErrorModel && m_receiveErrorModel->IsCorrupt (packet) )
00653 {
00654 NS_LOG_LOGIC ("Dropping pkt due to error model ");
00655 m_dropTrace (packet);
00656 }
00657 else
00658 {
00659
00660
00661
00662 uint16_t protocol = 0;
00663
00664 switch (m_encapMode)
00665 {
00666 case DIX:
00667 protocol = header.GetLengthType ();
00668 break;
00669 case LLC:
00670 {
00671 LlcSnapHeader llc;
00672 packet->RemoveHeader (llc);
00673 protocol = llc.GetType ();
00674 }
00675 break;
00676 case ILLEGAL:
00677 default:
00678 NS_FATAL_ERROR ("CsmaNetDevice::Receive(): Unknown packet encapsulation mode");
00679 break;
00680 }
00681
00682 PacketType packetType;
00683
00684 if (header.GetDestination ().IsBroadcast ())
00685 {
00686 packetType = PACKET_BROADCAST;
00687 m_rxTrace (originalPacket);
00688 }
00689 else if (header.GetDestination ().IsMulticast () ||
00690 header.GetDestination() == multicast6Node ||
00691 header.GetDestination() == multicast6AllNodes ||
00692 header.GetDestination() == multicast6AllRouters ||
00693 header.GetDestination() == multicast6AllHosts)
00694 {
00695 packetType = PACKET_MULTICAST;
00696 m_rxTrace (originalPacket);
00697 }
00698 else if (header.GetDestination () == m_address)
00699 {
00700 packetType = PACKET_HOST;
00701 m_rxTrace (originalPacket);
00702 }
00703 else
00704 {
00705 packetType = PACKET_OTHERHOST;
00706 }
00707
00708 if (!m_promiscRxCallback.IsNull ())
00709 {
00710 m_promiscRxCallback (this, packet, protocol, header.GetSource (), header.GetDestination (), packetType);
00711 }
00712
00713 if (packetType != PACKET_OTHERHOST)
00714 {
00715 m_rxCallback (this, packet, protocol, header.GetSource ());
00716 }
00717 }
00718 }
00719
00720 Ptr<Queue>
00721 CsmaNetDevice::GetQueue (void) const
00722 {
00723 NS_LOG_FUNCTION_NOARGS ();
00724 return m_queue;
00725 }
00726
00727 void
00728 CsmaNetDevice::NotifyLinkUp (void)
00729 {
00730 NS_LOG_FUNCTION_NOARGS ();
00731
00732 m_linkUp = true;
00733 if (m_linkChangeCallback.IsNull () == false)
00734 {
00735 m_linkChangeCallback ();
00736 }
00737 }
00738
00739 void
00740 CsmaNetDevice::SetName (const std::string name)
00741 {
00742 NS_LOG_FUNCTION (name);
00743 m_name = name;
00744 }
00745
00746 std::string
00747 CsmaNetDevice::GetName (void) const
00748 {
00749 NS_LOG_FUNCTION_NOARGS ();
00750 return m_name;
00751 }
00752
00753 void
00754 CsmaNetDevice::SetIfIndex (const uint32_t index)
00755 {
00756 NS_LOG_FUNCTION (index);
00757 m_ifIndex = index;
00758 }
00759
00760 uint32_t
00761 CsmaNetDevice::GetIfIndex (void) const
00762 {
00763 NS_LOG_FUNCTION_NOARGS ();
00764 return m_ifIndex;
00765 }
00766
00767 Ptr<Channel>
00768 CsmaNetDevice::GetChannel (void) const
00769 {
00770 NS_LOG_FUNCTION_NOARGS ();
00771 return m_channel;
00772 }
00773
00774 Address
00775 CsmaNetDevice::GetAddress (void) const
00776 {
00777 NS_LOG_FUNCTION_NOARGS ();
00778 return m_address;
00779 }
00780
00781 bool
00782 CsmaNetDevice::IsLinkUp (void) const
00783 {
00784 NS_LOG_FUNCTION_NOARGS ();
00785 return m_linkUp;
00786 }
00787
00788 void
00789 CsmaNetDevice::SetLinkChangeCallback (Callback<void> callback)
00790 {
00791 NS_LOG_FUNCTION (&callback);
00792 m_linkChangeCallback = callback;
00793 }
00794
00795 bool
00796 CsmaNetDevice::IsBroadcast (void) const
00797 {
00798 NS_LOG_FUNCTION_NOARGS ();
00799 return true;
00800 }
00801
00802 Address
00803 CsmaNetDevice::GetBroadcast (void) const
00804 {
00805 NS_LOG_FUNCTION_NOARGS ();
00806 return Mac48Address ("ff:ff:ff:ff:ff:ff");
00807 }
00808
00809 bool
00810 CsmaNetDevice::IsMulticast (void) const
00811 {
00812 NS_LOG_FUNCTION_NOARGS ();
00813 return true;
00814 }
00815
00816 Address
00817 CsmaNetDevice::GetMulticast (Ipv4Address multicastGroup) const
00818 {
00819 NS_LOG_FUNCTION (multicastGroup);
00820
00821 Mac48Address ad = Mac48Address::GetMulticast (multicastGroup);
00822
00823
00824
00825
00826
00827
00828 NS_LOG_LOGIC ("multicast address is " << ad);
00829
00830 return ad;
00831 }
00832
00833 bool
00834 CsmaNetDevice::IsPointToPoint (void) const
00835 {
00836 NS_LOG_FUNCTION_NOARGS ();
00837 return false;
00838 }
00839
00840 bool
00841 CsmaNetDevice::IsBridge (void) const
00842 {
00843 NS_LOG_FUNCTION_NOARGS ();
00844 return false;
00845 }
00846
00847 bool
00848 CsmaNetDevice::Send (Ptr<Packet> packet,const Address& dest, uint16_t protocolNumber)
00849 {
00850 NS_LOG_FUNCTION (packet << dest << protocolNumber);
00851 return SendFrom (packet, m_address, dest, protocolNumber);
00852 }
00853
00854 bool
00855 CsmaNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)
00856 {
00857 NS_LOG_FUNCTION (packet << src << dest << protocolNumber);
00858 NS_LOG_LOGIC ("p=" << packet);
00859 NS_LOG_LOGIC ("UID is " << packet->GetUid () << ")");
00860
00861 NS_ASSERT (IsLinkUp ());
00862
00863
00864
00865
00866 if (IsSendEnabled () == false)
00867 {
00868 return false;
00869 }
00870
00871 Mac48Address destination = Mac48Address::ConvertFrom (dest);
00872 Mac48Address source = Mac48Address::ConvertFrom (src);
00873 AddHeader (packet, source, destination, protocolNumber);
00874
00875
00876
00877
00878 if (m_queue->Enqueue(packet) == false)
00879 {
00880 return false;
00881 }
00882
00883
00884
00885
00886
00887
00888 if (m_txMachineState == READY)
00889 {
00890
00891
00892
00893 m_currentPkt = m_queue->Dequeue ();
00894 if (m_currentPkt != 0)
00895 {
00896 TransmitStart ();
00897 }
00898 }
00899 return true;
00900 }
00901
00902 Ptr<Node>
00903 CsmaNetDevice::GetNode (void) const
00904 {
00905 NS_LOG_FUNCTION_NOARGS ();
00906 return m_node;
00907 }
00908
00909 void
00910 CsmaNetDevice::SetNode (Ptr<Node> node)
00911 {
00912 NS_LOG_FUNCTION (node);
00913
00914 m_node = node;
00915 int count = -1;
00916 if (m_name.size () == 0)
00917 {
00918 for (uint32_t i = 0; i < node->GetNDevices (); i++)
00919 {
00920 Ptr<NetDevice> dev = node->GetDevice (i);
00921 if (dynamic_cast<CsmaNetDevice*> (PeekPointer (dev)))
00922 {
00923 count++;
00924 if (dev == this)
00925 {
00926 break;
00927 }
00928 }
00929 }
00930 std::ostringstream s;
00931 s << "eth" << count;
00932 m_name = s.str ();
00933 }
00934 }
00935
00936 bool
00937 CsmaNetDevice::NeedsArp (void) const
00938 {
00939 NS_LOG_FUNCTION_NOARGS ();
00940 return true;
00941 }
00942
00943 void
00944 CsmaNetDevice::SetReceiveCallback (NetDevice::ReceiveCallback cb)
00945 {
00946 NS_LOG_FUNCTION (&cb);
00947 m_rxCallback = cb;
00948 }
00949
00950 Address CsmaNetDevice::GetMulticast (Ipv6Address addr) const
00951 {
00952 Mac48Address ad = Mac48Address::GetMulticast (addr);
00953
00954 NS_LOG_LOGIC("MAC IPv6 multicast address is " << ad);
00955 return ad;
00956 }
00957
00958 void
00959 CsmaNetDevice::SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb)
00960 {
00961 NS_LOG_FUNCTION (&cb);
00962 m_promiscRxCallback = cb;
00963 }
00964
00965 bool
00966 CsmaNetDevice::SupportsSendFrom () const
00967 {
00968 NS_LOG_FUNCTION_NOARGS ();
00969 return true;
00970 }
00971
00972 }