void
SSLinkManager::SendRangingRequest (uint8_t uiuc, uint16_t allocationSize)
{
NS_ASSERT_MSG (
m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_WAITING_REG_RANG_INTRVL
|| m_ss->GetState ()
== SubscriberStationNetDevice::SS_STATE_WAITING_INV_RANG_INTRVL,
"SS: Error while sending a ranging request: the ss state should be SS_STATE_WAITING_REG_RANG_INTRVL or SS_STATE_WAITING_INV_RANG_INTRVL");
if (m_nrRngReqsSent == 0) // sending the first time
{
m_pTxIrMax = CalculateMaxIRSignalStrength ();
m_rngreq.SetReqDlBurstProfile (
m_ss->GetBurstProfileManager ()->GetBurstProfileToRequest ());
m_rngreq.SetMacAddress (m_ss->GetMacAddress ());
}
else
{
m_pTxIrMax++;
if (m_nrRngRspsRecvd > 0)
{
m_rngreq.SetRangingAnomalies (m_rangingAnomalies);
}
}
Ptr<Packet> packet = Create<Packet> ();
Ptr<PacketBurst> burst = Create<PacketBurst> ();
packet->AddHeader (m_rngreq);
packet->AddHeader (ManagementMessageType (
ManagementMessageType::MESSAGE_TYPE_RNG_REQ));
Ptr<WimaxConnection> connection;
if (m_rangingStatus == WimaxNetDevice::RANGING_STATUS_CONTINUE)
{
connection = m_ss->GetBasicConnection ();
}
else // have been assigned BCID, means currently adjusting parameters
{
connection = m_ss->GetInitialRangingConnection ();
}
m_ss->Enqueue (packet, MacHeaderType (), connection);
m_ss->SetState (SubscriberStationNetDevice::SS_STATE_WAITING_RNG_RSP);
m_ss->SetTimer (Simulator::Schedule (m_ss->GetIntervalT3 (),
&SSLinkManager::StartContentionResolution, this), m_waitForRngRspEvent);
m_nrRngReqsSent++;
NS_ASSERT_MSG (allocationSize
== m_ss->GetCurrentUcd ().GetChannelEncodings ().GetRangReqOppSize ()
/ m_ss->GetPhy ()->GetPsPerSymbol (),
"SS: Error while sending a ranging request: the allocation size is not correct");
// will work even if connection is not passed (i.e. null is passed) as scheduler will automatically select the same connection
m_ss->SendBurst (uiuc, allocationSize, connection);
}
Ptr<Packet>
MeshWifiBeacon::CreatePacket ()
{
Ptr<Packet> packet = Create <Packet> ();
packet->AddHeader (m_elements);
packet->AddHeader (BeaconHeader ());
return packet;
}
void
DsrSRHeaderTest::DoRun ()
{
dsr::DsrOptionSRHeader h;
std::vector<Ipv4Address> nodeList;
nodeList.push_back (Ipv4Address ("1.1.1.0"));
nodeList.push_back (Ipv4Address ("1.1.1.1"));
nodeList.push_back (Ipv4Address ("1.1.1.2"));
h.SetNodesAddress (nodeList);
NS_TEST_EXPECT_MSG_EQ (h.GetNodeAddress (0), Ipv4Address ("1.1.1.0"), "trivial");
NS_TEST_EXPECT_MSG_EQ (h.GetNodeAddress (1), Ipv4Address ("1.1.1.1"), "trivial");
NS_TEST_EXPECT_MSG_EQ (h.GetNodeAddress (2), Ipv4Address ("1.1.1.2"), "trivial");
h.SetSalvage (1);
NS_TEST_EXPECT_MSG_EQ (h.GetSalvage (), 1, "trivial");
h.SetSegmentsLeft (2);
NS_TEST_EXPECT_MSG_EQ (h.GetSegmentsLeft (), 2, "trivial");
Ptr<Packet> p = Create<Packet> ();
dsr::DsrRoutingHeader header;
header.AddDsrOption (h);
p->AddHeader (header);
p->RemoveAtStart (8);
dsr::DsrOptionSRHeader h2;
h2.SetNumberAddress (3);
uint32_t bytes = p->RemoveHeader (h2);
NS_TEST_EXPECT_MSG_EQ (bytes, 16, "Total RREP is 16 bytes long");
}
void
LtePdcp::DoTransmitPdcpSdu (Ptr<Packet> p)
{
NS_LOG_FUNCTION (this << m_rnti << (uint32_t) m_lcid << p->GetSize ());
LtePdcpHeader pdcpHeader;
pdcpHeader.SetSequenceNumber (m_txSequenceNumber);
m_txSequenceNumber++;
if (m_txSequenceNumber > m_maxPdcpSn)
{
m_txSequenceNumber = 0;
}
pdcpHeader.SetDcBit (LtePdcpHeader::DATA_PDU);
NS_LOG_LOGIC ("PDCP header: " << pdcpHeader);
p->AddHeader (pdcpHeader);
// Sender timestamp
PdcpTag pdcpTag (Simulator::Now ());
p->AddByteTag (pdcpTag);
m_txPdu (m_rnti, m_lcid, p->GetSize ());
LteRlcSapProvider::TransmitPdcpPduParameters params;
params.rnti = m_rnti;
params.lcid = m_lcid;
params.pdcpPdu = p;
m_rlcSapProvider->TransmitPdcpPdu (params);
}
void
DsrAckReqHeaderTest::DoRun ()
{
dsr::DsrOptionAckReqHeader h;
h.SetAckId (1);
NS_TEST_EXPECT_MSG_EQ (h.GetAckId (), 1, "trivial");
Ptr<Packet> p = Create<Packet> ();
dsr::DsrRoutingHeader header;
header.AddDsrOption (h);
p->AddHeader (header);
p->RemoveAtStart (8);
p->AddHeader (header);
dsr::DsrOptionAckReqHeader h2;
p->RemoveAtStart (8);
uint32_t bytes = p->RemoveHeader (h2);
NS_TEST_EXPECT_MSG_EQ (bytes, 4, "Total RREP is 4 bytes long");
}
void
DsrAckHeaderTest::DoRun ()
{
dsr::DsrOptionAckHeader h;
h.SetRealSrc (Ipv4Address ("1.1.1.0"));
NS_TEST_EXPECT_MSG_EQ (h.GetRealSrc (), Ipv4Address ("1.1.1.0"), "trivial");
h.SetRealDst (Ipv4Address ("1.1.1.1"));
NS_TEST_EXPECT_MSG_EQ (h.GetRealDst (), Ipv4Address ("1.1.1.1"), "trivial");
h.SetAckId (1);
NS_TEST_EXPECT_MSG_EQ (h.GetAckId (), 1, "trivial");
Ptr<Packet> p = Create<Packet> ();
dsr::DsrRoutingHeader header;
header.AddDsrOption (h);
p->AddHeader (header);
p->RemoveAtStart (8);
p->AddHeader (header);
dsr::DsrOptionAckHeader h2;
p->RemoveAtStart (8);
uint32_t bytes = p->RemoveHeader (h2);
NS_TEST_EXPECT_MSG_EQ (bytes, 12, "Total RREP is 12 bytes long");
}
Ptr<Packet>
WimaxMacQueue::Peek (GenericMacHeader &hdr) const
{
if (!IsEmpty ())
{
QueueElement element = m_queue.front ();
hdr = element.m_hdr;
Ptr<Packet> packet = element.m_packet->Copy ();
// this function must not be used by SS as it may be then a bandwidth request header
packet->AddHeader (element.m_hdr);
return packet;
}
return 0;
}
Ptr<Packet>
WimaxMacQueue::Peek (MacHeaderType::HeaderType packetType) const
{
if (!IsEmpty ())
{
QueueElement element = Front (packetType);
Ptr<Packet> packet = element.m_packet->Copy ();
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
packet->AddHeader (element.m_hdr);
}
return packet;
}
return 0;
}
Ptr<Packet>
BlockAckManager::ScheduleBlockAckReqIfNeeded (Mac48Address recipient, uint8_t tid)
{
/* This method checks if a BlockAckRequest frame should be send to the recipient station.
Number of packets under block ack is specified in OriginatorBlockAckAgreement object but sometimes
this number could be incorrect. In fact is possible that a block ack agreement exists for n
packets but some of these packets are dropped due to MSDU lifetime expiration.
*/
NS_LOG_FUNCTION (this << recipient << static_cast<uint32_t> (tid));
AgreementsI it = m_agreements.find (std::make_pair (recipient, tid));
NS_ASSERT (it != m_agreements.end ());
if ((*it).second.first.IsBlockAckRequestNeeded ()
|| (GetNRetryNeededPackets (recipient, tid) == 0
&& m_queue->GetNPacketsByTidAndAddress (tid, WifiMacHeader::ADDR1, recipient) == 0))
{
OriginatorBlockAckAgreement &agreement = (*it).second.first;
agreement.CompleteExchange ();
CtrlBAckRequestHeader reqHdr;
if (m_blockAckType == BASIC_BLOCK_ACK || m_blockAckType == COMPRESSED_BLOCK_ACK)
{
reqHdr.SetType (m_blockAckType);
reqHdr.SetTidInfo (agreement.GetTid ());
reqHdr.SetStartingSequence (agreement.GetStartingSequence ());
}
else if (m_blockAckType == MULTI_TID_BLOCK_ACK)
{
NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
}
else
{
NS_FATAL_ERROR ("Invalid block ack type.");
}
Ptr<Packet> bar = Create<Packet> ();
bar->AddHeader (reqHdr);
return bar;
}
return 0;
}
void
DsrRerrHeaderTest::DoRun ()
{
dsr::DsrOptionRerrUnreachHeader h;
h.SetErrorSrc (Ipv4Address ("1.1.1.0"));
NS_TEST_EXPECT_MSG_EQ (h.GetErrorSrc (), Ipv4Address ("1.1.1.0"), "trivial");
h.SetErrorDst (Ipv4Address ("1.1.1.1"));
NS_TEST_EXPECT_MSG_EQ (h.GetErrorDst (), Ipv4Address ("1.1.1.1"), "trivial");
h.SetSalvage (1);
NS_TEST_EXPECT_MSG_EQ (h.GetSalvage (), 1, "trivial");
h.SetUnreachNode (Ipv4Address ("1.1.1.2"));
NS_TEST_EXPECT_MSG_EQ (h.GetUnreachNode (), Ipv4Address ("1.1.1.2"), "trivial");
Ptr<Packet> p = Create<Packet> ();
dsr::DsrRoutingHeader header;
header.AddDsrOption (h);
p->AddHeader (header);
p->RemoveAtStart (8);
dsr::DsrOptionRerrUnreachHeader h2;
uint32_t bytes = p->RemoveHeader (h2);
NS_TEST_EXPECT_MSG_EQ (bytes, 20, "Total RREP is 20 bytes long");
}
void
DsaRequestTestCase::DoRun (void)
{
IpcsClassifierRecord classifier = IpcsClassifierRecord ();
CsParameters csParam (CsParameters::ADD, classifier);
ServiceFlow sf = ServiceFlow (ServiceFlow::SF_DIRECTION_DOWN);
sf.SetSfid (100);
sf.SetConvergenceSublayerParam (csParam);
sf.SetCsSpecification (ServiceFlow::IPV4);
sf.SetServiceSchedulingType (ServiceFlow::SF_TYPE_UGS);
sf.SetMaxSustainedTrafficRate (1000000);
sf.SetMinReservedTrafficRate (1000000);
sf.SetMinTolerableTrafficRate (1000000);
sf.SetMaximumLatency (10);
sf.SetMaxTrafficBurst (1000);
sf.SetTrafficPriority (1);
DsaReq dsaReq (sf);
Ptr<Packet> packet = Create<Packet> ();
packet->AddHeader (dsaReq);
DsaReq dsaReqRecv;
packet->RemoveHeader (dsaReqRecv);
ServiceFlow sfRecv = dsaReqRecv.GetServiceFlow ();
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetDirection (), ServiceFlow::SF_DIRECTION_DOWN, "The sfRecv had the wrong direction.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetSfid (), 100, "The sfRecv had the wrong sfid.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetCsSpecification (), ServiceFlow::IPV4, "The sfRecv had the wrong cs specification.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetServiceSchedulingType (), ServiceFlow::SF_TYPE_UGS, "The sfRecv had the wrong service scheduling type.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaxSustainedTrafficRate (), 1000000, "The sfRecv had the wrong maximum sustained traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMinReservedTrafficRate (), 1000000, "The sfRecv had the wrong minimum reserved traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMinTolerableTrafficRate (), 1000000, "The sfRecv had the wrong minimum tolerable traffic rate.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaximumLatency (), 10, "The sfRecv had the wrong maximum latency.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetMaxTrafficBurst (), 1000, "The sfRecv had the wrong maximum traffic burst.");
NS_TEST_ASSERT_MSG_EQ (sfRecv.GetTrafficPriority (), 1, "The sfRecv had the wrong traffic priority.");
}
bool
FdNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)
{
NS_LOG_FUNCTION (this << packet << src << dest << protocolNumber);
NS_LOG_LOGIC ("packet " << packet);
NS_LOG_LOGIC ("UID is " << packet->GetUid ());
if (IsLinkUp () == false)
{
m_macTxDropTrace (packet);
return false;
}
Mac48Address destination = Mac48Address::ConvertFrom (dest);
Mac48Address source = Mac48Address::ConvertFrom (src);
NS_LOG_LOGIC ("Transmit packet with UID " << packet->GetUid ());
NS_LOG_LOGIC ("Transmit packet from " << source);
NS_LOG_LOGIC ("Transmit packet to " << destination);
EthernetHeader header (false);
header.SetSource (source);
header.SetDestination (destination);
if (m_encapMode == LLC)
{
LlcSnapHeader llc;
llc.SetType (protocolNumber);
packet->AddHeader (llc);
header.SetLengthType (packet->GetSize ());
}
else
{
header.SetLengthType (protocolNumber);
}
packet->AddHeader (header);
//
// there's not much meaning associated with the different layers in this
// device, so don't be surprised when they're all stacked together in
// essentially one place. We do this for trace consistency across devices.
//
m_macTxTrace (packet);
m_promiscSnifferTrace (packet);
m_snifferTrace (packet);
NS_LOG_LOGIC ("calling write");
NS_ASSERT_MSG (packet->GetSize () <= m_mtu, "FdNetDevice::SendFrom(): Packet too big " << packet->GetSize ());
ssize_t len = (ssize_t) packet->GetSize ();
uint8_t *buffer = (uint8_t*)malloc (len);
packet->CopyData (buffer, len);
// We need to add the PI header
if (m_encapMode == DIXPI)
{
AddPIHeader (buffer, len);
}
ssize_t written = write (m_fd, buffer, len);
free (buffer);
if (written == -1 || written != len)
{
m_macTxDropTrace (packet);
return false;
}
return true;
}
void Ping6::Send ()
{
NS_LOG_FUNCTION_NOARGS ();
NS_ASSERT (m_sendEvent.IsExpired ());
Ptr<Packet> p = 0;
uint8_t* data = new uint8_t[m_size];
Ipv6Address src;
Ptr<Ipv6> ipv6 = GetNode ()->GetObject<Ipv6> ();
if (m_ifIndex > 0)
{
/* hack to have ifIndex in Ipv6RawSocketImpl
* maybe add a SetIfIndex in Ipv6RawSocketImpl directly
*/
Ipv6InterfaceAddress dstIa (m_peerAddress);
for (uint32_t i = 0; i < GetNode ()->GetObject<Ipv6> ()->GetNAddresses (m_ifIndex); i++)
{
src = GetNode ()->GetObject<Ipv6> ()->GetAddress (m_ifIndex, i).GetAddress ();
Ipv6InterfaceAddress srcIa (src);
if ( srcIa.GetScope() == dstIa.GetScope() )
{
break;
}
}
}
else
{
src = m_localAddress;
}
NS_ASSERT_MSG (m_size >= 4, "ICMPv6 echo request payload size must be >= 4");
data[0] = 0xDE;
data[1] = 0xAD;
data[2] = 0xBE;
data[3] = 0xEF;
p = Create<Packet> (data, 4);
p->AddAtEnd (Create<Packet> (m_size - 4));
Icmpv6Echo req (1);
req.SetId (0xBEEF);
req.SetSeq (m_seq);
m_seq++;
/* we do not calculate pseudo header checksum here, because we are not sure about
* source IPv6 address. Checksum is calculated in Ipv6RawSocketImpl.
*/
p->AddHeader (req);
m_socket->Bind (Inet6SocketAddress (src, 0));
/* use Loose Routing (routing type 0) */
if (m_routers.size ())
{
Ipv6ExtensionLooseRoutingHeader routingHeader;
routingHeader.SetNextHeader (Ipv6Header::IPV6_ICMPV6);
routingHeader.SetLength (m_routers.size () * 16 + 8);
routingHeader.SetTypeRouting (0);
routingHeader.SetSegmentsLeft (m_routers.size ());
routingHeader.SetRoutersAddress (m_routers);
p->AddHeader (routingHeader);
m_socket->SetAttribute ("Protocol", UintegerValue (Ipv6Header::IPV6_EXT_ROUTING));
}
m_socket->Send (p, 0);
++m_sent;
NS_LOG_INFO ("Sent " << p->GetSize () << " bytes to " << m_peerAddress);
if (m_sent < m_count)
{
ScheduleTransmit (m_interval);
}
delete[] data;
}
Ptr<Packet>
WimaxMacQueue::Dequeue (MacHeaderType::HeaderType packetType, uint32_t availableByte)
{
if (!IsEmpty ())
{
NS_LOG_INFO ("FRAG_DEBUG: Dequeue function" << std::endl);
QueueElement element = Front (packetType);
uint32_t headerSize = 2 + element.m_hdr.GetSerializedSize () +
element.m_hdrType.GetSerializedSize ();
// Create a fragment
uint32_t maxFragmentSize = availableByte - headerSize;
uint32_t fragmentOffset = element.m_fragmentOffset; // It is the latest byte sent.
Ptr<Packet> packet = element.m_packet->Copy ();
NS_LOG_INFO ("\t Create a fragment"
"\n\t\t availableByte=" << availableByte <<
"\n\t\t headerSize=" << headerSize <<
"\n\t\t maxFragmentSize=" << maxFragmentSize << ""
"\n\t\t fragmentOffset=" << fragmentOffset <<
"\n\t\t payloadSize=" << packet->GetSize ()
<< std::endl);
Ptr<Packet> fragment = packet->CreateFragment (fragmentOffset,
maxFragmentSize);
m_bytes -= maxFragmentSize;
FragmentationSubheader fragmentSubhdr;
if (!element.m_fragmentation)
{
NS_LOG_INFO ("\t First Fragment" << std::endl);
SetFragmentation (packetType);
fragmentSubhdr.SetFc (1);
}
else
{
NS_LOG_INFO ("\t Middle Fragment" << std::endl);
fragmentSubhdr.SetFc (3);
}
fragmentSubhdr.SetFsn (element.m_fragmentNumber);
NS_LOG_INFO ("\t FragmentSize=" << fragment->GetSize () << std::endl);
fragment->AddHeader (fragmentSubhdr);
SetFragmentNumber (packetType);
SetFragmentOffset (packetType, maxFragmentSize);
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
uint8_t tmpType = element.m_hdr.GetType ();
tmpType |= 4;
element.m_hdr.SetType (tmpType);
uint32_t length = maxFragmentSize + element.m_hdr.GetSerializedSize ()
+ fragmentSubhdr.GetSerializedSize ();
element.m_hdr.SetLen ((uint16_t)length);
fragment->AddHeader (element.m_hdr);
}
fragment->AddHeader (element.m_hdrType);
m_traceDequeue (fragment);
return fragment;
}
return 0;
}
Ptr<Packet>
WimaxMacQueue::Dequeue (MacHeaderType::HeaderType packetType)
{
if (!IsEmpty ())
{
QueueElement element = Front (packetType);
Pop (packetType);
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
NS_LOG_INFO ("Enqueued Packet IS A data packet");
NS_ASSERT_MSG (m_nrDataPackets >= 1,
"Can not enqueue more packets: no space left in the queue");
m_nrDataPackets--;
}
else
{
NS_LOG_INFO ("Enqueued Packet IS A Request BW packet");
NS_ASSERT_MSG (m_nrRequestPackets >= 1,
"Can not enqueue more packets: no space left in the queue");
m_nrRequestPackets--;
}
Ptr<Packet> packet = element.m_packet;
if (!element.m_fragmentation)
{
NS_LOG_INFO ("FRAG_DEBUG: Enqueued Packet IS NOT a fragment" << std::endl);
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
m_bytes -= element.GetSize ();
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
packet->AddHeader (element.m_hdr);
}
packet->AddHeader (element.m_hdrType);
m_traceDequeue (packet);
return packet;
}
else
{
/*
The enqueued packet is a fragment (the latest fragment)
We must modify type field of the m_hdr and add a fragmentation Subhdr
*/
NS_LOG_INFO ("\t Enqueued Packet IS a fragment, add subhdr" << std::endl);
// Create a fragment
uint32_t fragmentOffset = element.m_fragmentOffset;
uint32_t fragmentSize = element.m_packet->GetSize () - fragmentOffset;
NS_LOG_INFO ("\t Create a fragment"
"\n\t\t fragmentOffset=" << fragmentOffset <<
"\n\t\t packetSize=" << element.m_packet->GetSize () <<
"\n\t\t fragmentSize=" << fragmentSize << std::endl);
Ptr<Packet> fragment = packet->CreateFragment (fragmentOffset,fragmentSize);
FragmentationSubheader fragmentSubhdr;
NS_LOG_INFO ("\t Latest Fragment" << std::endl);
fragmentSubhdr.SetFc (2); // This is the latest fragment
fragmentSubhdr.SetFsn (element.m_fragmentNumber);
NS_LOG_INFO ("\t FragmentSize=" << fragment->GetSize () << std::endl);
fragment->AddHeader (fragmentSubhdr);
/*check because may be it is a bandwidth request packet (in which case a Bandwidth Request Header
has already been added to the packet) in which case Generic MAC Header will not be added to it.
this will only happen in the case of SS as only SS sends the bandwidth request packet. */
if (element.m_hdrType.GetType () == MacHeaderType::HEADER_TYPE_GENERIC)
{
uint8_t tmpType = element.m_hdr.GetType ();
tmpType |= 4;
element.m_hdr.SetType (tmpType);
uint32_t length = fragmentSize + element.m_hdr.GetSerializedSize ()
+ fragmentSubhdr.GetSerializedSize ();
element.m_hdr.SetLen ((uint16_t)length);
fragment->AddHeader (element.m_hdr);
}
fragment->AddHeader (element.m_hdrType);
m_bytes -= fragmentSize;
m_traceDequeue (fragment);
return fragment;
}
}
return 0;
}
