00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include <iostream>
00027 #include <algorithm>
00028
00029 #include <string.h>
00030
00031 #include "pending-data.h"
00032 #include "ns3/fatal-error.h"
00033 namespace ns3
00034 {
00035
00036 PendingData::PendingData () : size (0), data (0),
00037 msgSize (0), responseSize (0)
00038 {
00039 }
00040
00041 PendingData::PendingData (uint32_t s, uint8_t* d, uint32_t msg, uint32_t resp)
00042 : size (s), data (0), msgSize (msg), responseSize (resp)
00043 {
00044 if (d)
00045 {
00046 data.push_back (Create<Packet> (d, size));
00047 }
00048 }
00049
00050 PendingData::PendingData(const std::string& s)
00051 : size (s.length () + 1), data (0),
00052 msgSize (0), responseSize (0)
00053 {
00054 data.push_back (Create<Packet> ((uint8_t*)s.c_str(), size));
00055 }
00056
00057 PendingData::PendingData(const PendingData& c)
00058 : size (c.Size ()), data (c.data),
00059 msgSize (c.msgSize), responseSize (c.responseSize)
00060 {
00061 }
00062
00063 PendingData::~PendingData()
00064 {
00065 }
00066
00067 PendingData* PendingData::Copy () const
00068 {
00069 return new PendingData (*this);
00070 };
00071
00072 PendingData* PendingData::CopyS (uint32_t s)
00073 {
00074 return new PendingData (s, 0, msgSize, responseSize);
00075 }
00076
00077 PendingData* PendingData::CopySD (uint32_t s, uint8_t* d)
00078 {
00079 return new PendingData (s, d, msgSize, responseSize);
00080 }
00081
00082 void PendingData::Clear ()
00083 {
00084 data.clear();
00085 size = 0;
00086 }
00087
00088 void PendingData::Add (uint32_t s, const uint8_t* d)
00089 {
00090 if (d == 0)
00091 {
00092 data.push_back(Create<Packet> (d,s));
00093 }
00094 else
00095 {
00096 data.push_back(Create<Packet> (s));
00097 }
00098 size += s;
00099 }
00100
00101 void PendingData::Add (Ptr<Packet> p)
00102 {
00103 data.push_back(p);
00104 size += p->GetSize();
00105 }
00106
00107 uint32_t PendingData::SizeFromSeq (const SequenceNumber& f, const SequenceNumber& o)
00108 {
00109 uint32_t o1 = OffsetFromSeq (f,o);
00110 return SizeFromOffset (o1);
00111 }
00112
00113 uint32_t PendingData::SizeFromOffset (uint32_t o)
00114 {
00115 if (o > size) return 0;
00116 return size - o;
00117 }
00118
00119 uint32_t PendingData::OffsetFromSeq (const SequenceNumber& f, const SequenceNumber& o)
00120 {
00121 if (o < f)
00122 {
00123 return 0;
00124 }
00125 return o - f;
00126 }
00127
00128 Ptr<Packet> PendingData::CopyFromOffset (uint32_t s, uint32_t o)
00129 {
00130
00131 uint32_t s1 = std::min (s, SizeFromOffset (o));
00132 if (s1 == 0)
00133 {
00134 return Create<Packet> ();
00135 }
00136 if (data.size() != 0)
00137 {
00138 uint32_t count = 0;
00139 std::vector<Ptr<Packet> >::size_type begin = 0;
00140 bool beginFound = false;
00141 std::vector<Ptr<Packet> >::size_type end = 0;
00142 Ptr<Packet> outPacket;
00143 Ptr<Packet> endFragment;
00144 for (std::vector<Ptr<Packet> >::size_type i=0;i<data.size();++i)
00145 {
00146 count+=data[i]->GetSize();
00147 if (!beginFound)
00148 {
00149 if (count > o)
00150 {
00151 if (count >= o + s1)
00152 {
00153 Ptr<Packet> toFragment = data[i];
00154 uint32_t packetStart = count - toFragment->GetSize();
00155 uint32_t packetOffset = o - packetStart;
00156 outPacket = toFragment->CreateFragment (packetOffset, s1);
00157 return outPacket;
00158 }
00159 begin = i;
00160 beginFound = true;
00161 Ptr<Packet> toFragment = data[begin];
00162 uint32_t packetStart = count - toFragment->GetSize();
00163 uint32_t packetOffset = o - packetStart;
00164 uint32_t fragmentLength = count - o;
00165 outPacket = toFragment->CreateFragment (packetOffset, fragmentLength);
00166 }
00167 }
00168 else
00169 {
00170 if (count >= o + s1)
00171 {
00172 end = i;
00173 Ptr<Packet> toFragment = data[end];
00174 uint32_t packetStart = count - toFragment->GetSize();
00175 uint32_t fragmentLength = o + s1 - packetStart;
00176 endFragment = toFragment->CreateFragment(0, fragmentLength);
00177 break;
00178 }
00179 }
00180 }
00181 for (std::vector<Ptr<Packet> >::size_type i=begin+1;i<end;++i)
00182 {
00183 outPacket->AddAtEnd (data[i]);
00184 }
00185 outPacket->AddAtEnd(endFragment);
00186 NS_ASSERT(outPacket->GetSize() == s1);
00187 return outPacket;
00188 }
00189 else
00190 {
00191 return Create<Packet> (s1);
00192 }
00193 }
00194
00195 Ptr<Packet> PendingData::CopyFromSeq (uint32_t s, const SequenceNumber& f, const SequenceNumber& o)
00196 {
00197 return CopyFromOffset (s, OffsetFromSeq(f,o));
00198 }
00199
00200 }