Attachment #1719 for bug #938

View | Details | Raw Unified | Return to bug 938
Collapse All | Expand All

(-)a/src/internet/model/arp-cache.h (-18 / +81 lines)

Lines 49-82	Link Here

class ArpCache : public Object

class ArpCache : public Object

private:

private:

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

*/

  ArpCache (ArpCache const &);

  ArpCache (ArpCache const &);

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

   * \returns

*/

  ArpCache& operator= (ArpCache const &);

  ArpCache& operator= (ArpCache const &);

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  class Entry;

  class Entry;

  ArpCache ();

  ArpCache ();

  ~ArpCache ();

  ~ArpCache ();

/**

/**

   * \brief Set the NetDevice and Ipv4Interface associated with the ArpCache

   * \param device The hardware NetDevice associated with this ARP chache

   * \param device The hardware NetDevice associated with this ARP chache

   * \param interface the Ipv4Interface associated with this ARP chache

   * \param interface the Ipv4Interface associated with this ARP chache

*/

*/

  void SetDevice (Ptr<NetDevice> device, Ptr<Ipv4Interface> interface);

  void SetDevice (Ptr<NetDevice> device, Ptr<Ipv4Interface> interface);

/**

/**

   * \brief Returns the NetDevice that this ARP cache is associated with

   * \return The NetDevice that this ARP cache is associated with

   * \return The NetDevice that this ARP cache is associated with

*/

*/

  Ptr<NetDevice> GetDevice (void) const;

  Ptr<NetDevice> GetDevice (void) const;

/**

/**

   * \brief Returns the Ipv4Interface that this ARP cache is associated with

   * \return the Ipv4Interface that this ARP cache is associated with

   * \return the Ipv4Interface that this ARP cache is associated with

*/

*/

  Ptr<Ipv4Interface> GetInterface (void) const;

  Ptr<Ipv4Interface> GetInterface (void) const;

/**

   * \brief Set the time the entry will be in ALIVE state (unless refreshed)

   * \param aliveTimeout the Alive state timeout

*/

  void SetAliveTimeout (Time aliveTimeout);

  void SetAliveTimeout (Time aliveTimeout);

/**

100

   * \brief Set the time the entry will be in DEAD state before being removed

101

   * \param deadTimeout the Dead state timeout

102

*/

  void SetDeadTimeout (Time deadTimeout);

103

  void SetDeadTimeout (Time deadTimeout);

104

/**

105

   * \brief Set the time the entry will be in WAIT_REPLY state

106

   * \param waitReplyTimeout the WAIT_REPLY state timeout

107

*/

  void SetWaitReplyTimeout (Time waitReplyTimeout);

108

  void SetWaitReplyTimeout (Time waitReplyTimeout);

109

110

/**

111

   * \brief Get the time the entry will be in ALIVE state (unless refreshed)

112

   * \returns the Alive state timeout

113

*/

  Time GetAliveTimeout (void) const;

114

  Time GetAliveTimeout (void) const;

115

/**

116

   * \brief Get the time the entry will be in DEAD state before being removed

117

   * \returns the Dead state timeout

118

*/

  Time GetDeadTimeout (void) const;

119

  Time GetDeadTimeout (void) const;

120

/**

121

   * \brief Get the time the entry will be in WAIT_REPLY state

122

   * \returns the WAIT_REPLY state timeout

123

*/

  Time GetWaitReplyTimeout (void) const;

124

  Time GetWaitReplyTimeout (void) const;

125

/**

126

/**

Lines 190-235	Link Here

190

    void ClearRetries (void);

234

    void ClearRetries (void);

191

235

192

private:

236

private:

237

/**

238

     * \brief ARP cache entry states

239

*/

193

    enum ArpCacheEntryState_e {

240

    enum ArpCacheEntryState_e {

194

      ALIVE,

241

      ALIVE,

195

      WAIT_REPLY,

242

      WAIT_REPLY,

196

      DEAD

243

      DEAD

197

};

244

};

198

245

246

/**

247

     * \brief Update the entry when seeing a packet

248

*/

199

    void UpdateSeen (void);

249

    void UpdateSeen (void);

250

251

/**

252

     * \brief Returns the entry timeout

253

     * \returns the entry timeout

254

*/

200

    Time GetTimeout (void) const;

255

    Time GetTimeout (void) const;

201

    ArpCache *m_arp;

256

202

    ArpCacheEntryState_e m_state;

257

    ArpCache *m_arp; //!< pointer to the ARP cache owning the entry

203

    Time m_lastSeen;

258

    ArpCacheEntryState_e m_state; //!< state of the entry

204

    Address m_macAddress;

259

    Time m_lastSeen; //!< last moment a packet from that address has been seen

205

    Ipv4Address m_ipv4Address;

260

    Address m_macAddress; //!< entry's MAC address

206

    std::list<Ptr<Packet> > m_pending;

261

    Ipv4Address m_ipv4Address; //!< entry's IP address

207

    uint32_t m_retries;

262

    std::list<Ptr<Packet> > m_pending; //!< list of pending packets for the entry's IP

263

    uint32_t m_retries; //!< rerty counter

208

};

264

};

209

265

210

private:

266

private:

267

/**

268

   * \brief ARP Cache container

269

*/

211

  typedef sgi::hash_map<Ipv4Address, ArpCache::Entry *, Ipv4AddressHash> Cache;

270

  typedef sgi::hash_map<Ipv4Address, ArpCache::Entry *, Ipv4AddressHash> Cache;

271

/**

272

   * \brief ARP Cache container iterator

273

*/

212

  typedef sgi::hash_map<Ipv4Address, ArpCache::Entry *, Ipv4AddressHash>::iterator CacheI;

274

  typedef sgi::hash_map<Ipv4Address, ArpCache::Entry *, Ipv4AddressHash>::iterator CacheI;

213

275

214

  virtual void DoDispose (void);

276

  virtual void DoDispose (void);

215

277

216

  Ptr<NetDevice> m_device;

278

  Ptr<NetDevice> m_device; //!< NetDevice associated with the cache

217

  Ptr<Ipv4Interface> m_interface;

279

  Ptr<Ipv4Interface> m_interface; //!< Ipv4Interface associated with the cache

218

  Time m_aliveTimeout;

280

  Time m_aliveTimeout; //!< cache alive state timeout

219

  Time m_deadTimeout;

281

  Time m_deadTimeout; //!< cache dead state timeout

220

  Time m_waitReplyTimeout;

282

  Time m_waitReplyTimeout; //!< cache reply state timeout

221

  EventId m_waitReplyTimer;

283

  EventId m_waitReplyTimer;  //!< cache alive state timer

222

  Callback<void, Ptr<const ArpCache>, Ipv4Address> m_arpRequestCallback;

284

  Callback<void, Ptr<const ArpCache>, Ipv4Address> m_arpRequestCallback;  //!< reply timeout callback

223

  uint32_t m_maxRetries;

285

  uint32_t m_maxRetries; //!< max retries for a resolution

286

224

/**

287

/**

225

   * This function is an event handler for the event that the

288

   * This function is an event handler for the event that the

226

   * ArpCache wants to check whether it must retry any Arp requests.

289

   * ArpCache wants to check whether it must retry any Arp requests.

227

   * If there are no Arp requests pending, this event is not scheduled.

290

   * If there are no Arp requests pending, this event is not scheduled.

228

*/

291

*/

229

  void HandleWaitReplyTimeout (void);

292

  void HandleWaitReplyTimeout (void);

230

  uint32_t m_pendingQueueSize;

293

  uint32_t m_pendingQueueSize; //!< number of packets waiting for a resolution

231

  Cache m_arpCache;

294

  Cache m_arpCache; //!< the ARP cache

232

  TracedCallback<Ptr<const Packet> > m_dropTrace;

295

  TracedCallback<Ptr<const Packet> > m_dropTrace; //!< trace for packets dropped by the ARP cache queue

233

};

296

};

234

297

235

298

(-)a/src/internet/model/arp-header.h (-5 / +56 lines)

Lines 34-54	Link Here

class ArpHeader : public Header

class ArpHeader : public Header

public:

public:

/**

   * \brief Set the ARP request parameters

   * \param sourceHardwareAddress the source hardware address

   * \param sourceProtocolAddress the source IP address

   * \param destinationHardwareAddress the destination hardware address (usually the broadcast address)

   * \param destinationProtocolAddress the destination IP address

*/

  void SetRequest (Address sourceHardwareAddress,

  void SetRequest (Address sourceHardwareAddress,

                   Ipv4Address sourceProtocolAddress,

                   Ipv4Address sourceProtocolAddress,

                   Address destinationHardwareAddress,

                   Address destinationHardwareAddress,

                   Ipv4Address destinationProtocolAddress);

                   Ipv4Address destinationProtocolAddress);

/**

   * \brief Set the ARP reply parameters

   * \param sourceHardwareAddress the source hardware address

   * \param sourceProtocolAddress the source IP address

   * \param destinationHardwareAddress the destination hardware address (usually the broadcast address)

   * \param destinationProtocolAddress the destination IP address

*/

  void SetReply (Address sourceHardwareAddress,

  void SetReply (Address sourceHardwareAddress,

                 Ipv4Address sourceProtocolAddress,

                 Ipv4Address sourceProtocolAddress,

                 Address destinationHardwareAddress,

                 Address destinationHardwareAddress,

                 Ipv4Address destinationProtocolAddress);

                 Ipv4Address destinationProtocolAddress);

/**

   * \brief Check if the ARP is a request

   * \returns true if it is a request

*/

  bool IsRequest (void) const;

  bool IsRequest (void) const;

/**

   * \brief Check if the ARP is a reply

   * \returns true if it is a reply

*/

  bool IsReply (void) const;

  bool IsReply (void) const;

/**

   * \brief Returns the source hardware address

   * \returns the source hardware address

*/

  Address GetSourceHardwareAddress (void);

  Address GetSourceHardwareAddress (void);

/**

   * \brief Returns the destination hardware address

   * \returns the destination hardware address

*/

  Address GetDestinationHardwareAddress (void);

  Address GetDestinationHardwareAddress (void);

/**

   * \brief Returns the source IP address

   * \returns the source IP address

*/

  Ipv4Address GetSourceIpv4Address (void);

  Ipv4Address GetSourceIpv4Address (void);

/**

   * \brief Returns the destination IP address

   * \returns the destination IP address

*/

  Ipv4Address GetDestinationIpv4Address (void);

  Ipv4Address GetDestinationIpv4Address (void);

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

100

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

101

  virtual TypeId GetInstanceTypeId (void) const;

  virtual void Print (std::ostream &os) const;

102

  virtual void Print (std::ostream &os) const;

Lines 56-70	Link Here

  virtual void Serialize (Buffer::Iterator start) const;

104

  virtual void Serialize (Buffer::Iterator start) const;

  virtual uint32_t Deserialize (Buffer::Iterator start);

105

  virtual uint32_t Deserialize (Buffer::Iterator start);

106

107

/**

108

   * \brief Enumeration listing the possible ARP types

109

*/

  enum ArpType_e {

110

  enum ArpType_e {

    ARP_TYPE_REQUEST = 1,

111

    ARP_TYPE_REQUEST = 1,

    ARP_TYPE_REPLY   = 2

112

    ARP_TYPE_REPLY   = 2

};

113

};

  uint16_t m_type;

114

  uint16_t m_type;           //!< type of the ICMP (ARP_TYPE_REQUEST)

  Address m_macSource;

115

  Address m_macSource;       //!< hardware source address

  Address m_macDest;

116

  Address m_macDest;         //!< hardware destination address

  Ipv4Address m_ipv4Source;

117

  Ipv4Address m_ipv4Source;  //!< IP source address

  Ipv4Address m_ipv4Dest;

118

  Ipv4Address m_ipv4Dest;    //!< IP destination address

};

119

};

120

} // namespace ns3

121

} // namespace ns3

(-)a/src/internet/model/arp-l3-protocol.h (-12 / +65 lines)

Lines 49-77	Link Here

class ArpL3Protocol : public Object

class ArpL3Protocol : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  static const uint16_t PROT_NUMBER;

  static const uint16_t PROT_NUMBER; //!< ARP protocol number (0x0806)

  ArpL3Protocol ();

  ArpL3Protocol ();

  virtual ~ArpL3Protocol ();

  virtual ~ArpL3Protocol ();

/**

   * \brief Set the node the ARP L3 protocol is associated with

   * \param node the node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

/**

   * \brief Create an ARP cache for the device/interface

   * \param device the NetDevice

   * \param interface the Ipv4Interface

   * \returns a smart pointer to the ARP cache

*/

  Ptr<ArpCache> CreateCache (Ptr<NetDevice> device, Ptr<Ipv4Interface> interface);

  Ptr<ArpCache> CreateCache (Ptr<NetDevice> device, Ptr<Ipv4Interface> interface);

/**

/**

   * \brief Receive a packet

   * \brief Receive a packet

   * \param device the source NetDevice

   * \param p the packet

   * \param protocol the protocol

   * \param from the source address

   * \param to the destination address

   * \param packetType type of packet (i.e., unicast, multicast, etc.)

*/

*/

  void Receive (Ptr<NetDevice> device, Ptr<const Packet> p, uint16_t protocol, const Address &from, const Address &to,

  void Receive (Ptr<NetDevice> device, Ptr<const Packet> p, uint16_t protocol, const Address &from, const Address &to,

                NetDevice::PacketType packetType);

                NetDevice::PacketType packetType);

/**

/**

   * \brief Perform an ARP lookup

   * \brief Perform an ARP lookup

   * \param p

   * \param p the packet

   * \param destination

   * \param destination destination IP address

   * \param device

   * \param device outgoing device

   * \param cache

   * \param cache ARP cache

   * \param hardwareDestination

   * \param hardwareDestination filled with the destination MAC address (if the entry exists)

   * \return

   * \return true if there is a matching ARP Entry

*/

*/

  bool Lookup (Ptr<Packet> p, Ipv4Address destination,

  bool Lookup (Ptr<Packet> p, Ipv4Address destination,

               Ptr<NetDevice> device,

               Ptr<NetDevice> device,

Lines 96-111	Link Here

*/

116

*/

  virtual void NotifyNewAggregate ();

117

  virtual void NotifyNewAggregate ();

private:

118

private:

  typedef std::list<Ptr<ArpCache> > CacheList;

119

  typedef std::list<Ptr<ArpCache> > CacheList; //!< container of the ARP caches

120

/**

121

   * \brief Copy constructor

122

123

   * Defined and unimplemented to avoid misuse

124

   * \param o

125

*/

100

  ArpL3Protocol (const ArpL3Protocol &o);

126

  ArpL3Protocol (const ArpL3Protocol &o);

127

/**

128

   * \brief Copy constructor

129

130

   * Defined and unimplemented to avoid misuse

131

   * \param o

132

   * \returns

133

*/

101

  ArpL3Protocol &operator = (const ArpL3Protocol &o);

134

  ArpL3Protocol &operator = (const ArpL3Protocol &o);

135

136

/**

137

   * \brief Finds the cache associated with a NetDevice

138

   * \param device the NetDevice

139

   * \returns the ARP cache, or null if no cache is found

140

*/

102

  Ptr<ArpCache> FindCache (Ptr<NetDevice> device);

141

  Ptr<ArpCache> FindCache (Ptr<NetDevice> device);

142

143

/**

144

   * \brief Send an ARP request to an host

145

   * \param cache the ARP cache to use

146

   * \param to the destination IP

147

*/

103

  void SendArpRequest (Ptr<const ArpCache>cache, Ipv4Address to);

148

  void SendArpRequest (Ptr<const ArpCache>cache, Ipv4Address to);

149

/**

150

   * \brief Send an ARP reply to an host

151

   * \param cache the ARP cache to use

152

   * \param myIp the source IP address

153

   * \param toIp the destination IP

154

   * \param toMac the destination MAC address

155

*/

104

  void SendArpReply (Ptr<const ArpCache> cache, Ipv4Address myIp, Ipv4Address toIp, Address toMac);

156

  void SendArpReply (Ptr<const ArpCache> cache, Ipv4Address myIp, Ipv4Address toIp, Address toMac);

105

  CacheList m_cacheList;

157

106

  Ptr<Node> m_node;

158

  CacheList m_cacheList; //!< ARP cache container

107

  TracedCallback<Ptr<const Packet> > m_dropTrace;

159

  Ptr<Node> m_node; //!< node the ARP L3 protocol is associated with

108

  Ptr<RandomVariableStream> m_requestJitter;

160

  TracedCallback<Ptr<const Packet> > m_dropTrace; //!< trace for packets dropped by ARP

161

  Ptr<RandomVariableStream> m_requestJitter; //!< jitter to de-sync ARP requests

109

162

110

};

163

};

111

164

(-)a/src/internet/model/candidate-queue.cc (+7 lines)

Lines 27-32	Link Here

namespace ns3 {

namespace ns3 {

/**

 * \brief Stream insertion operator.

 * \param os the reference to the output stream

 * \param t the SPFVertex type

 * \returns the reference to the output stream

*/

std::ostream&

std::ostream&

operator<< (std::ostream& os, const SPFVertex::VertexType& t)

operator<< (std::ostream& os, const SPFVertex::VertexType& t)

(-)a/src/internet/model/candidate-queue.h (-2 / +12 lines)

Lines 176-181	Link Here

176

 * prevent the compiler from slipping in incorrect versions that don't

176

 * prevent the compiler from slipping in incorrect versions that don't

177

 * properly deal with deep copies.

177

 * properly deal with deep copies.

178

 * \param sr object to assign

178

 * \param sr object to assign

179

 * \return copied object

179

*/

180

*/

180

  CandidateQueue& operator= (CandidateQueue& sr);

181

  CandidateQueue& operator= (CandidateQueue& sr);

181

/**

182

/**

Lines 185-197	Link Here

185

 * defined by this method. If v1 should be popped before v2, this

186

 * defined by this method. If v1 should be popped before v2, this

186

 * method return true; false otherwise

187

 * method return true; false otherwise

187

188

189

 * \param v1 first operand

190

 * \param v2 second operand

188

 * \return True if v1 should be popped before v2; false otherwise

191

 * \return True if v1 should be popped before v2; false otherwise

189

*/

192

*/

190

  static bool CompareSPFVertex (const SPFVertex* v1, const SPFVertex* v2);

193

  static bool CompareSPFVertex (const SPFVertex* v1, const SPFVertex* v2);

191

194

192

  typedef std::list<SPFVertex*> CandidateList_t;

195

  typedef std::list<SPFVertex*> CandidateList_t; //!< container of SPFVertex pointers

193

  CandidateList_t m_candidates;

196

  CandidateList_t m_candidates;  //!< SPFVertex candidates

194

197

198

/**

199

   * \brief Stream insertion operator.

200

201

   * \param os the reference to the output stream

202

   * \param q the CandidateQueue

203

   * \returns the reference to the output stream

204

*/

195

  friend std::ostream& operator<< (std::ostream& os, const CandidateQueue& q);

205

  friend std::ostream& operator<< (std::ostream& os, const CandidateQueue& q);

196

};

206

};

197

207

(-)a/src/internet/model/global-route-manager-impl.cc (+7 lines)

Lines 44-49	Link Here

namespace ns3 {

namespace ns3 {

/**

 * \brief Stream insertion operator.

 * \param os the reference to the output stream

 * \param exit the exit node

 * \returns the reference to the output stream

*/

std::ostream&

std::ostream&

operator<< (std::ostream& os, const SPFVertex::NodeExit_t& exit)

operator<< (std::ostream& os, const SPFVertex::NodeExit_t& exit)

(-)a/src/internet/model/global-route-manager-impl.h (-24 / +218 lines)

Lines 34-40	Link Here

namespace ns3 {

namespace ns3 {

const uint32_t SPF_INFINITY = 0xffffffff;

const uint32_t SPF_INFINITY = 0xffffffff; //!< "infinite" distance between nodes

class CandidateQueue;

class CandidateQueue;

class Ipv4GlobalRouting;

class Ipv4GlobalRouting;

Lines 298-304	Link Here

298

 * network represented by "this" SPFVertex.

298

 * network represented by "this" SPFVertex.

299

*/

299

*/

300

  void SetRootExitDirection (Ipv4Address nextHop, int32_t id = SPF_INFINITY);

300

  void SetRootExitDirection (Ipv4Address nextHop, int32_t id = SPF_INFINITY);

301

  typedef std::pair<Ipv4Address, int32_t> NodeExit_t;

301

302

  typedef std::pair<Ipv4Address, int32_t> NodeExit_t; //!< IPv4 / interface container for exit nodes.

303

302

/**

304

/**

303

 * @brief Set the IP address and outgoing interface index that should be used

305

 * @brief Set the IP address and outgoing interface index that should be used

304

 * to begin forwarding packets from the root SPFVertex to "this" SPFVertex.

306

 * to begin forwarding packets from the root SPFVertex to "this" SPFVertex.

Lines 532-553	Link Here

532

*/

534

*/

533

  bool IsVertexProcessed (void) const;

535

  bool IsVertexProcessed (void) const;

534

536

537

/**

538

   * @brief Clear the value of the VertexProcessed flag

539

540

   * Flag to note whether vertex has been processed in stage two of

541

   * SPF computation

542

*/

535

  void ClearVertexProcessed (void);

543

  void ClearVertexProcessed (void);

536

544

537

private:

545

private:

538

  VertexType m_vertexType;

546

  VertexType m_vertexType; //!< Vertex type

539

  Ipv4Address m_vertexId;

547

  Ipv4Address m_vertexId; //!< Vertex ID

540

  GlobalRoutingLSA* m_lsa;

548

  GlobalRoutingLSA* m_lsa; //!< Link State Advertisement

541

  uint32_t m_distanceFromRoot;

549

  uint32_t m_distanceFromRoot; //!< Distance from root node

542

  int32_t m_rootOif;

550

  int32_t m_rootOif; //!< root Output Interface

543

  Ipv4Address m_nextHop;

551

  Ipv4Address m_nextHop; //!< next hop

544

  typedef std::list< NodeExit_t > ListOfNodeExit_t;

552

  typedef std::list< NodeExit_t > ListOfNodeExit_t; //!< container of Exit nodes

545

  /// store the multiple root's exits for supporting ECMP

553

  ListOfNodeExit_t m_ecmpRootExits; //!< store the multiple root's exits for supporting ECMP

546

  ListOfNodeExit_t m_ecmpRootExits;

554

  typedef std::list<SPFVertex*> ListOfSPFVertex_t; //!< container of SPFVertexes

547

  typedef std::list<SPFVertex*> ListOfSPFVertex_t;

555

  ListOfSPFVertex_t m_parents; //!< parent list

548

  ListOfSPFVertex_t m_parents;

556

  ListOfSPFVertex_t m_children; //!< Children list

549

  ListOfSPFVertex_t m_children;

557

  bool m_vertexProcessed; //!< Flag to note whether vertex has been processed in stage two of SPF computation

550

  bool m_vertexProcessed;

551

558

552

/**

559

/**

553

 * @brief The SPFVertex copy construction is disallowed.  There's no need for

560

 * @brief The SPFVertex copy construction is disallowed.  There's no need for

Lines 561-568	Link Here

561

*/

568

*/

562

  SPFVertex& operator= (SPFVertex& v);

569

  SPFVertex& operator= (SPFVertex& v);

563

570

564

  //friend std::ostream& operator<< (std::ostream& os, const ListOfIf_t& ifs);

571

/**

565

  //friend std::ostream& operator<< (std::ostream& os, const ListOfAddr_t& addrs);

572

   * \brief Stream insertion operator.

573

574

   * \param os the reference to the output stream

575

   * \param vs a list of SPFVertexes

576

   * \returns the reference to the output stream

577

*/

566

  friend std::ostream& operator<< (std::ostream& os, const SPFVertex::ListOfSPFVertex_t& vs);

578

  friend std::ostream& operator<< (std::ostream& os, const SPFVertex::ListOfSPFVertex_t& vs);

567

};

579

};

568

580

Lines 662-677	Link Here

662

*/

674

*/

663

  void Initialize ();

675

  void Initialize ();

664

676

677

/**

678

   * @brief Look up the External Link State Advertisement associated with the given

679

   * index.

680

   * @internal

681

682

   * The external database map is searched for the given index and corresponding

683

   * GlobalRoutingLSA is returned.

684

685

   * @see GlobalRoutingLSA

686

   * @param index the index associated with the LSA.

687

   * @returns A pointer to the Link State Advertisement.

688

*/

665

  GlobalRoutingLSA* GetExtLSA (uint32_t index) const;

689

  GlobalRoutingLSA* GetExtLSA (uint32_t index) const;

690

/**

691

   * @brief Get the number of External Link State Advertisements.

692

   * @internal

693

694

   * @see GlobalRoutingLSA

695

   * @returns the number of External Link State Advertisements.

696

*/

666

  uint32_t GetNumExtLSAs () const;

697

  uint32_t GetNumExtLSAs () const;

667

698

668

699

669

private:

700

private:

670

  typedef std::map<Ipv4Address, GlobalRoutingLSA*> LSDBMap_t;

701

  typedef std::map<Ipv4Address, GlobalRoutingLSA*> LSDBMap_t; //!< container of IPv4 addresses / Link State Advertisements

671

  typedef std::pair<Ipv4Address, GlobalRoutingLSA*> LSDBPair_t;

702

  typedef std::pair<Ipv4Address, GlobalRoutingLSA*> LSDBPair_t; //!< pair of IPv4 addresses / Link State Advertisements

672

703

673

  LSDBMap_t m_database;

704

  LSDBMap_t m_database; //!< database of IPv4 addresses / Link State Advertisements

674

  std::vector<GlobalRoutingLSA*> m_extdatabase;

705

  std::vector<GlobalRoutingLSA*> m_extdatabase; //!< database of External Link State Advertisements

675

706

676

/**

707

/**

677

 * @brief GlobalRouteManagerLSDB copy construction is disallowed.  There's no

708

 * @brief GlobalRouteManagerLSDB copy construction is disallowed.  There's no

Lines 736-741	Link Here

736

/**

767

/**

737

 * @brief Debugging routine; call the core SPF from the unit tests

768

 * @brief Debugging routine; call the core SPF from the unit tests

738

 * @internal

769

 * @internal

770

 * @param root the root node to start calculations

739

*/

771

*/

740

  void DebugSPFCalculate (Ipv4Address root);

772

  void DebugSPFCalculate (Ipv4Address root);

741

773

Lines 754-775	Link Here

754

*/

786

*/

755

  GlobalRouteManagerImpl& operator= (GlobalRouteManagerImpl& srmi);

787

  GlobalRouteManagerImpl& operator= (GlobalRouteManagerImpl& srmi);

756

788

757

  SPFVertex* m_spfroot;

789

  SPFVertex* m_spfroot; //!< the root node

758

  GlobalRouteManagerLSDB* m_lsdb;

790

  GlobalRouteManagerLSDB* m_lsdb; //!< the Link State DataBase (LSDB) of the Global Route Manager

791

792

/**

793

   * \brief Test if a node is a stub, from an OSPF sense.

794

795

   * If there is only one link of type 1 or 2, then a default route

796

   * can safely be added to the next-hop router and SPF does not need

797

   * to be run

798

799

   * \param root the root node

800

   * \returns true if the node is a stub

801

*/

759

  bool CheckForStubNode (Ipv4Address root);

802

  bool CheckForStubNode (Ipv4Address root);

803

804

/**

805

   * \brief Calculate the shortest path first (SPF) tree

806

807

   * Equivalent to quagga ospf_spf_calculate

808

   * \param root the root node

809

*/

760

  void SPFCalculate (Ipv4Address root);

810

  void SPFCalculate (Ipv4Address root);

811

812

/**

813

   * \brief Process Stub nodes

814

815

   * Processing logic from RFC 2328, page 166 and quagga ospf_spf_process_stubs ()

816

   * stub link records will exist for point-to-point interfaces and for

817

   * broadcast interfaces for which no neighboring router can be found

818

819

   * \param v vertex to be processed

820

*/

761

  void SPFProcessStubs (SPFVertex* v);

821

  void SPFProcessStubs (SPFVertex* v);

822

823

/**

824

   * \brief Process Autonomous Systems (AS) External LSA

825

826

   * \param v vertex to be processed

827

   * \param extlsa external LSA

828

*/

762

  void ProcessASExternals (SPFVertex* v, GlobalRoutingLSA* extlsa);

829

  void ProcessASExternals (SPFVertex* v, GlobalRoutingLSA* extlsa);

763

  void SPFNext (SPFVertex*, CandidateQueue&);

830

831

/**

832

   * \brief Examine the links in v's LSA and update the list of candidates with any

833

   *        vertices not already on the list

834

835

   * \internal

836

837

   * This method is derived from quagga ospf_spf_next ().  See RFC2328 Section

838

   * 16.1 (2) for further details.

839

840

   * We're passed a parameter \a v that is a vertex which is already in the SPF

841

   * tree.  A vertex represents a router node.  We also get a reference to the

842

   * SPF candidate queue, which is a priority queue containing the shortest paths

843

   * to the networks we know about.

844

845

   * We examine the links in v's LSA and update the list of candidates with any

846

   * vertices not already on the list.  If a lower-cost path is found to a

847

   * vertex already on the candidate list, store the new (lower) cost.

848

849

   * \param v the vertex

850

   * \param candidate the SPF candidate queue

851

*/

852

  void SPFNext (SPFVertex* v, CandidateQueue& candidate);

853

854

/**

855

   * \brief Calculate nexthop from root through V (parent) to vertex W (destination)

856

   *        with given distance from root->W.

857

858

   * This method is derived from quagga ospf_nexthop_calculation() 16.1.1.

859

   * For now, this is greatly simplified from the quagga code

860

861

   * \param v the parent

862

   * \param w the destination

863

   * \param l the link record

864

   * \param distance the target distance

865

   * \returns 1 on success

866

*/

764

  int SPFNexthopCalculation (SPFVertex* v, SPFVertex* w,

867

  int SPFNexthopCalculation (SPFVertex* v, SPFVertex* w,

765

                             GlobalRoutingLinkRecord* l, uint32_t distance);

868

                             GlobalRoutingLinkRecord* l, uint32_t distance);

869

870

/**

871

   * \brief Adds a vertex to the list of children *in* each of its parents

872

873

   * Derived from quagga ospf_vertex_add_parents ()

874

875

   * This is a somewhat oddly named method (blame quagga).  Although you might

876

   * expect it to add a parent *to* something, it actually adds a vertex

877

   * to the list of children *in* each of its parents.

878

879

   * Given a pointer to a vertex, it links back to the vertex's parent that it

880

   * already has set and adds itself to that vertex's list of children.

881

882

   * \param v the vertex

883

*/

766

  void SPFVertexAddParent (SPFVertex* v);

884

  void SPFVertexAddParent (SPFVertex* v);

885

886

/**

887

   * \brief Search for a link between two vertexes.

888

889

   * This method is derived from quagga ospf_get_next_link ()

890

891

   * First search the Global Router Link Records of vertex \a v for one

892

   * representing a point-to point link to vertex \a w.

893

894

   * What is done depends on prev_link.  Contrary to appearances, prev_link just

895

   * acts as a flag here.  If prev_link is NULL, we return the first Global

896

   * Router Link Record we find that describes a point-to-point link from \a v

897

   * to \a w.  If prev_link is not NULL, we return a Global Router Link Record

898

   * representing a possible *second* link from \a v to \a w.

899

900

   * \param v first vertex

901

   * \param w second vertex

902

   * \param prev_link the previous link in the list

903

   * \returns the link's record

904

*/

767

  GlobalRoutingLinkRecord* SPFGetNextLink (SPFVertex* v, SPFVertex* w,

905

  GlobalRoutingLinkRecord* SPFGetNextLink (SPFVertex* v, SPFVertex* w,

768

                                           GlobalRoutingLinkRecord* prev_link);

906

                                           GlobalRoutingLinkRecord* prev_link);

907

908

/**

909

   * \brief Add a host route to the routing tables

910

911

912

   * This method is derived from quagga ospf_intra_add_router ()

913

914

   * This is where we are actually going to add the host routes to the routing

915

   * tables of the individual nodes.

916

917

   * The vertex passed as a parameter has just been added to the SPF tree.

918

   * This vertex must have a valid m_root_oid, corresponding to the outgoing

919

   * interface on the root router of the tree that is the first hop on the path

920

   * to the vertex.  The vertex must also have a next hop address, corresponding

921

   * to the next hop on the path to the vertex.  The vertex has an m_lsa field

922

   * that has some number of link records.  For each point to point link record,

923

   * the m_linkData is the local IP address of the link.  This corresponds to

924

   * a destination IP address, reachable from the root, to which we add a host

925

   * route.

926

927

   * \param v the vertex

928

929

*/

769

  void SPFIntraAddRouter (SPFVertex* v);

930

  void SPFIntraAddRouter (SPFVertex* v);

931

932

/**

933

   * \brief Add a transit to the routing tables

934

935

   * \param v the vertex

936

*/

770

  void SPFIntraAddTransit (SPFVertex* v);

937

  void SPFIntraAddTransit (SPFVertex* v);

938

939

/**

940

   * \brief Add a stub to the routing tables

941

942

   * \param l the global routing link record

943

   * \param v the vertex

944

*/

771

  void SPFIntraAddStub (GlobalRoutingLinkRecord *l, SPFVertex* v);

945

  void SPFIntraAddStub (GlobalRoutingLinkRecord *l, SPFVertex* v);

946

947

/**

948

   * \brief Add an external route to the routing tables

949

950

   * \param extlsa the external LSA

951

   * \param v the vertex

952

*/

772

  void SPFAddASExternal (GlobalRoutingLSA *extlsa, SPFVertex *v);

953

  void SPFAddASExternal (GlobalRoutingLSA *extlsa, SPFVertex *v);

954

955

/**

956

   * \brief Return the interface number corresponding to a given IP address and mask

957

958

   * This is a wrapper around GetInterfaceForPrefix(), but we first

959

   * have to find the right node pointer to pass to that function.

960

   * If no such interface is found, return -1 (note:  unit test framework

961

   * for routing assumes -1 to be a legal return value)

962

963

   * \param a the target IP address

964

   * \param amask the target subnet mask

965

   * \return the outgoing interface number

966

*/

773

  int32_t FindOutgoingInterfaceId (Ipv4Address a,

967

  int32_t FindOutgoingInterfaceId (Ipv4Address a,

774

                                   Ipv4Mask amask = Ipv4Mask ("255.255.255.255"));

968

                                   Ipv4Mask amask = Ipv4Mask ("255.255.255.255"));

775

};

969

};




 * proper position in the tree.
 */
  SPFStatus m_status;
  uint32_t m_node_id; //!< node ID
};

/**
 * \brief Stream insertion operator.
 *
 * \param os the reference to the output stream
 * \param lsa the LSA
 * \returns the reference to the output stream
 */
std::ostream& operator<< (std::ostream& os, GlobalRoutingLSA& lsa);

/**

class GlobalRouter : public Object
{
public:
  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
 */
  static TypeId GetTypeId (void);

/**

 */
  GlobalRouter ();

  /**
   * \brief Set the specific Global Routing Protocol to be used
   * \param routing the routing protocol
   */
  void SetRoutingProtocol (Ptr<Ipv4GlobalRouting> routing);

  /**
   * \brief Get the specific Global Routing Protocol used
   * \returns the routing protocol
   */
  Ptr<Ipv4GlobalRouting> GetRoutingProtocol (void);

/**


private:
  virtual ~GlobalRouter ();

  /**
   * \brief Clear list of LSAs
   */
  void ClearLSAs (void);

  /**
   * \brief Link through the given channel and find the net device that's on the other end.
   *
   * This only makes sense with a point-to-point channel.
   *
   * \param nd outgoing NetDevice
   * \param ch channel
   * \returns the NetDevice on the other end
   */
  Ptr<NetDevice> GetAdjacent (Ptr<NetDevice> nd, Ptr<Channel> ch) const;

  /**
   * \brief Given a node and a net device, find an IPV4 interface index that corresponds
   *        to that net device.
   *
   * This function may fail for various reasons.  If a node
   * does not have an internet stack (for example if it is a bridge) we won't have
   * an IPv4 at all.  If the node does have a stack, but the net device in question
   * is bridged, there will not be an interface associated directly with the device.
   *
   * \param node the node
   * \param nd outgoing NetDevice
   * \param index the IPV4 interface index
   * \returns true on success
   */
  bool FindInterfaceForDevice (Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;

  /**
   * \brief Finds a designated router
   *
   * Given a local net device, we need to walk the channel to which the net device is
   * attached and look for nodes with GlobalRouter interfaces on them (one of them
   * will be us).  Of these, the router with the lowest IP address on the net device
   * connecting to the channel becomes the designated router for the link.
   *
   * \param ndLocal local NetDevice to scan
   * \param allowRecursion Recursively look for routers down bridge port
   * \returns the IP address of the designated router
   */
  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal, bool allowRecursion) const;

  /**
   * \brief Checks for the presence of another router on the NetDevice
   *
   * Given a node and an attached net device, take a look off in the channel to
   * which the net device is attached and look for a node on the other side
   * that has a GlobalRouter interface aggregated.  Life gets more complicated
   * when there is a bridged net device on the other side.
   *
   * \param nd NetDevice to scan
   * \param allowRecursion Recursively look for routers down bridge port
   * \returns true if a router is found
   */
  bool AnotherRouterOnLink (Ptr<NetDevice> nd, bool allowRecursion) const;

  /**
   * \brief Process a generic broadcast link
   *
   * \param nd the NetDevice
   * \param pLSA the Global LSA
   * \param c the returned NetDevice container
   */
  void ProcessBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

  /**
   * \brief Process a single broadcast link
   *
   * \param nd the NetDevice
   * \param pLSA the Global LSA
   * \param c the returned NetDevice container
   */
  void ProcessSingleBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

  /**
   * \brief Process a bridged broadcast link
   *
   * \param nd the NetDevice
   * \param pLSA the Global LSA
   * \param c the returned NetDevice container
   */
  void ProcessBridgedBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

  /**
   * \brief Process a point to point link
   *
   * \param ndLocal the NetDevice
   * \param pLSA the Global LSA
   */
  void ProcessPointToPointLink (Ptr<NetDevice> ndLocal, GlobalRoutingLSA *pLSA);

  /**
   * \brief Build one NetworkLSA for each net device talking to a network that we are the
   * designated router for.
   *
   * \param c the devices.
   */
  void BuildNetworkLSAs (NetDeviceContainer c);

  /**
   * \brief Decide whether or not a given net device is being bridged by a BridgeNetDevice.
   *
   * \param nd the NetDevice
   * \returns the BridgeNetDevice smart pointer or null if not found
   */
  Ptr<BridgeNetDevice> NetDeviceIsBridged (Ptr<NetDevice> nd) const;


  typedef std::list<GlobalRoutingLSA*> ListOfLSAs_t; //!< container for the GlobalRoutingLSAs
  ListOfLSAs_t m_LSAs; //!< database of GlobalRoutingLSAs

  Ipv4Address m_routerId; //!< router ID (its IPv4 address)
  Ptr<Ipv4GlobalRouting> m_routingProtocol; //!< the Ipv4GlobalRouting in use

  typedef std::list<Ipv4RoutingTableEntry *> InjectedRoutes; //!< container of Ipv4RoutingTableEntry
  typedef std::list<Ipv4RoutingTableEntry *>::const_iterator InjectedRoutesCI; //!< Const Iterator to container of Ipv4RoutingTableEntry
  typedef std::list<Ipv4RoutingTableEntry *>::iterator InjectedRoutesI; //!< Iterator to container of Ipv4RoutingTableEntry
  InjectedRoutes m_injectedRoutes; //!< Routes we are exporting

  // inherited from Object
  virtual void DoDispose (void);

(-)a/src/internet/model/icmpv4-l4-protocol.h (-5 / +98 lines)

Lines 14-35	Link Here

class Icmpv4L4Protocol : public IpL4Protocol

class Icmpv4L4Protocol : public IpL4Protocol

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  static const uint8_t PROT_NUMBER;

  static const uint8_t PROT_NUMBER; //!< ICMP protocol number (0x1)

  Icmpv4L4Protocol ();

  Icmpv4L4Protocol ();

  virtual ~Icmpv4L4Protocol ();

  virtual ~Icmpv4L4Protocol ();

/**

   * \brief Set the node the protocol is associated with.

   * \param node the node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

/**

   * Get the protocol number

   * \returns the protocol number

*/

  static uint16_t GetStaticProtocolNumber (void);

  static uint16_t GetStaticProtocolNumber (void);

/**

   * Get the protocol number

   * \returns the protocol number

*/

  virtual int GetProtocolNumber (void) const;

  virtual int GetProtocolNumber (void) const;

/**

/**

   * \brief Receive method.

   * \brief Receive method.

   * \param p the packet

   * \param p the packet

   * \param header the IPv4 header

   * \param header the IPv4 header

   * \param interface the interface from which the packet is coming

   * \param incomingInterface the interface from which the packet is coming

   * \returns the receive status

*/

*/

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

                                               Ipv4Header const &header,

                                               Ipv4Header const &header,

Lines 39-52	Link Here

   * \brief Receive method.

   * \brief Receive method.

   * \param p the packet

   * \param p the packet

   * \param header the IPv6 header

   * \param header the IPv6 header

   * \param interface the interface from which the packet is coming

   * \param incomingInterface the interface from which the packet is coming

   * \returns the receive status

*/

*/

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

                                               Ipv6Header const &header,

                                               Ipv6Header const &header,

                                               Ptr<Ipv6Interface> incomingInterface);

                                               Ptr<Ipv6Interface> incomingInterface);

/**

   * \brief Send a Destination Unreachable - Fragmentation needed ICMP error

   * \param header the original IP header

   * \param orgData the original packet

   * \param nextHopMtu the next hop MTU

*/

  void SendDestUnreachFragNeeded (Ipv4Header header, Ptr<const Packet> orgData, uint16_t nextHopMtu);

  void SendDestUnreachFragNeeded (Ipv4Header header, Ptr<const Packet> orgData, uint16_t nextHopMtu);

/**

   * \brief Send a Time Exceeded ICMP error

   * \param header the original IP header

   * \param orgData the original packet

*/

  void SendTimeExceededTtl (Ipv4Header header, Ptr<const Packet> orgData);

  void SendTimeExceededTtl (Ipv4Header header, Ptr<const Packet> orgData);

/**

   * \brief Send a Time Exceeded ICMP error

   * \param header the original IP header

   * \param orgData the original packet

*/

  void SendDestUnreachPort (Ipv4Header header, Ptr<const Packet> orgData);

  void SendDestUnreachPort (Ipv4Header header, Ptr<const Packet> orgData);

  // From IpL4Protocol

  // From IpL4Protocol

Lines 62-91	Link Here

*/

*/

  virtual void NotifyNewAggregate ();

100

  virtual void NotifyNewAggregate ();

private:

101

private:

102

/**

103

   * \brief Handles an incoming ICMP Echo packet

104

   * \param p the packet

105

   * \param header the IP header

106

   * \param source the source address

107

   * \param destination the destination address

108

*/

  void HandleEcho (Ptr<Packet> p,

109

  void HandleEcho (Ptr<Packet> p,

                   Icmpv4Header header,

110

                   Icmpv4Header header,

                   Ipv4Address source,

111

                   Ipv4Address source,

                   Ipv4Address destination);

112

                   Ipv4Address destination);

113

/**

114

   * \brief Handles an incoming ICMP Destination Unreachable packet

115

   * \param p the packet

116

   * \param header the IP header

117

   * \param source the source address

118

   * \param destination the destination address

119

*/

  void HandleDestUnreach (Ptr<Packet> p,

120

  void HandleDestUnreach (Ptr<Packet> p,

                          Icmpv4Header header,

121

                          Icmpv4Header header,

                          Ipv4Address source,

122

                          Ipv4Address source,

                          Ipv4Address destination);

123

                          Ipv4Address destination);

124

/**

125

   * \brief Handles an incoming ICMP Time Exceeded packet

126

   * \param p the packet

127

   * \param icmp the ICMP header

128

   * \param source the source address

129

   * \param destination the destination address

130

*/

  void HandleTimeExceeded (Ptr<Packet> p,

131

  void HandleTimeExceeded (Ptr<Packet> p,

                           Icmpv4Header icmp,

132

                           Icmpv4Header icmp,

                           Ipv4Address source,

133

                           Ipv4Address source,

                           Ipv4Address destination);

134

                           Ipv4Address destination);

135

/**

136

   * \brief Send an ICMP Destination Unreachable packet

137

138

   * \param header the original IP header

139

   * \param orgData the original packet

140

   * \param code the ICMP code

141

   * \param nextHopMtu the next hop MTU

142

*/

  void SendDestUnreach (Ipv4Header header, Ptr<const Packet> orgData,

143

  void SendDestUnreach (Ipv4Header header, Ptr<const Packet> orgData,

                        uint8_t code, uint16_t nextHopMtu);

144

                        uint8_t code, uint16_t nextHopMtu);

145

/**

146

   * \brief Send a generic ICMP packet

147

148

   * \param packet the packet

149

   * \param dest the destination

150

   * \param type the ICMP type

151

   * \param code the ICMP code

152

*/

  void SendMessage (Ptr<Packet> packet, Ipv4Address dest, uint8_t type, uint8_t code);

153

  void SendMessage (Ptr<Packet> packet, Ipv4Address dest, uint8_t type, uint8_t code);

154

/**

155

   * \brief Send a generic ICMP packet

156

157

   * \param packet the packet

158

   * \param source the source

159

   * \param dest the destination

160

   * \param type the ICMP type

161

   * \param code the ICMP code

162

   * \param route the route to be used

163

*/

  void SendMessage (Ptr<Packet> packet, Ipv4Address source, Ipv4Address dest, uint8_t type, uint8_t code, Ptr<Ipv4Route> route);

164

  void SendMessage (Ptr<Packet> packet, Ipv4Address source, Ipv4Address dest, uint8_t type, uint8_t code, Ptr<Ipv4Route> route);

165

/**

166

   * \brief Forward the message to an L4 protocol

167

168

   * \param source the source

169

   * \param icmp the ICMP header

170

   * \param info info data (e.g., the target MTU)

171

   * \param ipHeader the IP header carried by ICMP

172

   * \param payload payload chunk carried by ICMP

173

*/

  void Forward (Ipv4Address source, Icmpv4Header icmp,

174

  void Forward (Ipv4Address source, Icmpv4Header icmp,

                uint32_t info, Ipv4Header ipHeader,

175

                uint32_t info, Ipv4Header ipHeader,

                const uint8_t payload[8]);

176

                const uint8_t payload[8]);

177

  virtual void DoDispose (void);

178

  virtual void DoDispose (void);

179

  Ptr<Node> m_node;

180

  Ptr<Node> m_node; //!< the node this protocol is associated with

  IpL4Protocol::DownTargetCallback m_downTarget;

181

  IpL4Protocol::DownTargetCallback m_downTarget; //!< callback to Ipv4::Send

};

182

};

183

} // namespace ns3

184

} // namespace ns3

(-)a/src/internet/model/icmpv4.h (-12 / +120 lines)

Lines 40-55	Link Here

    TIME_EXCEEDED = 11

    TIME_EXCEEDED = 11

};

};

/**

   * Enables ICMP Checksum calculation

*/

  void EnableChecksum (void);

  void EnableChecksum (void);

/**

   * Set ICMP type

   * \param type the ICMP type

*/

  void SetType (uint8_t type);

  void SetType (uint8_t type);

/**

   * Set ICMP code

   * \param code the ICMP code

*/

  void SetCode (uint8_t code);

  void SetCode (uint8_t code);

/**

   * Get ICMP type

   * \returns the ICMP type

*/

  uint8_t GetType (void) const;

  uint8_t GetType (void) const;

/**

   * Get ICMP code

   * \returns the ICMP code

*/

  uint8_t GetCode (void) const;

  uint8_t GetCode (void) const;

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Icmpv4Header ();

  Icmpv4Header ();

  virtual ~Icmpv4Header ();

  virtual ~Icmpv4Header ();

  virtual TypeId GetInstanceTypeId (void) const;

  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (Buffer::Iterator start) const;

  virtual void Serialize (Buffer::Iterator start) const;

Lines 57-79	Link Here

  virtual void Print (std::ostream &os) const;

  virtual void Print (std::ostream &os) const;

private:

private:

  uint8_t m_type;

  uint8_t m_type; //!< ICMP type

  uint8_t m_code;

  uint8_t m_code; //!< ICMP code

  bool m_calcChecksum;

  bool m_calcChecksum;  //!< true if checksum is calculated

};

};

class Icmpv4Echo : public Header

class Icmpv4Echo : public Header

public:

public:

/**

   * \brief Set the Echo identifier

   * \param id the identifier

*/

  void SetIdentifier (uint16_t id);

  void SetIdentifier (uint16_t id);

/**

100

   * \brief Set the Echo sequence number

101

   * \param seq the sequence number

102

*/

  void SetSequenceNumber (uint16_t seq);

103

  void SetSequenceNumber (uint16_t seq);

104

/**

105

   * \brief Set the Echo data

106

   * \param data the data

107

*/

  void SetData (Ptr<const Packet> data);

108

  void SetData (Ptr<const Packet> data);

109

/**

110

   * \brief Get the Echo identifier

111

   * \returns the identifier

112

*/

  uint16_t GetIdentifier (void) const;

113

  uint16_t GetIdentifier (void) const;

114

/**

115

   * \brief Get the Echo sequence number

116

   * \returns the sequence number

117

*/

  uint16_t GetSequenceNumber (void) const;

118

  uint16_t GetSequenceNumber (void) const;

119

/**

120

   * \brief Get the Echo data size

121

   * \returns the data size

122

*/

  uint32_t GetDataSize (void) const;

123

  uint32_t GetDataSize (void) const;

124

/**

125

   * \brief Get the Echo data

126

   * \param payload the data (filled)

127

   * \returns the data length

128

*/

  uint32_t GetData (uint8_t payload[]) const;

129

  uint32_t GetData (uint8_t payload[]) const;

130

131

132

/**

133

   * Get ICMP type

134

   * \returns the ICMP type

135

*/

  static TypeId GetTypeId (void);

136

  static TypeId GetTypeId (void);

  Icmpv4Echo ();

137

  Icmpv4Echo ();

  virtual ~Icmpv4Echo ();

138

  virtual ~Icmpv4Echo ();

Lines 83-92	Link Here

  virtual uint32_t Deserialize (Buffer::Iterator start);

142

  virtual uint32_t Deserialize (Buffer::Iterator start);

  virtual void Print (std::ostream &os) const;

143

  virtual void Print (std::ostream &os) const;

private:

144

private:

  uint16_t m_identifier;

145

  uint16_t m_identifier; //!< identifier

  uint16_t m_sequence;

146

  uint16_t m_sequence;   //!< sequence number

  uint8_t *m_data;

147

  uint8_t *m_data;       //!< data

  uint32_t m_dataSize;

148

  uint32_t m_dataSize;   //!< data size

};

149

};

150

class Icmpv4DestinationUnreachable : public Header

151

class Icmpv4DestinationUnreachable : public Header

Lines 100-116	Link Here

100

    FRAG_NEEDED = 4,

159

    FRAG_NEEDED = 4,

101

    SOURCE_ROUTE_FAILED = 5

160

    SOURCE_ROUTE_FAILED = 5

102

};

161

};

162

163

/**

164

   * Get ICMP type

165

   * \returns the ICMP type

166

*/

103

  static TypeId GetTypeId (void);

167

  static TypeId GetTypeId (void);

104

  Icmpv4DestinationUnreachable ();

168

  Icmpv4DestinationUnreachable ();

105

  virtual ~Icmpv4DestinationUnreachable ();

169

  virtual ~Icmpv4DestinationUnreachable ();

106

170

171

/**

172

   * \brief Set the next hop MTU

173

   * \param mtu the MTU

174

*/

107

  void SetNextHopMtu (uint16_t mtu);

175

  void SetNextHopMtu (uint16_t mtu);

176

/**

177

   * \brief Get the next hop MTU

178

   * \returns the MTU

179

*/

108

  uint16_t GetNextHopMtu (void) const;

180

  uint16_t GetNextHopMtu (void) const;

109

181

182

/**

183

   * \brief Set the ICMP carried data

184

   * \param data the data

185

*/

110

  void SetData (Ptr<const Packet> data);

186

  void SetData (Ptr<const Packet> data);

187

/**

188

   * \brief Set the ICMP carried IPv4 header

189

   * \param header the header

190

*/

111

  void SetHeader (Ipv4Header header);

191

  void SetHeader (Ipv4Header header);

112

192

193

/**

194

   * \brief Get the ICMP carried data

195

   * \param payload the data (filled)

196

*/

113

  void GetData (uint8_t payload[8]) const;

197

  void GetData (uint8_t payload[8]) const;

198

/**

199

   * \brief Get the ICMP carried IPv4 header

200

   * \returns the header

201

*/

114

  Ipv4Header GetHeader (void) const;

202

  Ipv4Header GetHeader (void) const;

115

203

116

private:

204

private:

Lines 120-128	Link Here

120

  virtual uint32_t Deserialize (Buffer::Iterator start);

208

  virtual uint32_t Deserialize (Buffer::Iterator start);

121

  virtual void Print (std::ostream &os) const;

209

  virtual void Print (std::ostream &os) const;

122

private:

210

private:

123

  uint16_t m_nextHopMtu;

211

  uint16_t m_nextHopMtu; //!< next hop MTU

124

  Ipv4Header m_header;

212

  Ipv4Header m_header;   //!< carried IPv4 header

125

  uint8_t m_data[8];

213

  uint8_t m_data[8];     //!< carried data

126

};

214

};

127

215

128

216

Lines 134-145	Link Here

134

    FRAGMENT_REASSEMBLY = 1

222

    FRAGMENT_REASSEMBLY = 1

135

};

223

};

136

224

225

/**

226

   * \brief Get the ICMP carried data

227

   * \param data the data

228

*/

137

  void SetData (Ptr<const Packet> data);

229

  void SetData (Ptr<const Packet> data);

230

/**

231

   * \brief Set the ICMP carried IPv4 header

232

   * \param header the header

233

*/

138

  void SetHeader (Ipv4Header header);

234

  void SetHeader (Ipv4Header header);

139

235

236

/**

237

   * \brief Get the ICMP carried data

238

   * \param payload the data (filled)

239

*/

140

  void GetData (uint8_t payload[8]) const;

240

  void GetData (uint8_t payload[8]) const;

241

/**

242

   * \brief Get the ICMP carried IPv4 header

243

   * \returns the header

244

*/

141

  Ipv4Header GetHeader (void) const;

245

  Ipv4Header GetHeader (void) const;

142

246

247

/**

248

   * Get ICMP type

249

   * \returns the ICMP type

250

*/

143

  static TypeId GetTypeId (void);

251

  static TypeId GetTypeId (void);

144

  Icmpv4TimeExceeded ();

252

  Icmpv4TimeExceeded ();

145

  virtual ~Icmpv4TimeExceeded ();

253

  virtual ~Icmpv4TimeExceeded ();

Lines 150-157	Link Here

150

  virtual void Print (std::ostream &os) const;

258

  virtual void Print (std::ostream &os) const;

151

259

152

private:

260

private:

153

  Ipv4Header m_header;

261

  Ipv4Header m_header;   //!< carried IPv4 header

154

  uint8_t m_data[8];

262

  uint8_t m_data[8];     //!< carried data

155

};

263

};

156

264

157

} // namespace ns3

265

} // namespace ns3

(-)a/src/internet/model/icmpv6-l4-protocol.h (-3 / +9 lines)

Lines 338-343	Link Here

338

   * \param p the packet

338

   * \param p the packet

339

   * \param header the IPv4 header

339

   * \param header the IPv4 header

340

   * \param interface the interface from which the packet is coming

340

   * \param interface the interface from which the packet is coming

341

   * \returns the receive status

341

*/

342

*/

342

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

343

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

343

                                               Ipv4Header const &header,

344

                                               Ipv4Header const &header,

Lines 348-353	Link Here

348

   * \param p the packet

349

   * \param p the packet

349

   * \param header the IPv6 header

350

   * \param header the IPv6 header

350

   * \param interface the interface from which the packet is coming

351

   * \param interface the interface from which the packet is coming

352

   * \returns the receive status

351

*/

353

*/

352

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

354

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

353

                                               Ipv6Header const &header,

355

                                               Ipv6Header const &header,

Lines 363-373	Link Here

363

365

364

/**

366

/**

365

   * \brief Lookup in the ND cache for the IPv6 address

367

   * \brief Lookup in the ND cache for the IPv6 address

368

369

   * \note Unlike other Lookup method, it does not send NS request!

370

366

   * \param dst destination address

371

   * \param dst destination address

367

   * \param device device

372

   * \param device device

368

   * \param cache the neighbor cache

373

   * \param cache the neighbor cache

369

   * \param hardwareDestination hardware address

374

   * \param hardwareDestination hardware address

370

   * \note Unlike other Lookup method, it does not send NS request!

375

   * \return true if the address is in the ND cache, the hardwareDestination is updated.

371

*/

376

*/

372

  bool Lookup (Ipv6Address dst, Ptr<NetDevice> device, Ptr<NdiscCache> cache, Address* hardwareDestination);

377

  bool Lookup (Ipv6Address dst, Ptr<NetDevice> device, Ptr<NdiscCache> cache, Address* hardwareDestination);

373

378

Lines 423-429	Link Here

423

  virtual void DoDispose ();

428

  virtual void DoDispose ();

424

429

425

private:

430

private:

426

  typedef std::list<Ptr<NdiscCache> > CacheList;

431

  typedef std::list<Ptr<NdiscCache> > CacheList; //!< container of NdiscCaches

427

432

428

/**

433

/**

429

   * \brief The node.

434

   * \brief The node.

Lines 559-564	Link Here

559

/**

564

/**

560

   * \brief Get the cache corresponding to the device.

565

   * \brief Get the cache corresponding to the device.

561

   * \param device the device

566

   * \param device the device

567

   * \returns the NdiscCache associated with the device

562

*/

568

*/

563

  Ptr<NdiscCache> FindCache (Ptr<NetDevice> device);

569

  Ptr<NdiscCache> FindCache (Ptr<NetDevice> device);

564

570

Lines 569-575	Link Here

569

  virtual IpL4Protocol::DownTargetCallback GetDownTarget (void) const;

575

  virtual IpL4Protocol::DownTargetCallback GetDownTarget (void) const;

570

  virtual IpL4Protocol::DownTargetCallback6 GetDownTarget6 (void) const;

576

  virtual IpL4Protocol::DownTargetCallback6 GetDownTarget6 (void) const;

571

577

572

  IpL4Protocol::DownTargetCallback6 m_downTarget;

578

  IpL4Protocol::DownTargetCallback6 m_downTarget; //!< callback to Ipv6::Send

573

579

574

};

580

};

575

581

(-)a/src/internet/model/ip-l4-protocol.h (-12 / +25 lines)

Lines 47-52	Link Here

class IpL4Protocol : public Object

class IpL4Protocol : public Object

public:

public:

/**

   * \brief Rx status codes

*/

  enum RxStatus {

  enum RxStatus {

    RX_OK,

    RX_OK,

    RX_CSUM_FAILED,

    RX_CSUM_FAILED,

Lines 54-59	Link Here

    RX_ENDPOINT_UNREACH

    RX_ENDPOINT_UNREACH

};

};

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual ~IpL4Protocol ();

  virtual ~IpL4Protocol ();

Lines 64-93	Link Here

  virtual int GetProtocolNumber (void) const = 0;

  virtual int GetProtocolNumber (void) const = 0;

/**

/**

   * \brief Called from lower-level layers to send the packet up in the stack.

   * \param p packet to forward up

   * \param p packet to forward up

   * \param header IPv4 Header information

   * \param header IPv4 Header information

   * \param incomingInterface the Ipv4Interface on which the packet arrived

   * \param incomingInterface the Ipv4Interface on which the packet arrived

   * \returns Rx status code

   * Called from lower-level layers to send the packet up

   * in the stack.

*/

*/

  virtual enum RxStatus Receive (Ptr<Packet> p,

  virtual enum RxStatus Receive (Ptr<Packet> p,

                                 Ipv4Header const &header,

                                 Ipv4Header const &header,

                                 Ptr<Ipv4Interface> incomingInterface) = 0;

                                 Ptr<Ipv4Interface> incomingInterface) = 0;

/**

/**

   * \brief Called from lower-level layers to send the packet up in the stack.

   * \param p packet to forward up

   * \param p packet to forward up

   * \param header IPv6 Header information

   * \param header IPv6 Header information

   * \param incomingInterface the Ipv6Interface on which the packet arrived

   * \param incomingInterface the Ipv6Interface on which the packet arrived

   * \returns Rx status code

   * Called from lower-level layers to send the packet up

   * in the stack.

*/

*/

  virtual enum RxStatus Receive (Ptr<Packet> p,

  virtual enum RxStatus Receive (Ptr<Packet> p,

                                 Ipv6Header const &header,

                                 Ipv6Header const &header,

                                 Ptr<Ipv6Interface> incomingInterface) = 0;

                                 Ptr<Ipv6Interface> incomingInterface) = 0;

/**

/**

   * \brief Called from lower-level layers to send the ICMP packet up in the stack.

   * \param icmpSource the source address of the icmp message

   * \param icmpSource the source address of the icmp message

   * \param icmpTtl the ttl of the icmp message

   * \param icmpTtl the ttl of the icmp message

   * \param icmpType the 'type' field of the icmp message

   * \param icmpType the 'type' field of the icmp message

Lines 98-104	Link Here

   *        the icmp message

104

   *        the icmp message

   * \param payloadDestination the destination address of the packet which

105

   * \param payloadDestination the destination address of the packet which

100

   *        triggered the icmp message.

106

   *        triggered the icmp message.

101

   * \param payload the first 8 bytes of the udp header of the packet

107

   * \param payload the first 8 bytes of the packet payload

102

   *        which triggered the icmp message.

108

   *        which triggered the icmp message.

103

*/

109

*/

104

  virtual void ReceiveIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

110

  virtual void ReceiveIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

Lines 108-113	Link Here

108

114

109

115

110

/**

116

/**

117

   * \brief Called from lower-level layers to send the ICMPv6 packet up in the stack.

111

   * \param icmpSource the source address of the icmp message

118

   * \param icmpSource the source address of the icmp message

112

   * \param icmpTtl the ttl of the icmp message

119

   * \param icmpTtl the ttl of the icmp message

113

   * \param icmpType the 'type' field of the icmp message

120

   * \param icmpType the 'type' field of the icmp message

Lines 118-124	Link Here

118

   *        the icmp message

125

   *        the icmp message

119

   * \param payloadDestination the destination address of the packet which

126

   * \param payloadDestination the destination address of the packet which

120

   *        triggered the icmp message.

127

   *        triggered the icmp message.

121

   * \param payload the first 8 bytes of the udp header of the packet

128

   * \param payload the first 8 bytes of the packet payload

122

   *        which triggered the icmp message.

129

   *        which triggered the icmp message.

123

*/

130

*/

124

  virtual void ReceiveIcmp (Ipv6Address icmpSource, uint8_t icmpTtl,

131

  virtual void ReceiveIcmp (Ipv6Address icmpSource, uint8_t icmpTtl,

Lines 126-137	Link Here

126

                            Ipv6Address payloadSource, Ipv6Address payloadDestination,

133

                            Ipv6Address payloadSource, Ipv6Address payloadDestination,

127

                            const uint8_t payload[8]);

134

                            const uint8_t payload[8]);

128

135

136

/**

137

   * \brief callback to send packets over IPv4

138

*/

129

  typedef Callback<void,Ptr<Packet>, Ipv4Address, Ipv4Address, uint8_t, Ptr<Ipv4Route> > DownTargetCallback;

139

  typedef Callback<void,Ptr<Packet>, Ipv4Address, Ipv4Address, uint8_t, Ptr<Ipv4Route> > DownTargetCallback;

140

/**

141

   * \brief callback to send packets over IPv6

142

*/

130

  typedef Callback<void,Ptr<Packet>, Ipv6Address, Ipv6Address, uint8_t, Ptr<Ipv6Route> > DownTargetCallback6;

143

  typedef Callback<void,Ptr<Packet>, Ipv6Address, Ipv6Address, uint8_t, Ptr<Ipv6Route> > DownTargetCallback6;

131

144

132

/**

145

/**

133

   * This method allows a caller to set the current down target callback

146

   * This method allows a caller to set the current down target callback

134

   * set for this L4 protocol

147

   * set for this L4 protocol (IPv4 case)

135

148

136

   * \param cb current Callback for the L4 protocol

149

   * \param cb current Callback for the L4 protocol

137

*/

150

*/

Lines 139-145	Link Here

139

152

140

/**

153

/**

141

   * This method allows a caller to set the current down target callback

154

   * This method allows a caller to set the current down target callback

142

   * set for this L4 protocol

155

   * set for this L4 protocol (IPv6 case)

143

156

144

   * \param cb current Callback for the L4 protocol

157

   * \param cb current Callback for the L4 protocol

145

*/

158

*/

Lines 147-153	Link Here

147

160

148

/**

161

/**

149

   * This method allows a caller to get the current down target callback

162

   * This method allows a caller to get the current down target callback

150

   * set for this L4 protocol, for

163

   * set for this L4 protocol (IPv4 case)

151

164

152

   * \return current Callback for the L4 protocol

165

   * \return current Callback for the L4 protocol

153

*/

166

*/

Lines 155-161	Link Here

155

168

156

/**

169

/**

157

   * This method allows a caller to get the current down target callback

170

   * This method allows a caller to get the current down target callback

158

   * set for this L4 protocol, for

171

   * set for this L4 protocol (IPv6 case)

159

172

160

   * \return current Callback for the L4 protocol

173

   * \return current Callback for the L4 protocol

161

*/

174

*/





namespace ns3 {

/**
 * \internal
 * \ingroup address
 *
 * \brief Implementation class of Ipv4AddressGenerator
 * This generator assigns addresses sequentially from a provided
 * network address; used in topology code. It also keeps track of all
 * addresses assigned to perform duplicate detection.
 */
class Ipv4AddressGeneratorImpl
{
public:
  Ipv4AddressGeneratorImpl ();
  virtual ~Ipv4AddressGeneratorImpl ();

  /**
   * \internal
   * \brief Initialise the base network, mask and address for the generator
   *
   * The first call to NextAddress() or GetAddress() will return the
   * value passed in.
   *
   * \param net The network for the base Ipv4Address
   * \param mask The network mask of the base Ipv4Address
   * \param addr The base address used for initialization
   */
  void Init (const Ipv4Address net, const Ipv4Mask mask, 
             const Ipv4Address addr);

  /**
   * \internal
   * \brief Get the current network of the given Ipv4Mask
   *
   * Does not change the internal state; this just peeks at the current
   * network
   *
   * \param mask The Ipv4Mask for the current network
   * \returns the IPv4 address of the current network
   */
  Ipv4Address GetNetwork (const Ipv4Mask mask) const;

  /**
   * \internal
   * \brief Get the next network according to the given Ipv4Mask
   *
   * This operation is a pre-increment, meaning that the internal state
   * is changed before returning the new network address.
   *
   * This also resets the address to the base address that was
   * used for initialization.
   *
   * \param mask The Ipv4Mask used to set the next network
   * \returns the IPv4 address of the next network
   */
  Ipv4Address NextNetwork (const Ipv4Mask mask);

  /**
   * \internal
   * \brief Set the address for the given mask
   *
   * \param addr The address to set for the current mask
   * \param mask The Ipv4Mask whose address is to be set
   */
  void InitAddress (const Ipv4Address addr, const Ipv4Mask mask);

  /**
   * \internal
   * \brief Allocate the next Ipv4Address for the configured network and mask
   *
   * This operation is a post-increment, meaning that the first address
   * allocated will be the one that was initially configured.
   *
   * \param mask The Ipv4Mask for the current network
   * \returns the IPv4 address
   */
  Ipv4Address NextAddress (const Ipv4Mask mask);

  /**
   * \internal
   * \brief Get the Ipv4Address that will be allocated upon NextAddress ()
   *
   * Does not change the internal state; just is used to peek the next
   * address that will be allocated upon NextAddress ()
   *
   * \param mask The Ipv4Mask for the current network
   * \returns the IPv4 address
   */
  Ipv4Address GetAddress (const Ipv4Mask mask) const;

  /**
   * \internal
   * \brief Reset the networks and Ipv4Address to zero
   */
  void Reset (void);

  /**
   * \internal
   * \brief Add the Ipv4Address to the list of IPv4 entries
   *
   * Typically, this is used by external address allocators that want
   * to make use of this class's ability to track duplicates.  AddAllocated
   * is always called internally for any address generated by NextAddress ()
   *
   * \param addr The Ipv4Address to be added to the list of Ipv4 entries
   * \returns true on success
   */
  bool AddAllocated (const Ipv4Address addr);

  /**
   * \internal
   * \brief Used to turn off fatal errors and assertions, for testing
   */
  void TestMode (void);
private:
  static const uint32_t N_BITS = 32;  //!< /internal the number of bits in the address
  static const uint32_t MOST_SIGNIFICANT_BIT = 0x80000000; //!< /internal MSB set to 1

  /**
   * \internal
   * \brief Create an index number for the network mask
   * \param mask the mask to index
   * \returns an index
   */
  uint32_t MaskToIndex (Ipv4Mask mask) const;

  /**
   * \internal
   * \brief This class holds the state for a given network
   */
  class NetworkState
  {
public:
    uint32_t mask;      //!< /internal the network mask
    uint32_t shift;     //!< /internal a shift
    uint32_t network;   //!< /internal the network
    uint32_t addr;      //!< /internal the address
    uint32_t addrMax;   //!< /internal the maximum address
  };

  NetworkState m_netTable[N_BITS]; //!< /internal the available networks

  /**
   * \internal
   * \brief This class holds the allocated addresses
   */
  class Entry
  {
public:
    uint32_t addrLow;  //!< /internal the lowest allocated address
    uint32_t addrHigh; //!< /internal the highest allocated address
  };

  std::list<Entry> m_entries; //!< /internal contained of allocated addresses
  bool m_test; //!< /internal test mode (if true)
};

Ipv4AddressGeneratorImpl::Ipv4AddressGeneratorImpl () 

(-)a/src/internet/model/ipv4-address-generator.h (+81 lines)

Lines 28-49	Link Here

 * \brief This generator assigns addresses sequentially from a provided

 * \brief This generator assigns addresses sequentially from a provided

 * network address; used in topology code.

 * network address; used in topology code.

 * \note BEWARE: this class acts as a Singleton.

 * In other terms, two different instances of Ipv4AddressGenerator will

 * pick IPv4 numbers from the same pool. Changing the network in one of them

 * will also change the network in the other instances.

*/

*/

class Ipv4AddressGenerator {

class Ipv4AddressGenerator {

public:

public:

/**

   * \brief Initialise the base network, mask and address for the generator

   * The first call to NextAddress() or GetAddress() will return the

   * value passed in.

   * \param net The network for the base Ipv4Address

   * \param mask The network mask of the base Ipv4Address

   * \param addr The base address used for initialization

*/

  static void Init (const Ipv4Address net, const Ipv4Mask mask,

  static void Init (const Ipv4Address net, const Ipv4Mask mask,

                    const Ipv4Address addr = "0.0.0.1");

                    const Ipv4Address addr = "0.0.0.1");

/**

   * \brief Get the next network according to the given Ipv4Mask

   * This operation is a pre-increment, meaning that the internal state

   * is changed before returning the new network address.

   * This also resets the address to the base address that was

   * used for initialization.

   * \param mask The Ipv4Mask used to set the next network

   * \returns the IPv4 address of the next network

*/

  static Ipv4Address NextNetwork (const Ipv4Mask mask);

  static Ipv4Address NextNetwork (const Ipv4Mask mask);

/**

   * \brief Get the current network of the given Ipv4Mask

   * Does not change the internal state; this just peeks at the current

   * network

   * \param mask The Ipv4Mask for the current network

   * \returns the IPv4 address of the current network

*/

  static Ipv4Address GetNetwork (const Ipv4Mask mask);

  static Ipv4Address GetNetwork (const Ipv4Mask mask);

/**

   * \brief Set the address for the given mask

   * \param addr The address to set for the current mask

   * \param mask The Ipv4Mask whose address is to be set

*/

  static void InitAddress (const Ipv4Address addr, const Ipv4Mask mask);

  static void InitAddress (const Ipv4Address addr, const Ipv4Mask mask);

/**

   * \brief Allocate the next Ipv4Address for the configured network and mask

   * This operation is a post-increment, meaning that the first address

   * allocated will be the one that was initially configured.

   * \param mask The Ipv4Mask for the current network

   * \returns the IPv4 address

*/

  static Ipv4Address NextAddress (const Ipv4Mask mask);

  static Ipv4Address NextAddress (const Ipv4Mask mask);

/**

   * \brief Get the Ipv4Address that will be allocated upon NextAddress ()

100

   * Does not change the internal state; just is used to peek the next

101

   * address that will be allocated upon NextAddress ()

102

103

   * \param mask The Ipv4Mask for the current network

104

   * \returns the IPv4 address

105

*/

  static Ipv4Address GetAddress (const Ipv4Mask mask);

106

  static Ipv4Address GetAddress (const Ipv4Mask mask);

107

108

/**

109

   * \brief Reset the networks and Ipv4Address to zero

110

*/

  static void Reset (void);

111

  static void Reset (void);

112

113

/**

114

   * \brief Add the Ipv4Address to the list of IPv4 entries

115

116

   * Typically, this is used by external address allocators that want

117

   * to make use of this class's ability to track duplicates.  AddAllocated

118

   * is always called internally for any address generated by NextAddress ()

119

120

   * \param addr The Ipv4Address to be added to the list of Ipv4 entries

121

   * \returns true on success

122

*/

  static bool AddAllocated (const Ipv4Address addr);

123

  static bool AddAllocated (const Ipv4Address addr);

124

125

/**

126

   * \brief Used to turn off fatal errors and assertions, for testing

127

*/

  static void TestMode (void);

128

  static void TestMode (void);

};

129

};

130

(-)a/src/internet/model/ipv4-end-point-demux.h (+98 lines)

Lines 42-84	Link Here

class Ipv4EndPointDemux {

class Ipv4EndPointDemux {

public:

public:

/**

   * \brief Container of the IPv4 endpoints.

*/

  typedef std::list<Ipv4EndPoint *> EndPoints;

  typedef std::list<Ipv4EndPoint *> EndPoints;

/**

   * \brief Iterator to the container of the IPv4 endpoints.

*/

  typedef std::list<Ipv4EndPoint *>::iterator EndPointsI;

  typedef std::list<Ipv4EndPoint *>::iterator EndPointsI;

  Ipv4EndPointDemux ();

  Ipv4EndPointDemux ();

  ~Ipv4EndPointDemux ();

  ~Ipv4EndPointDemux ();

/**

   * \brief Get the entire list of end points registered.

   * \return list of Ipv4EndPoint

*/

  EndPoints GetAllEndPoints (void);

  EndPoints GetAllEndPoints (void);

/**

   * \brief Lookup for port local.

   * \param port port to test

   * \return true if a port local is in EndPoints, false otherwise

*/

  bool LookupPortLocal (uint16_t port);

  bool LookupPortLocal (uint16_t port);

/**

   * \brief Lookup for address and port.

   * \param addr address to test

   * \param port port to test

   * \return true if there is a match in EndPoints, false otherwise

*/

  bool LookupLocal (Ipv4Address addr, uint16_t port);

  bool LookupLocal (Ipv4Address addr, uint16_t port);

/**

   * \brief lookup for a match with all the parameters.

   * \param daddr destination address to test

   * \param dport destination port to test

   * \param saddr source address to test

   * \param sport source port to test

   * \param incomingInterface the incoming interface

   * \return list of IPv4EndPoints (could be 0 element)

*/

  EndPoints Lookup (Ipv4Address daddr,

  EndPoints Lookup (Ipv4Address daddr,

                    uint16_t dport,

                    uint16_t dport,

                    Ipv4Address saddr,

                    Ipv4Address saddr,

                    uint16_t sport,

                    uint16_t sport,

                    Ptr<Ipv4Interface> incomingInterface);

                    Ptr<Ipv4Interface> incomingInterface);

/**

   * \brief simple lookup for a match with all the parameters.

   * \param daddr destination address to test

   * \param dport destination port to test

   * \param saddr source address to test

   * \param sport source port to test

100

   * \return IPv4EndPoint (0 if not found)

101

*/

  Ipv4EndPoint *SimpleLookup (Ipv4Address daddr,

102

  Ipv4EndPoint *SimpleLookup (Ipv4Address daddr,

                              uint16_t dport,

103

                              uint16_t dport,

                              Ipv4Address saddr,

104

                              Ipv4Address saddr,

                              uint16_t sport);

105

                              uint16_t sport);

106

107

/**

108

   * \brief Allocate a Ipv4EndPoint.

109

   * \return an empty Ipv4EndPoint instance

110

*/

  Ipv4EndPoint *Allocate (void);

111

  Ipv4EndPoint *Allocate (void);

112

113

/**

114

   * \brief Allocate a Ipv4EndPoint.

115

   * \param address IPv4 address

116

   * \return an Ipv4EndPoint instance

117

*/

  Ipv4EndPoint *Allocate (Ipv4Address address);

118

  Ipv4EndPoint *Allocate (Ipv4Address address);

119

120

/**

121

   * \brief Allocate a Ipv4EndPoint.

122

   * \param port local port

123

   * \return an Ipv4EndPoint instance

124

*/

  Ipv4EndPoint *Allocate (uint16_t port);

125

  Ipv4EndPoint *Allocate (uint16_t port);

126

127

/**

128

   * \brief Allocate a Ipv4EndPoint.

129

   * \param address local address

130

   * \param port local port

131

   * \return an Ipv4EndPoint instance

132

*/

  Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port);

133

  Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port);

134

135

/**

136

   * \brief Allocate a Ipv4EndPoint.

137

   * \param localAddress local address

138

   * \param localPort local port

139

   * \param peerAddress peer address

140

   * \param peerPort peer port

141

   * \return an Ipv4EndPoint instance

142

*/

  Ipv4EndPoint *Allocate (Ipv4Address localAddress,

143

  Ipv4EndPoint *Allocate (Ipv4Address localAddress,

                          uint16_t localPort,

144

                          uint16_t localPort,

                          Ipv4Address peerAddress,

145

                          Ipv4Address peerAddress,

                          uint16_t peerPort);

146

                          uint16_t peerPort);

147

148

/**

149

   * \brief Remove a end point.

150

   * \param endPoint the end point to remove

151

*/

  void DeAllocate (Ipv4EndPoint *endPoint);

152

  void DeAllocate (Ipv4EndPoint *endPoint);

153

private:

154

private:

155

156

/**

157

   * \brief Allocate an ephemeral port.

158

   * \returns the ephemeral port

159

*/

  uint16_t AllocateEphemeralPort (void);

160

  uint16_t AllocateEphemeralPort (void);

161

162

/**

163

   * \brief The ephemeral port.

164

*/

  uint16_t m_ephemeral;

165

  uint16_t m_ephemeral;

166

167

/**

168

   * \brief The last ephemeral port.

169

*/

  uint16_t m_portLast;

170

  uint16_t m_portLast;

171

172

/**

173

   * \brief The first ephemeral port.

174

*/

  uint16_t m_portFirst;

175

  uint16_t m_portFirst;

176

177

/**

178

   * \brief A list of IPv4 end points.

179

*/

  EndPoints m_endPoints;

180

  EndPoints m_endPoints;

};

181

};

182

(-)a/src/internet/model/ipv4-end-point.h (-5 / +145 lines)

Lines 46-93	Link Here

class Ipv4EndPoint {

class Ipv4EndPoint {

public:

public:

/**

   * \brief Constructor.

   * \param address the IPv4 address

   * \param port the port

*/

  Ipv4EndPoint (Ipv4Address address, uint16_t port);

  Ipv4EndPoint (Ipv4Address address, uint16_t port);

  ~Ipv4EndPoint ();

  ~Ipv4EndPoint ();

/**

   * \brief Get the local address.

   * \return the local address

*/

  Ipv4Address GetLocalAddress (void);

  Ipv4Address GetLocalAddress (void);

/**

   * \brief Set the local address.

   * \param address the address to set

*/

  void SetLocalAddress (Ipv4Address address);

  void SetLocalAddress (Ipv4Address address);

/**

   * \brief Get the local port.

   * \return the local port

*/

  uint16_t GetLocalPort (void);

  uint16_t GetLocalPort (void);

/**

   * \brief Get the peer address.

   * \return the peer address

*/

  Ipv4Address GetPeerAddress (void);

  Ipv4Address GetPeerAddress (void);

/**

   * \brief Get the peer port.

   * \return the peer port

*/

  uint16_t GetPeerPort (void);

  uint16_t GetPeerPort (void);

/**

   * \brief Set the peer informations (address and port).

   * \param address peer address

   * \param port peer port

*/

  void SetPeer (Ipv4Address address, uint16_t port);

  void SetPeer (Ipv4Address address, uint16_t port);

/**

   * \brief Bind a socket to specific device.

   * This method corresponds to using setsockopt() SO_BINDTODEVICE

   * of real network or BSD sockets.   If set on a socket, this option will

   * force packets to leave the bound device regardless of the device that

100

   * IP routing would naturally choose.  In the receive direction, only

101

   * packets received from the bound interface will be delivered.

102

103

   * This option has no particular relationship to binding sockets to

104

   * an address via Socket::Bind ().  It is possible to bind sockets to a

105

   * specific IP address on the bound interface by calling both

106

   * Socket::Bind (address) and Socket::BindToNetDevice (device), but it

107

   * is also possible to bind to mismatching device and address, even if

108

   * the socket can not receive any packets as a result.

109

110

   * \param netdevice Pointer to Netdevice of desired interface

111

*/

  void BindToNetDevice (Ptr<NetDevice> netdevice);

112

  void BindToNetDevice (Ptr<NetDevice> netdevice);

113

114

/**

115

   * \brief Returns socket's bound netdevice, if any.

116

117

   * This method corresponds to using getsockopt() SO_BINDTODEVICE

118

   * of real network or BSD sockets.

119

120

121

   * \returns Pointer to interface.

122

*/

  Ptr<NetDevice> GetBoundNetDevice (void);

123

  Ptr<NetDevice> GetBoundNetDevice (void);

124

  // Called from socket implementations to get notified about important events.

125

  // Called from socket implementations to get notified about important events.

126

/**

127

   * \brief Set the reception callback.

128

   * \param callback callback function

129

*/

  void SetRxCallback (Callback<void,Ptr<Packet>, Ipv4Header, uint16_t, Ptr<Ipv4Interface> > callback);

130

  void SetRxCallback (Callback<void,Ptr<Packet>, Ipv4Header, uint16_t, Ptr<Ipv4Interface> > callback);

131

/**

132

   * \brief Set the ICMP callback.

133

   * \param callback callback function

134

*/

  void SetIcmpCallback (Callback<void,Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> callback);

135

  void SetIcmpCallback (Callback<void,Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> callback);

136

/**

137

   * \brief Set the default destroy callback.

138

   * \param callback callback function

139

*/

  void SetDestroyCallback (Callback<void> callback);

140

  void SetDestroyCallback (Callback<void> callback);

141

  // Called from an L4Protocol implementation to notify an endpoint of a

142

/**

  // packet reception.

143

   * \brief Forward the packet to the upper level.

144

145

   * Called from an L4Protocol implementation to notify an endpoint of a

146

   * packet reception.

147

   * \param p the packet

148

   * \param header the packet header

149

   * \param sport source port

150

   * \param incomingInterface incoming interface

151

*/

  void ForwardUp (Ptr<Packet> p, const Ipv4Header& header, uint16_t sport,

152

  void ForwardUp (Ptr<Packet> p, const Ipv4Header& header, uint16_t sport,

                  Ptr<Ipv4Interface> incomingInterface);

153

                  Ptr<Ipv4Interface> incomingInterface);

  // Called from an L4Protocol implementation to notify an endpoint of

154

  // an icmp message reception.

155

/**

156

   * \brief Forward the ICMP packet to the upper level.

157

158

   * Called from an L4Protocol implementation to notify an endpoint of

159

   * an icmp message reception.

160

161

   * \param icmpSource source IP address

162

   * \param icmpTtl time-to-live

163

   * \param icmpType ICMP type

164

   * \param icmpCode ICMP code

165

   * \param icmpInfo ICMP info

166

*/

  void ForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

167

  void ForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

                    uint8_t icmpType, uint8_t icmpCode,

168

                    uint8_t icmpType, uint8_t icmpCode,

                    uint32_t icmpInfo);

169

                    uint32_t icmpInfo);

170

private:

171

private:

172

/**

173

   * \brief ForwardUp wrapper.

174

   * \param p packet

175

   * \param header the packet header

176

   * \param sport source port

177

   * \param incomingInterface incoming interface

178

*/

  void DoForwardUp (Ptr<Packet> p, const Ipv4Header& header, uint16_t sport,

179

  void DoForwardUp (Ptr<Packet> p, const Ipv4Header& header, uint16_t sport,

                    Ptr<Ipv4Interface> incomingInterface);

180

                    Ptr<Ipv4Interface> incomingInterface);

  void DoForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

181

/**

182

   * \brief ForwardIcmp wrapper.

183

   * \param icmpSource source IP address

184

   * \param icmpTtl time-to-live

185

   * \param icmpType ICMP type

186

   * \param icmpCode ICMP code

187

   * \param icmpInfo ICMP info

188

*/

189

  void DoForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

                      uint8_t icmpType, uint8_t icmpCode,

190

                      uint8_t icmpType, uint8_t icmpCode,

                      uint32_t icmpInfo);

191

                      uint32_t icmpInfo);

192

193

/**

194

   * \brief The local address.

195

*/

  Ipv4Address m_localAddr;

196

  Ipv4Address m_localAddr;

197

198

/**

199

   * \brief The local port.

200

*/

  uint16_t m_localPort;

201

  uint16_t m_localPort;

202

203

/**

204

   * \brief The peer address.

205

*/

  Ipv4Address m_peerAddr;

206

  Ipv4Address m_peerAddr;

207

208

/**

209

   * \brief The peer port.

210

*/

  uint16_t m_peerPort;

211

  uint16_t m_peerPort;

212

213

/**

214

   * \brief The NetDevice the EndPoint is bound to (if any).

215

*/

  Ptr<NetDevice> m_boundnetdevice;

216

  Ptr<NetDevice> m_boundnetdevice;

217

218

/**

219

   * \brief The RX callback.

220

*/

  Callback<void,Ptr<Packet>, Ipv4Header, uint16_t, Ptr<Ipv4Interface> > m_rxCallback;

221

  Callback<void,Ptr<Packet>, Ipv4Header, uint16_t, Ptr<Ipv4Interface> > m_rxCallback;

222

223

/**

224

   * \brief The ICMPv6 callback.

225

*/

  Callback<void,Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback;

226

  Callback<void,Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback;

227

228

/**

229

   * \brief The destroy callback.

230

*/

  Callback<void> m_destroyCallback;

231

  Callback<void> m_destroyCallback;

};

232

};

233




class Ipv4GlobalRouting : public Ipv4RoutingProtocol
{
public:
  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
  static TypeId GetTypeId (void);
  /**
   * \brief Construct an empty Ipv4GlobalRouting routing protocol,
   *
   * The Ipv4GlobalRouting class supports host and network unicast routes.
   * This method initializes the lists containing these routes to empty.
   *
   * \see Ipv4GlobalRouting
   */
  Ipv4GlobalRouting ();
  virtual ~Ipv4GlobalRouting ();


  virtual void SetIpv4 (Ptr<Ipv4> ipv4);
  virtual void PrintRoutingTable (Ptr<OutputStreamWrapper> stream) const;

  /**
   * \brief Add a host route to the global routing table.
   *
   * \param dest The Ipv4Address destination for this route.
   * \param nextHop The Ipv4Address of the next hop in the route.
   * \param interface The network interface index used to send packets to the
   * destination.
   *
   * \see Ipv4Address
   */
  void AddHostRouteTo (Ipv4Address dest, 
                       Ipv4Address nextHop, 
                       uint32_t interface);
  /**
   * \brief Add a host route to the global routing table.
   *
   * \param dest The Ipv4Address destination for this route.
   * \param interface The network interface index used to send packets to the
   * destination.
   *
   * \see Ipv4Address
   */
  void AddHostRouteTo (Ipv4Address dest, 
                       uint32_t interface);

  /**
   * \brief Add a network route to the global routing table.
   *
   * \param network The Ipv4Address network for this route.
   * \param networkMask The Ipv4Mask to extract the network.
   * \param nextHop The next hop in the route to the destination network.
   * \param interface The network interface index used to send packets to the
   * destination.
   *
   * \see Ipv4Address
   */
  void AddNetworkRouteTo (Ipv4Address network, 
                          Ipv4Mask networkMask, 
                          Ipv4Address nextHop, 
                          uint32_t interface);

  /**
   * \brief Add a network route to the global routing table.
   *
   * \param network The Ipv4Address network for this route.
   * \param networkMask The Ipv4Mask to extract the network.
   * \param interface The network interface index used to send packets to the
   * destination.
   *
   * \see Ipv4Address
   */
  void AddNetworkRouteTo (Ipv4Address network, 
                          Ipv4Mask networkMask, 
                          uint32_t interface);

  /**
   * \brief Add an external route to the global routing table.
   *
   * \param network The Ipv4Address network for this route.
   * \param networkMask The Ipv4Mask to extract the network.
   * \param nextHop The next hop Ipv4Address
   * \param interface The network interface index used to send packets to the
   * destination.
   */
  void AddASExternalRouteTo (Ipv4Address network,
                             Ipv4Mask networkMask,
                             Ipv4Address nextHop,
                             uint32_t interface);

  /**
   * \brief Get the number of individual unicast routes that have been added
   * to the routing table.
   *
   * \warning The default route counts as one of the routes.
   * \returns the number of routes
   */
  uint32_t GetNRoutes (void) const;

  /**
   * \brief Get a route from the global unicast routing table.
   *
   * Externally, the unicast global routing table appears simply as a table with
   * n entries.  The one subtlety of note is that if a default route has been set
   * it will appear as the zeroth entry in the table.  This means that if you
   * add only a default route, the table will have one entry that can be accessed
   * either by explicitly calling GetDefaultRoute () or by calling GetRoute (0).
   *
   * Similarly, if the default route has been set, calling RemoveRoute (0) will
   * remove the default route.
   *
   * \param i The index (into the routing table) of the route to retrieve.  If
   * the default route has been set, it will occupy index zero.
   * \return If route is set, a pointer to that Ipv4RoutingTableEntry is returned, otherwise
   * a zero pointer is returned.
   *
   * \see Ipv4RoutingTableEntry
   * \see Ipv4GlobalRouting::RemoveRoute
   */
  Ipv4RoutingTableEntry *GetRoute (uint32_t i) const;

  /**
   * \brief Remove a route from the global unicast routing table.
   *
   * Externally, the unicast global routing table appears simply as a table with
   * n entries.  The one subtlety of note is that if a default route has been set
   * it will appear as the zeroth entry in the table.  This means that if the
   * default route has been set, calling RemoveRoute (0) will remove the
   * default route.
   *
   * \param i The index (into the routing table) of the route to remove.  If
   * the default route has been set, it will occupy index zero.
   *
   * \see Ipv4RoutingTableEntry
   * \see Ipv4GlobalRouting::GetRoute
   * \see Ipv4GlobalRouting::AddRoute
   */
  void RemoveRoute (uint32_t i);

  /**
   * Assign a fixed random variable stream number to the random variables
   * used by this model.  Return the number of streams (possibly zero) that
   * have been assigned.
   *
   * \param stream first stream index to use
   * \return the number of stream indices assigned by this model
   */
  int64_t AssignStreams (int64_t stream);

protected:

  /// A uniform random number generator for randomly routing packets among ECMP 
  Ptr<UniformRandomVariable> m_rand;

  /// container of Ipv4RoutingTableEntry (routes to hosts)
  typedef std::list<Ipv4RoutingTableEntry *> HostRoutes;
  /// const iterator of container of Ipv4RoutingTableEntry (routes to hosts)
  typedef std::list<Ipv4RoutingTableEntry *>::const_iterator HostRoutesCI;
  /// iterator of container of Ipv4RoutingTableEntry (routes to hosts)
  typedef std::list<Ipv4RoutingTableEntry *>::iterator HostRoutesI;

  /// container of Ipv4RoutingTableEntry (routes to networks)
  typedef std::list<Ipv4RoutingTableEntry *> NetworkRoutes;
  /// const iterator of container of Ipv4RoutingTableEntry (routes to networks)
  typedef std::list<Ipv4RoutingTableEntry *>::const_iterator NetworkRoutesCI;
  /// iterator of container of Ipv4RoutingTableEntry (routes to networks)
  typedef std::list<Ipv4RoutingTableEntry *>::iterator NetworkRoutesI;

  /// container of Ipv4RoutingTableEntry (routes to external AS)
  typedef std::list<Ipv4RoutingTableEntry *> ASExternalRoutes;
  /// const iterator of container of Ipv4RoutingTableEntry (routes to external AS)
  typedef std::list<Ipv4RoutingTableEntry *>::const_iterator ASExternalRoutesCI;
  /// iterator of container of Ipv4RoutingTableEntry (routes to external AS)
  typedef std::list<Ipv4RoutingTableEntry *>::iterator ASExternalRoutesI;

  Ptr<Ipv4Route> LookupGlobal (Ipv4Address dest, Ptr<NetDevice> oif = 0);

  HostRoutes m_hostRoutes;             //!< Routes to hosts
  NetworkRoutes m_networkRoutes;       //!< Routes to networks
  ASExternalRoutes m_ASexternalRoutes; //!< External routes imported

  Ptr<Ipv4> m_ipv4; //!< associated IPv4 instance
};

} // Namespace ns3

(-)a/src/internet/model/ipv4-header.h (-13 / +20 lines)

Lines 172-177	Link Here

172

*/

172

*/

173

  DscpType GetDscp (void) const;

173

  DscpType GetDscp (void) const;

174

/**

174

/**

175

   * \param dscp the dscp

175

   * \returns std::string of DSCPType

176

   * \returns std::string of DSCPType

176

*/

177

*/

177

  std::string DscpTypeToString (DscpType dscp) const;

178

  std::string DscpTypeToString (DscpType dscp) const;

Lines 180-185	Link Here

180

*/

181

*/

181

  EcnType GetEcn (void) const;

182

  EcnType GetEcn (void) const;

182

/**

183

/**

184

   * \param ecn the ECNType

183

   * \returns std::string of ECNType

185

   * \returns std::string of ECNType

184

*/

186

*/

185

  std::string EcnTypeToString (EcnType ecn) const;

187

  std::string EcnTypeToString (EcnType ecn) const;

Lines 220-225	Link Here

220

*/

222

*/

221

  bool IsChecksumOk (void) const;

223

  bool IsChecksumOk (void) const;

222

224

225

/**

226

   * \brief Get the type ID.

227

   * \return the object TypeId

228

*/

223

  static TypeId GetTypeId (void);

229

  static TypeId GetTypeId (void);

224

  virtual TypeId GetInstanceTypeId (void) const;

230

  virtual TypeId GetInstanceTypeId (void) const;

225

  virtual void Print (std::ostream &os) const;

231

  virtual void Print (std::ostream &os) const;

Lines 228-252	Link Here

228

  virtual uint32_t Deserialize (Buffer::Iterator start);

234

  virtual uint32_t Deserialize (Buffer::Iterator start);

229

private:

235

private:

230

236

237

  /// flags related to IP fragmentation

231

  enum FlagsE {

238

  enum FlagsE {

232

    DONT_FRAGMENT = (1<<0),

239

    DONT_FRAGMENT = (1<<0),

233

    MORE_FRAGMENTS = (1<<1)

240

    MORE_FRAGMENTS = (1<<1)

234

};

241

};

235

242

236

  bool m_calcChecksum;

243

  bool m_calcChecksum; //!< true if the checksum must be calculated

237

244

238

  uint16_t m_payloadSize;

245

  uint16_t m_payloadSize; //!< payload size

239

  uint16_t m_identification;

246

  uint16_t m_identification; //!< identification

240

  uint32_t m_tos : 8; //Also used as DSCP + ECN value

247

  uint32_t m_tos : 8; //!< TOS, also used as DSCP + ECN value

241

  uint32_t m_ttl : 8;

248

  uint32_t m_ttl : 8; //!< TTL

242

  uint32_t m_protocol : 8;

249

  uint32_t m_protocol : 8;  //!< Protocol

243

  uint32_t m_flags : 3;

250

  uint32_t m_flags : 3; //!< flags

244

  uint16_t m_fragmentOffset;

251

  uint16_t m_fragmentOffset;  //!< Fragment offset

245

  Ipv4Address m_source;

252

  Ipv4Address m_source; //!< source address

246

  Ipv4Address m_destination;

253

  Ipv4Address m_destination; //!< destination address

247

  uint16_t m_checksum;

254

  uint16_t m_checksum; //!< checksum

248

  bool m_goodChecksum;

255

  bool m_goodChecksum; //!< true if checksum is correct

249

  uint16_t m_headerSize;

256

  uint16_t m_headerSize; //!< IP header size

250

};

257

};

251

258

252

} // namespace ns3

259

} // namespace ns3

(-)a/src/internet/model/ipv4-interface-address.h (-7 / +88 lines)

Lines 42-47	Link Here

class Ipv4InterfaceAddress

class Ipv4InterfaceAddress

public:

public:

/**

   * \enum InterfaceAddressScope_e

   * \brief Address scope.

*/

  enum InterfaceAddressScope_e {

  enum InterfaceAddressScope_e {

    HOST,

    HOST,

    LINK,

    LINK,

Lines 49-87	Link Here

};

};

  Ipv4InterfaceAddress ();

  Ipv4InterfaceAddress ();

  // Configure m_local, m_mask, and m_broadcast from the below constructor

/**

   * \brief Configure local address, mask and broadcast address

   * \param local the local address

   * \param mask the network mask

*/

  Ipv4InterfaceAddress (Ipv4Address local, Ipv4Mask mask);

  Ipv4InterfaceAddress (Ipv4Address local, Ipv4Mask mask);

/**

   * Copy constructor

   * \param o the object to copy

*/

  Ipv4InterfaceAddress (const Ipv4InterfaceAddress &o);

  Ipv4InterfaceAddress (const Ipv4InterfaceAddress &o);

/**

   * \brief Set local address

   * \param local the address

*/

  void SetLocal (Ipv4Address local);

  void SetLocal (Ipv4Address local);

/**

   * \brief Get the local address

   * \returns the local address

*/

  Ipv4Address GetLocal (void) const;

  Ipv4Address GetLocal (void) const;

/**

   * \brief Set the network mask

   * \param mask the network mask

*/

  void SetMask (Ipv4Mask mask);

  void SetMask (Ipv4Mask mask);

/**

   * \brief Get the network mask

   * \returns the network mask

*/

  Ipv4Mask GetMask (void) const;

  Ipv4Mask GetMask (void) const;

/**

   * \brief Set the broadcast address

   * \param broadcast the broadcast address

*/

  void SetBroadcast (Ipv4Address broadcast);

  void SetBroadcast (Ipv4Address broadcast);

/**

   * \brief Get the broadcast address

   * \returns the broadcast address

*/

  Ipv4Address GetBroadcast (void) const;

  Ipv4Address GetBroadcast (void) const;

100

/**

101

   * \brief Set the scope.

102

   * \param scope the scope of address

103

*/

  void SetScope (Ipv4InterfaceAddress::InterfaceAddressScope_e scope);

104

  void SetScope (Ipv4InterfaceAddress::InterfaceAddressScope_e scope);

105

106

/**

107

   * \brief Get address scope.

108

   * \return scope

109

*/

  Ipv4InterfaceAddress::InterfaceAddressScope_e GetScope (void) const;

110

  Ipv4InterfaceAddress::InterfaceAddressScope_e GetScope (void) const;

111

112

/**

113

   * \brief Check if the address is a secondary address

114

115

   * Secondary address is used for multihoming

116

   * \returns true if the address is secondary

117

*/

  bool IsSecondary (void) const;

118

  bool IsSecondary (void) const;

119

120

/**

121

   * \brief Make the address secondary (used for multihoming)

122

*/

  void SetSecondary (void);

123

  void SetSecondary (void);

124

/**

125

   * \brief Make the address primary

126

*/

  void SetPrimary (void);

127

  void SetPrimary (void);

128

private:

129

private:

130

  Ipv4Address m_local;     // Interface address

131

  Ipv4Address m_local;     //!< Interface address

  // Note:  m_peer may be added in future when necessary

132

  // Note:  m_peer may be added in future when necessary

  // Ipv4Address m_peer;      // Peer destination address (in Linux:  m_address)

133

  // Ipv4Address m_peer;   // Peer destination address (in Linux:  m_address)

  Ipv4Mask m_mask;         // Network mask

134

  Ipv4Mask m_mask;         //!< Network mask

  Ipv4Address m_broadcast; // Broadcast address

135

  Ipv4Address m_broadcast; //!< Broadcast address

136

  InterfaceAddressScope_e m_scope;

137

  InterfaceAddressScope_e m_scope; //!< Address scope

  bool m_secondary;        // For use in multihoming

138

  bool m_secondary;        //!< For use in multihoming

139

140

/**

141

   * \brief Equal to operator.

142

143

   * \param a the first operand

144

   * \param b the first operand

145

   * \returns true if the operands are equal

146

*/

  friend bool operator == (Ipv4InterfaceAddress const &a, Ipv4InterfaceAddress const &b);

147

  friend bool operator == (Ipv4InterfaceAddress const &a, Ipv4InterfaceAddress const &b);

148

149

/**

150

   * \brief Not equal to operator.

151

152

   * \param a the first operand

153

   * \param b the first operand

154

   * \returns true if the operands are not equal

155

*/

  friend bool operator != (Ipv4InterfaceAddress const &a, Ipv4InterfaceAddress const &b);

156

  friend bool operator != (Ipv4InterfaceAddress const &a, Ipv4InterfaceAddress const &b);

};

157

};

158

159

/**

160

 * \brief Stream insertion operator.

161

162

 * \param os the reference to the output stream

163

 * \param addr the Ipv4InterfaceAddress

164

 * \returns the reference to the output stream

165

*/

std::ostream& operator<< (std::ostream& os, const Ipv4InterfaceAddress &addr);

166

std::ostream& operator<< (std::ostream& os, const Ipv4InterfaceAddress &addr);

167

inline bool operator == (const Ipv4InterfaceAddress &a, const Ipv4InterfaceAddress &b)

168

inline bool operator == (const Ipv4InterfaceAddress &a, const Ipv4InterfaceAddress &b)

(-)a/src/internet/model/ipv4-interface.h (-9 / +43 lines)

Lines 43-62	Link Here

 * specific information (addresses) about an interface.

 * specific information (addresses) about an interface.

 * By default, Ipv4 interface are created in the "down" state

 * By default, Ipv4 interface are created in the "down" state

 * no IP addresses.  Before becoming useable, the user must

 * no IP addresses.  Before becoming usable, the user must

 * add an address of some type and invoke Setup on them.

 * add an address of some type and invoke Setup on them.

*/

*/

class Ipv4Interface  : public Object

class Ipv4Interface  : public Object

public:

public:

/**

   * \brief Get the type ID

   * \return type ID

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Ipv4Interface ();

  Ipv4Interface ();

  virtual ~Ipv4Interface();

  virtual ~Ipv4Interface();

/**

   * \brief Set node associated with interface.

   * \param node node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

/**

   * \brief Set the NetDevice.

   * \param device NetDevice

*/

  void SetDevice (Ptr<NetDevice> device);

  void SetDevice (Ptr<NetDevice> device);

  void SetArpCache (Ptr<ArpCache>);

/**

   * \brief Set ARP cache used by this interface

   * \param arpCache the ARP cache

*/

  void SetArpCache (Ptr<ArpCache> arpCache);

/**

/**

   * \returns the underlying NetDevice. This method cannot return zero.

   * \returns the underlying NetDevice. This method cannot return zero.

Lines 164-181	Link Here

164

protected:

180

protected:

165

  virtual void DoDispose (void);

181

  virtual void DoDispose (void);

166

private:

182

private:

183

/**

184

   * \brief Initialize interface.

185

*/

167

  void DoSetup (void);

186

  void DoSetup (void);

187

188

189

/**

190

   * \brief Container for the Ipv4InterfaceAddresses.

191

*/

168

  typedef std::list<Ipv4InterfaceAddress> Ipv4InterfaceAddressList;

192

  typedef std::list<Ipv4InterfaceAddress> Ipv4InterfaceAddressList;

193

194

/**

195

   * \brief Container Iterator for the Ipv4InterfaceAddresses.

196

*/

169

  typedef std::list<Ipv4InterfaceAddress>::const_iterator Ipv4InterfaceAddressListCI;

197

  typedef std::list<Ipv4InterfaceAddress>::const_iterator Ipv4InterfaceAddressListCI;

198

199

/**

200

   * \brief Const Container Iterator for the Ipv4InterfaceAddresses.

201

*/

170

  typedef std::list<Ipv4InterfaceAddress>::iterator Ipv4InterfaceAddressListI;

202

  typedef std::list<Ipv4InterfaceAddress>::iterator Ipv4InterfaceAddressListI;

171

203

172

  bool m_ifup;

204

173

  bool m_forwarding;  // IN_DEV_FORWARD

205

174

  uint16_t m_metric;

206

  bool m_ifup; //!< The state of this interface

175

  Ipv4InterfaceAddressList m_ifaddrs;

207

  bool m_forwarding;  //!< Forwarding state.

176

  Ptr<Node> m_node;

208

  uint16_t m_metric;  //!< Interface metric

177

  Ptr<NetDevice> m_device;

209

  Ipv4InterfaceAddressList m_ifaddrs; //!< Address list

178

  Ptr<ArpCache> m_cache;

210

  Ptr<Node> m_node; //!< The associated node

211

  Ptr<NetDevice> m_device; //!< The associated NetDevice

212

  Ptr<ArpCache> m_cache; //!< ARP cache

179

};

213

};

180

214

181

} // namespace ns3

215

} // namespace ns3

(-)a/src/internet/model/ipv4-l3-protocol.cc (-3 / +3 lines)

Lines 688-696	Link Here

688

689

690

691

/// \todo when should we set ip_id?   check whether we are incrementing

691

// \todo when should we set ip_id?   check whether we are incrementing

692

/// m_identification on packets that may later be dropped in this stack

692

// m_identification on packets that may later be dropped in this stack

693

/// and whether that deviates from Linux

693

// and whether that deviates from Linux

694

Ipv4Header

694

Ipv4Header

695

Ipv4L3Protocol::BuildHeader (

695

Ipv4L3Protocol::BuildHeader (

696

  Ipv4Address source,

696

  Ipv4Address source,

(-)a/src/internet/model/ipv4-l3-protocol.h (-19 / +117 lines)

Lines 77-84	Link Here

class Ipv4L3Protocol : public Ipv4

class Ipv4L3Protocol : public Ipv4

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  static const uint16_t PROT_NUMBER;

  static const uint16_t PROT_NUMBER; //!< Protocol number (0x0800)

  Ipv4L3Protocol();

  Ipv4L3Protocol();

  virtual ~Ipv4L3Protocol ();

  virtual ~Ipv4L3Protocol ();

Lines 97-102	Link Here

    DROP_FRAGMENT_TIMEOUT /**< Fragment timeout exceeded */

101

    DROP_FRAGMENT_TIMEOUT /**< Fragment timeout exceeded */

};

102

};

103

104

/**

105

   * \brief Set node associated with this stack.

106

   * \param node node to set

107

*/

100

  void SetNode (Ptr<Node> node);

108

  void SetNode (Ptr<Node> node);

101

109

102

  // functions defined in base class Ipv4

110

  // functions defined in base class Ipv4

Lines 182-187	Link Here

182

  void SendWithHeader (Ptr<Packet> packet, Ipv4Header ipHeader, Ptr<Ipv4Route> route);

190

  void SendWithHeader (Ptr<Packet> packet, Ipv4Header ipHeader, Ptr<Ipv4Route> route);

183

191

184

  uint32_t AddInterface (Ptr<NetDevice> device);

192

  uint32_t AddInterface (Ptr<NetDevice> device);

193

/**

194

   * \brief Get an interface.

195

   * \param i interface index

196

   * \return IPv4 interface pointer

197

*/

185

  Ptr<Ipv4Interface> GetInterface (uint32_t i) const;

198

  Ptr<Ipv4Interface> GetInterface (uint32_t i) const;

186

  uint32_t GetNInterfaces (void) const;

199

  uint32_t GetNInterfaces (void) const;

187

200

Lines 220-226	Link Here

220

  virtual void NotifyNewAggregate ();

233

  virtual void NotifyNewAggregate ();

221

private:

234

private:

222

  friend class Ipv4L3ProtocolTestCase;

235

  friend class Ipv4L3ProtocolTestCase;

236

237

/**

238

   * \brief Copy constructor.

239

240

   * Defined but not implemented to avoid misuse

241

*/

223

  Ipv4L3Protocol(const Ipv4L3Protocol &);

242

  Ipv4L3Protocol(const Ipv4L3Protocol &);

243

244

/**

245

   * \brief Copy constructor.

246

247

   * Defined but not implemented to avoid misuse

248

   * \returns the copied object

249

*/

224

  Ipv4L3Protocol &operator = (const Ipv4L3Protocol &);

250

  Ipv4L3Protocol &operator = (const Ipv4L3Protocol &);

225

251

226

  // class Ipv4 attributes

252

  // class Ipv4 attributes

Lines 229-234	Link Here

229

  virtual void SetWeakEsModel (bool model);

255

  virtual void SetWeakEsModel (bool model);

230

  virtual bool GetWeakEsModel (void) const;

256

  virtual bool GetWeakEsModel (void) const;

231

257

258

/**

259

   * \brief Construct an IPv4 header.

260

   * \param source source IPv4 address

261

   * \param destination destination IPv4 address

262

   * \param protocol L4 protocol

263

   * \param payloadSize payload size

264

   * \param ttl Time to Live

265

   * \param tos Type of Service

266

   * \param mayFragment true if the packet can be fragmented

267

   * \return newly created IPv4 header

268

*/

232

  Ipv4Header BuildHeader (

269

  Ipv4Header BuildHeader (

233

    Ipv4Address source,

270

    Ipv4Address source,

234

    Ipv4Address destination,

271

    Ipv4Address destination,

Lines 238-262	Link Here

238

    uint8_t tos,

275

    uint8_t tos,

239

    bool mayFragment);

276

    bool mayFragment);

240

277

278

/**

279

   * \brief Send packet with route.

280

   * \param route route

281

   * \param packet packet to send

282

   * \param ipHeader IPv4 header to add to the packet

283

*/

241

  void

284

  void

242

  SendRealOut (Ptr<Ipv4Route> route,

285

  SendRealOut (Ptr<Ipv4Route> route,

243

               Ptr<Packet> packet,

286

               Ptr<Packet> packet,

244

               Ipv4Header const &ipHeader);

287

               Ipv4Header const &ipHeader);

245

288

289

/**

290

   * \brief Forward a packet.

291

   * \param rtentry route

292

   * \param p packet to forward

293

   * \param header IPv4 header to add to the packet

294

*/

246

  void

295

  void

247

  IpForward (Ptr<Ipv4Route> rtentry,

296

  IpForward (Ptr<Ipv4Route> rtentry,

248

             Ptr<const Packet> p,

297

             Ptr<const Packet> p,

249

             const Ipv4Header &header);

298

             const Ipv4Header &header);

250

299

300

/**

301

   * \brief Forward a multicast packet.

302

   * \param mrtentry route

303

   * \param p packet to forward

304

   * \param header IPv6 header to add to the packet

305

*/

251

  void

306

  void

252

  IpMulticastForward (Ptr<Ipv4MulticastRoute> mrtentry,

307

  IpMulticastForward (Ptr<Ipv4MulticastRoute> mrtentry,

253

                      Ptr<const Packet> p,

308

                      Ptr<const Packet> p,

254

                      const Ipv4Header &header);

309

                      const Ipv4Header &header);

255

310

311

/**

312

   * \brief Deliver a packet.

313

   * \param p packet delivered

314

   * \param ip IPv4 header

315

   * \param iif input interface packet was received

316

*/

256

  void LocalDeliver (Ptr<const Packet> p, Ipv4Header const&ip, uint32_t iif);

317

  void LocalDeliver (Ptr<const Packet> p, Ipv4Header const&ip, uint32_t iif);

318

319

/**

320

   * \brief Fallback when no route is found.

321

   * \param p packet

322

   * \param ipHeader IPv4 header

323

   * \param sockErrno error number

324

*/

257

  void RouteInputError (Ptr<const Packet> p, const Ipv4Header & ipHeader, Socket::SocketErrno sockErrno);

325

  void RouteInputError (Ptr<const Packet> p, const Ipv4Header & ipHeader, Socket::SocketErrno sockErrno);

258

326

327

/**

328

   * \brief Add an IPv4 interface to the stack.

329

   * \param interface interface to add

330

   * \return index of newly added interface

331

*/

259

  uint32_t AddIpv4Interface (Ptr<Ipv4Interface> interface);

332

  uint32_t AddIpv4Interface (Ptr<Ipv4Interface> interface);

333

334

/**

335

   * \brief Setup loopback interface.

336

*/

260

  void SetupLoopback (void);

337

  void SetupLoopback (void);

261

338

262

/**

339

/**

Lines 264-269	Link Here

264

   * \return Icmpv4L4Protocol pointer

341

   * \return Icmpv4L4Protocol pointer

265

*/

342

*/

266

  Ptr<Icmpv4L4Protocol> GetIcmp (void) const;

343

  Ptr<Icmpv4L4Protocol> GetIcmp (void) const;

344

345

/**

346

   * \brief Check if an IPv4 address is unicast.

347

   * \param ad address

348

   * \param interfaceMask the network mask

349

   * \return true if the address is unicast

350

*/

267

  bool IsUnicast (Ipv4Address ad, Ipv4Mask interfaceMask) const;

351

  bool IsUnicast (Ipv4Address ad, Ipv4Mask interfaceMask) const;

268

352

269

/**

353

/**

Lines 277-283	Link Here

277

/**

361

/**

278

   * \brief Process a packet fragment

362

   * \brief Process a packet fragment

279

   * \param packet the packet

363

   * \param packet the packet

280

   * \param fragmentSize the size of the fragment

364

   * \param ipHeader the IP header

281

   * \param iif Input Interface

365

   * \param iif Input Interface

282

   * \return true is the fragment completed the packet

366

   * \return true is the fragment completed the packet

283

*/

367

*/

Lines 291-322	Link Here

291

*/

375

*/

292

  void HandleFragmentsTimeout ( std::pair<uint64_t, uint32_t> key, Ipv4Header & ipHeader, uint32_t iif);

376

  void HandleFragmentsTimeout ( std::pair<uint64_t, uint32_t> key, Ipv4Header & ipHeader, uint32_t iif);

293

377

378

/**

379

   * \brief Container of the IPv4 Interfaces.

380

*/

294

  typedef std::vector<Ptr<Ipv4Interface> > Ipv4InterfaceList;

381

  typedef std::vector<Ptr<Ipv4Interface> > Ipv4InterfaceList;

382

/**

383

   * \brief Container of the IPv4 Raw Sockets.

384

*/

295

  typedef std::list<Ptr<Ipv4RawSocketImpl> > SocketList;

385

  typedef std::list<Ptr<Ipv4RawSocketImpl> > SocketList;

296

  typedef std::list<Ptr<IpL4Protocol> > L4List_t;

386

/**

387

   * \brief Container of the IPv4 L4 instances.

388

*/

389

   typedef std::list<Ptr<IpL4Protocol> > L4List_t;

297

390

298

  bool m_ipForward;

391

  bool m_ipForward;      //!< Forwarding packets (i.e. router mode) state.

299

  bool m_weakEsModel;

392

  bool m_weakEsModel;    //!< Weak ES model state

300

  L4List_t m_protocols;

393

  L4List_t m_protocols;  //!< List of transport protocol.

301

  Ipv4InterfaceList m_interfaces;

394

  Ipv4InterfaceList m_interfaces; //!< List of IPv4 interfaces.

302

  uint8_t m_defaultTos;

395

  uint8_t m_defaultTos;  //!< Default TOS

303

  uint8_t m_defaultTtl;

396

  uint8_t m_defaultTtl;  //!< Default TTL

304

  uint16_t m_identification;

397

  uint16_t m_identification; //!< Identification

305

  Ptr<Node> m_node;

398

  Ptr<Node> m_node; //!< Node attached to stack.

306

399

400

  /// Trace of sent packets

307

  TracedCallback<const Ipv4Header &, Ptr<const Packet>, uint32_t> m_sendOutgoingTrace;

401

  TracedCallback<const Ipv4Header &, Ptr<const Packet>, uint32_t> m_sendOutgoingTrace;

402

  /// Trace of unicast forwarded packets

308

  TracedCallback<const Ipv4Header &, Ptr<const Packet>, uint32_t> m_unicastForwardTrace;

403

  TracedCallback<const Ipv4Header &, Ptr<const Packet>, uint32_t> m_unicastForwardTrace;

404

  /// Trace of locally delivered packets

309

  TracedCallback<const Ipv4Header &, Ptr<const Packet>, uint32_t> m_localDeliverTrace;

405

  TracedCallback<const Ipv4Header &, Ptr<const Packet>, uint32_t> m_localDeliverTrace;

310

406

311

  // The following two traces pass a packet with an IP header

407

  // The following two traces pass a packet with an IP header

408

  /// Trace of transmitted packets

312

  TracedCallback<Ptr<const Packet>, Ptr<Ipv4>,  uint32_t> m_txTrace;

409

  TracedCallback<Ptr<const Packet>, Ptr<Ipv4>,  uint32_t> m_txTrace;

410

  /// Trace of received packets

313

  TracedCallback<Ptr<const Packet>, Ptr<Ipv4>, uint32_t> m_rxTrace;

411

  TracedCallback<Ptr<const Packet>, Ptr<Ipv4>, uint32_t> m_rxTrace;

314

  // <ip-header, payload, reason, ifindex> (ifindex not valid if reason is DROP_NO_ROUTE)

412

  // <ip-header, payload, reason, ifindex> (ifindex not valid if reason is DROP_NO_ROUTE)

413

  /// Trace of dropped packets

315

  TracedCallback<const Ipv4Header &, Ptr<const Packet>, DropReason, Ptr<Ipv4>, uint32_t> m_dropTrace;

414

  TracedCallback<const Ipv4Header &, Ptr<const Packet>, DropReason, Ptr<Ipv4>, uint32_t> m_dropTrace;

316

415

317

  Ptr<Ipv4RoutingProtocol> m_routingProtocol;

416

  Ptr<Ipv4RoutingProtocol> m_routingProtocol; //!< Routing protocol associated with the stack

318

417

319

  SocketList m_sockets;

418

  SocketList m_sockets; //!< List of IPv4 raw sockets.

320

419

321

/**

420

/**

322

   * \class Fragments

421

   * \class Fragments

Lines 374-388	Link Here

374

473

375

};

474

};

376

475

476

  /// Container of fragments, stored as pairs(src+dst addr, src+dst port) / fragment

377

  typedef std::map< std::pair<uint64_t, uint32_t>, Ptr<Fragments> > MapFragments_t;

477

  typedef std::map< std::pair<uint64_t, uint32_t>, Ptr<Fragments> > MapFragments_t;

478

  /// Container of fragment timeout event, stored as pairs(src+dst addr, src+dst port) / EventId

378

  typedef std::map< std::pair<uint64_t, uint32_t>, EventId > MapFragmentsTimers_t;

479

  typedef std::map< std::pair<uint64_t, uint32_t>, EventId > MapFragmentsTimers_t;

379

480

380

/**

481

  MapFragments_t       m_fragments; //!< Fragmented packets.

381

   * \brief The hash of fragmented packets.

482

  Time                 m_fragmentExpirationTimeout; //!< Expiration timeout

382

*/

483

  MapFragmentsTimers_t m_fragmentsTimers; //!< Expiration events.

383

  MapFragments_t       m_fragments;

384

  Time                 m_fragmentExpirationTimeout;

385

  MapFragmentsTimers_t m_fragmentsTimers;

386

484

387

};

485

};

388

486

(-)a/src/internet/model/ipv4-list-routing.h (-2 / +20 lines)

Lines 45-50	Link Here

class Ipv4ListRouting : public Ipv4RoutingProtocol

class Ipv4ListRouting : public Ipv4RoutingProtocol

public:

public:

/**

   * \brief Get the type ID of this class.

   * \return type ID

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Ipv4ListRouting ();

  Ipv4ListRouting ();

Lines 92-102	Link Here

  void DoDispose (void);

  void DoDispose (void);

  void DoInitialize (void);

  void DoInitialize (void);

private:

private:

/**

100

   * \brief Container identifying an IPv4 Routing Protocol entry in the list.

101

*/

  typedef std::pair<int16_t, Ptr<Ipv4RoutingProtocol> > Ipv4RoutingProtocolEntry;

102

  typedef std::pair<int16_t, Ptr<Ipv4RoutingProtocol> > Ipv4RoutingProtocolEntry;

103

/**

104

   * \brief Container of the IPv4 Routing Protocols.

105

*/

  typedef std::list<Ipv4RoutingProtocolEntry> Ipv4RoutingProtocolList;

106

  typedef std::list<Ipv4RoutingProtocolEntry> Ipv4RoutingProtocolList;

  Ipv4RoutingProtocolList m_routingProtocols;

107

  Ipv4RoutingProtocolList m_routingProtocols; //!<  List of routing protocols.

108

109

/**

110

   * \brief Compare two routing protocols.

111

   * \param a first object to compare

112

   * \param b second object to compare

113

   * \return true if they are the same, false otherwise

114

*/

  static bool Compare (const Ipv4RoutingProtocolEntry& a, const Ipv4RoutingProtocolEntry& b);

115

  static bool Compare (const Ipv4RoutingProtocolEntry& a, const Ipv4RoutingProtocolEntry& b);

  Ptr<Ipv4> m_ipv4;

116

  Ptr<Ipv4> m_ipv4; //!< Ipv4 this protocol is associated with.

117

100

118

101

};

119

};

102

120

(-)a/src/internet/model/ipv4-packet-info-tag.h (-13 / +57 lines)

Lines 43-65	Link Here

public:

public:

  Ipv4PacketInfoTag ();

  Ipv4PacketInfoTag ();

  // Implemented, but not used in the stack yet

/**

   * \brief Set the tag's address

   * \param addr the address

*/

  void SetAddress (Ipv4Address addr);

  void SetAddress (Ipv4Address addr);

  // Implemented, but not used in the stack yet

/**

   * \brief Get the tag's address

   * \returns the address

*/

  Ipv4Address GetAddress (void) const;

  Ipv4Address GetAddress (void) const;

  // This corresponds to "ipi_spec_dst" in struct in_pktinfo.

/**

  // Implemented, but not used in the stack yet

   * \brief Set the tag's \a local address

   * This corresponds to "ipi_spec_dst" in struct in_pktinfo.

   * Implemented, but not used in the stack yet

   * \param addr the address

*/

  void SetLocalAddress (Ipv4Address addr);

  void SetLocalAddress (Ipv4Address addr);

  // This corresponds to "ipi_spec_dst" in struct in_pktinfo.

/**

  // Implemented, but not used in the stack yet

   * \brief Get the tag's \a local address

   * This corresponds to "ipi_spec_dst" in struct in_pktinfo.

   * Implemented, but not used in the stack yet

   * \returns the address

*/

  Ipv4Address GetLocalAddress (void) const;

  Ipv4Address GetLocalAddress (void) const;

/**

   * \brief Set the tag's receiving interface

   * \param ifindex the interface index

*/

  void SetRecvIf (uint32_t ifindex);

  void SetRecvIf (uint32_t ifindex);

/**

   * \brief Get the tag's receiving interface

   * \returns the interface index

*/

  uint32_t GetRecvIf (void) const;

  uint32_t GetRecvIf (void) const;

  // Implemented, but not used in the stack yet

/**

   * \brief Set the tag's Time to Live

   * Implemented, but not used in the stack yet

   * \param ttl the TTL

*/

  void SetTtl (uint8_t ttl);

  void SetTtl (uint8_t ttl);

  // Implemented, but not used in the stack yet

/**

   * \brief Get the tag's Time to Live

   * Implemented, but not used in the stack yet

   * \returns the TTL

100

*/

  uint8_t GetTtl (void) const;

101

  uint8_t GetTtl (void) const;

102

103

/**

104

   * \brief Get the type ID.

105

   * \return the object TypeId

106

*/

  static TypeId GetTypeId (void);

107

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

108

  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

109

  virtual uint32_t GetSerializedSize (void) const;

Lines 77-88	Link Here

  //                                   address */

121

  //                                   address */

  // };

122

  // };

123

  Ipv4Address m_addr;

124

  Ipv4Address m_addr;     //!< Header destination address

  Ipv4Address m_spec_dst;

125

  Ipv4Address m_spec_dst; //!< Local address

  uint32_t m_ifindex;

126

  uint32_t m_ifindex;     //!< interface index

127

  // Uset for IP_RECVTTL, though not implemented yet.

128

  // Used for IP_RECVTTL, though not implemented yet.

  uint8_t m_ttl;

129

  uint8_t m_ttl; //!< Time to Live

};

130

};

} // namespace ns3

131

} // namespace ns3

132

(-)a/src/internet/model/ipv4-packet-probe.h (+6 lines)

Lines 47-52	Link Here

class Ipv4PacketProbe : public Probe

class Ipv4PacketProbe : public Probe

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId ();

  static TypeId GetTypeId ();

  Ipv4PacketProbe ();

  Ipv4PacketProbe ();

  virtual ~Ipv4PacketProbe ();

  virtual ~Ipv4PacketProbe ();

Lines 102-108	Link Here

102

*/

106

*/

103

  void TraceSink (Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface);

107

  void TraceSink (Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface);

104

108

109

  /// Traced Callback: the packet, the Ipv4 object and the interface.

105

  TracedCallback<Ptr<const Packet>, Ptr<Ipv4>, uint32_t> m_output;

110

  TracedCallback<Ptr<const Packet>, Ptr<Ipv4>, uint32_t> m_output;

111

  /// Traced Callback: the previous packet's size and the actual packet's size.

106

  TracedCallback<uint32_t, uint32_t> m_outputBytes;

112

  TracedCallback<uint32_t, uint32_t> m_outputBytes;

107

113

108

  /// The traced packet.

114

  /// The traced packet.

(-)a/src/internet/model/ipv4-raw-socket-factory-impl.h (+6 lines)

Lines 25-30	Link Here

namespace ns3 {

namespace ns3 {

/**

 * \ingroup socket

 * \class Ipv4RawSocketFactoryImpl

 * \brief Implementation of IPv4 raw socket factory.

*/

class Ipv4RawSocketFactoryImpl : public Ipv4RawSocketFactory

class Ipv4RawSocketFactoryImpl : public Ipv4RawSocketFactory

public:

public:

(-)a/src/internet/model/ipv4-raw-socket-factory.h (+4 lines)

Lines 37-42	Link Here

class Ipv4RawSocketFactory : public SocketFactory

class Ipv4RawSocketFactory : public SocketFactory

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

};

};

(-)a/src/internet/model/ipv4-raw-socket-impl.h (-14 / +55 lines)

Lines 13-29	Link Here

class NetDevice;

class NetDevice;

class Node;

class Node;

/**

 * \class Ipv4RawSocketImpl

 * \brief IPv4 raw socket.

 * \ingroup socket

 * A RAW Socket typically is used to access specific IP layers not usually

 * available through L4 sockets, e.g., ICMP. The implementer should take

 * particular care to define the Ipv4RawSocketImpl Attributes, and in

 * particular the Protocol attribute.

*/

class Ipv4RawSocketImpl : public Socket

class Ipv4RawSocketImpl : public Socket

public:

public:

/**

   * \brief Get the type ID of this class.

   * \return type ID

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Ipv4RawSocketImpl ();

  Ipv4RawSocketImpl ();

/**

   * \brief Set the node associated with this socket.

   * \param node node to set

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

  virtual enum Socket::SocketErrno GetErrno (void) const;

  virtual enum Socket::SocketErrno GetErrno () const;

/**

   * \brief Get socket type (NS3_SOCK_RAW)

   * \return socket type

*/

  virtual enum Socket::SocketType GetSocketType (void) const;

  virtual enum Socket::SocketType GetSocketType (void) const;

  virtual Ptr<Node> GetNode (void) const;

  virtual Ptr<Node> GetNode (void) const;

  virtual int Bind (const Address &address);

  virtual int Bind (const Address &address);

  virtual int Bind ();

  virtual int Bind ();

Lines 43-49	Link Here

  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,

  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,

                                Address &fromAddress);

                                Address &fromAddress);

/**

   * \brief Set protocol field.

   * \param protocol protocol to set

*/

  void SetProtocol (uint16_t protocol);

  void SetProtocol (uint16_t protocol);

/**

   * \brief Forward up to receive method.

   * \param p packet

   * \param ipHeader IPv4 header

   * \param incomingInterface incoming interface

   * \return true if forwarded, false otherwise

*/

  bool ForwardUp (Ptr<const Packet> p, Ipv4Header ipHeader, Ptr<Ipv4Interface> incomingInterface);

  bool ForwardUp (Ptr<const Packet> p, Ipv4Header ipHeader, Ptr<Ipv4Interface> incomingInterface);

  virtual bool SetAllowBroadcast (bool allowBroadcast);

  virtual bool SetAllowBroadcast (bool allowBroadcast);

  virtual bool GetAllowBroadcast () const;

  virtual bool GetAllowBroadcast () const;

Lines 51-72	Link Here

private:

private:

  virtual void DoDispose (void);

  virtual void DoDispose (void);

/**

   * \struct Data

   * \brief IPv4 raw data and additional information.

*/

  struct Data {

  struct Data {

    Ptr<Packet> packet;

    Ptr<Packet> packet;  /**< Packet data */

    Ipv4Address fromIp;

    Ipv4Address fromIp;  /**< Source address */

    uint16_t fromProtocol;

    uint16_t fromProtocol;   /**< Protocol used */

};

};

100

  enum Socket::SocketErrno m_err;

101

  enum Socket::SocketErrno m_err;   //!< Last error number.

  Ptr<Node> m_node;

102

  Ptr<Node> m_node;                 //!< Node

  Ipv4Address m_src;

103

  Ipv4Address m_src;                //!< Source address.

  Ipv4Address m_dst;

104

  Ipv4Address m_dst;                //!< Destination address.

  uint16_t m_protocol;

105

  uint16_t m_protocol;              //!< Protocol.

  std::list<struct Data> m_recv;

106

  std::list<struct Data> m_recv;    //!< Packet waiting to be processed.

  bool m_shutdownSend;

107

  bool m_shutdownSend;              //!< Flag to shutdown send capability.

  bool m_shutdownRecv;

108

  bool m_shutdownRecv;              //!< Flag to shutdown receive capability.

  uint32_t m_icmpFilter;

109

  uint32_t m_icmpFilter;            //!< ICMPv4 filter specification

  bool m_iphdrincl;

110

  bool m_iphdrincl;                 //!< Include IP Header information (a.k.a setsockopt (IP_HDRINCL))

};

111

};

112

} // namespace ns3

113

} // namespace ns3




#endif

private:
  Ipv4Address m_dest;             //!< Destination address.
  Ipv4Address m_source;           //!< Source address.
  Ipv4Address m_gateway;          //!< Gateway address.
  Ptr<NetDevice> m_outputDevice;  //!< Output device.
#ifdef NOTYET
  uint32_t m_inputIfIndex;
#endif
};

/**
 * \brief Stream insertion operator.
 *
 * \param os the reference to the output stream
 * \param route the Ipv4 route
 * \returns the reference to the output stream
 */
std::ostream& operator<< (std::ostream& os, Ipv4Route const& route);

/**

   */
  std::map<uint32_t, uint32_t> GetOutputTtlMap () const;

  static const uint32_t MAX_INTERFACES = 16;  //!< Maximum number of multicast interfaces on a router
  static const uint32_t MAX_TTL = 255;  //!< Maximum time-to-live (TTL)

private:
  Ipv4Address m_group;      //!< Group
  Ipv4Address m_origin;     //!< Source of packet
  uint32_t m_parent;        //!< Source interface
  std::map<uint32_t, uint32_t> m_ttls; //!< Time to Live container
};

} // namespace ns3

(-)a/src/internet/model/ipv4-routing-table-entry.h (-8 / +53 lines)

Lines 135-159	Link Here

135

                                                   uint32_t interface);

135

                                                   uint32_t interface);

136

137

private:

137

private:

138

/**

139

   * \brief Constructor.

140

   * \param network network address

141

   * \param mask network mask

142

   * \param gateway the gateway

143

   * \param interface the interface index

144

*/

138

  Ipv4RoutingTableEntry (Ipv4Address network,

145

  Ipv4RoutingTableEntry (Ipv4Address network,

139

                         Ipv4Mask mask,

146

                         Ipv4Mask mask,

140

                         Ipv4Address gateway,

147

                         Ipv4Address gateway,

141

                         uint32_t interface);

148

                         uint32_t interface);

149

/**

150

   * \brief Constructor.

151

   * \param dest destination address

152

   * \param mask network mask

153

   * \param interface the interface index

154

*/

142

  Ipv4RoutingTableEntry (Ipv4Address dest,

155

  Ipv4RoutingTableEntry (Ipv4Address dest,

143

                         Ipv4Mask mask,

156

                         Ipv4Mask mask,

144

                         uint32_t interface);

157

                         uint32_t interface);

158

/**

159

   * \brief Constructor.

160

   * \param dest destination address

161

   * \param gateway the gateway

162

   * \param interface the interface index

163

*/

145

  Ipv4RoutingTableEntry (Ipv4Address dest,

164

  Ipv4RoutingTableEntry (Ipv4Address dest,

146

                         Ipv4Address gateway,

165

                         Ipv4Address gateway,

147

                         uint32_t interface);

166

                         uint32_t interface);

167

/**

168

   * \brief Constructor.

169

   * \param dest destination address

170

   * \param interface the interface index

171

*/

148

  Ipv4RoutingTableEntry (Ipv4Address dest,

172

  Ipv4RoutingTableEntry (Ipv4Address dest,

149

                         uint32_t interface);

173

                         uint32_t interface);

150

174

151

  Ipv4Address m_dest;

175

  Ipv4Address m_dest;         //!< destination address

152

  Ipv4Mask m_destNetworkMask;

176

  Ipv4Mask m_destNetworkMask; //!< destination network mask

153

  Ipv4Address m_gateway;

177

  Ipv4Address m_gateway;      //!< gateway

154

  uint32_t m_interface;

178

  uint32_t m_interface;       //!< output interface

155

};

179

};

156

180

181

/**

182

 * \brief Stream insertion operator.

183

184

 * \param os the reference to the output stream

185

 * \param route the Ipv4 routing table entry

186

 * \returns the reference to the output stream

187

*/

157

std::ostream& operator<< (std::ostream& os, Ipv4RoutingTableEntry const& route);

188

std::ostream& operator<< (std::ostream& os, Ipv4RoutingTableEntry const& route);

158

189

159

/**

190

/**

Lines 215-229	Link Here

215

                                                              std::vector<uint32_t> outputInterfaces);

246

                                                              std::vector<uint32_t> outputInterfaces);

216

247

217

private:

248

private:

249

/**

250

   * \brief Constructor.

251

   * \param origin source address

252

   * \param group destination address

253

   * \param inputInterface input interface

254

   * \param outputInterfaces output interfaces

255

*/

218

  Ipv4MulticastRoutingTableEntry (Ipv4Address origin, Ipv4Address group,

256

  Ipv4MulticastRoutingTableEntry (Ipv4Address origin, Ipv4Address group,

219

                                  uint32_t inputInterface, std::vector<uint32_t> outputInterfaces);

257

                                  uint32_t inputInterface, std::vector<uint32_t> outputInterfaces);

220

258

221

  Ipv4Address m_origin;

259

  Ipv4Address m_origin;   //!< source address

222

  Ipv4Address m_group;

260

  Ipv4Address m_group;    //!< destination address

223

  uint32_t m_inputInterface;

261

  uint32_t m_inputInterface;    //!< input interface

224

  std::vector<uint32_t> m_outputInterfaces;

262

  std::vector<uint32_t> m_outputInterfaces;   //!< output interfaces

225

};

263

};

226

264

265

/**

266

 * \brief Stream insertion operator.

267

268

 * \param os the reference to the output stream

269

 * \param route the Ipv4 multicast routing table entry

270

 * \returns the reference to the output stream

271

*/

227

std::ostream& operator<< (std::ostream& os, Ipv4MulticastRoutingTableEntry const& route);

272

std::ostream& operator<< (std::ostream& os, Ipv4MulticastRoutingTableEntry const& route);

228

273

229

} // namespace ns3

274

} // namespace ns3

(-)a/src/internet/model/ipv4-static-routing.h (+46 lines)

Lines 69-74	Link Here

class Ipv4StaticRouting : public Ipv4RoutingProtocol

class Ipv4StaticRouting : public Ipv4RoutingProtocol

public:

public:

/**

   * \brief The interface Id associated with this class.

   * \return type identifier

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Ipv4StaticRouting ();

  Ipv4StaticRouting ();

Lines 177-182	Link Here

177

 * to the routing table.

181

 * to the routing table.

178

182

179

 * \warning The default route counts as one of the routes.

183

 * \warning The default route counts as one of the routes.

184

 * \return number of entries

180

*/

185

*/

181

  uint32_t GetNRoutes (void) const;

186

  uint32_t GetNRoutes (void) const;

182

187

Lines 308-313	Link Here

308

 * to the routing table.

313

 * to the routing table.

309

314

310

 * \warning The default multicast route counts as one of the routes.

315

 * \warning The default multicast route counts as one of the routes.

316

 * \return number of entries

311

*/

317

*/

312

  uint32_t GetNMulticastRoutes (void) const;

318

  uint32_t GetNMulticastRoutes (void) const;

313

319

Lines 375-397	Link Here

375

  virtual void DoDispose (void);

381

  virtual void DoDispose (void);

376

382

377

private:

383

private:

384

  /// Container for the network routes

378

  typedef std::list<std::pair <Ipv4RoutingTableEntry *, uint32_t> > NetworkRoutes;

385

  typedef std::list<std::pair <Ipv4RoutingTableEntry *, uint32_t> > NetworkRoutes;

386

387

  /// Const Iterator for container for the network routes

379

  typedef std::list<std::pair <Ipv4RoutingTableEntry *, uint32_t> >::const_iterator NetworkRoutesCI;

388

  typedef std::list<std::pair <Ipv4RoutingTableEntry *, uint32_t> >::const_iterator NetworkRoutesCI;

389

390

  /// Iterator for container for the network routes

380

  typedef std::list<std::pair <Ipv4RoutingTableEntry *, uint32_t> >::iterator NetworkRoutesI;

391

  typedef std::list<std::pair <Ipv4RoutingTableEntry *, uint32_t> >::iterator NetworkRoutesI;

381

392

393

  /// Container for the multicast routes

382

  typedef std::list<Ipv4MulticastRoutingTableEntry *> MulticastRoutes;

394

  typedef std::list<Ipv4MulticastRoutingTableEntry *> MulticastRoutes;

395

396

  /// Const Iterator for container for the multicast routes

383

  typedef std::list<Ipv4MulticastRoutingTableEntry *>::const_iterator MulticastRoutesCI;

397

  typedef std::list<Ipv4MulticastRoutingTableEntry *>::const_iterator MulticastRoutesCI;

398

399

  /// Iterator for container for the multicast routes

384

  typedef std::list<Ipv4MulticastRoutingTableEntry *>::iterator MulticastRoutesI;

400

  typedef std::list<Ipv4MulticastRoutingTableEntry *>::iterator MulticastRoutesI;

385

401

402

/**

403

   * \brief Lookup in the forwarding table for destination.

404

   * \param dest destination address

405

   * \param oif output interface if any (put 0 otherwise)

406

   * \return Ipv4Route to route the packet to reach dest address

407

*/

386

  Ptr<Ipv4Route> LookupStatic (Ipv4Address dest, Ptr<NetDevice> oif = 0);

408

  Ptr<Ipv4Route> LookupStatic (Ipv4Address dest, Ptr<NetDevice> oif = 0);

409

410

/**

411

   * \brief Lookup in the multicast forwarding table for destination.

412

   * \param origin source address

413

   * \param group group multicast address

414

   * \param interface interface index

415

   * \return Ipv4MulticastRoute to route the packet to reach dest address

416

*/

387

  Ptr<Ipv4MulticastRoute> LookupStatic (Ipv4Address origin, Ipv4Address group,

417

  Ptr<Ipv4MulticastRoute> LookupStatic (Ipv4Address origin, Ipv4Address group,

388

                                        uint32_t interface);

418

                                        uint32_t interface);

389

419

420

/**

421

   * \brief Choose the source address to use with destination address.

422

   * \param interface interface index

423

   * \param dest IPv4 destination address

424

   * \return IPv4 source address to use

425

*/

390

  Ipv4Address SourceAddressSelection (uint32_t interface, Ipv4Address dest);

426

  Ipv4Address SourceAddressSelection (uint32_t interface, Ipv4Address dest);

391

427

428

/**

429

   * \brief the forwarding table for network.

430

*/

392

  NetworkRoutes m_networkRoutes;

431

  NetworkRoutes m_networkRoutes;

432

433

/**

434

   * \brief the forwarding table for multicast.

435

*/

393

  MulticastRoutes m_multicastRoutes;

436

  MulticastRoutes m_multicastRoutes;

394

437

438

/**

439

   * \brief Ipv4 reference.

440

*/

395

  Ptr<Ipv4> m_ipv4;

441

  Ptr<Ipv4> m_ipv4;

396

};

442

};

397

443

(-)a/src/internet/model/ipv4.h (-1 / +28 lines)

Lines 75-80	Link Here

class Ipv4 : public Object

class Ipv4 : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Ipv4 ();

  Ipv4 ();

  virtual ~Ipv4 ();

  virtual ~Ipv4 ();

Lines 167-172	Link Here

167

171

168

   * \param address The IP address being considered

172

   * \param address The IP address being considered

169

   * \param iif The incoming Ipv4 interface index

173

   * \param iif The incoming Ipv4 interface index

174

   * \returns true if the address is associated with the interface index

170

175

171

   * This method can be used to determine whether a received packet has

176

   * This method can be used to determine whether a received packet has

172

   * an acceptable address for local delivery on the host.  The address

177

   * an acceptable address for local delivery on the host.  The address

Lines 378-390	Link Here

378

  virtual void DeleteRawSocket (Ptr<Socket> socket) = 0;

383

  virtual void DeleteRawSocket (Ptr<Socket> socket) = 0;

379

384

380

385

381

  static const uint32_t IF_ANY = 0xffffffff;

386

  static const uint32_t IF_ANY = 0xffffffff; //!< interface wildcard, meaning any interface

382

387

383

private:

388

private:

384

  // Indirect the Ipv4 attributes through private pure virtual methods

389

  // Indirect the Ipv4 attributes through private pure virtual methods

390

391

/**

392

   * \brief Set or unset the IP forwarding state

393

   * \param forward the forwarding state

394

*/

385

  virtual void SetIpForward (bool forward) = 0;

395

  virtual void SetIpForward (bool forward) = 0;

396

/**

397

   * \brief Get the IP forwarding state

398

   * \returns true if IP is in forwarding state

399

*/

386

  virtual bool GetIpForward (void) const = 0;

400

  virtual bool GetIpForward (void) const = 0;

401

402

/**

403

   * \brief Set or unset the Weak Es Model

404

405

   * RFC1122 term for whether host accepts datagram with a dest. address on another interface

406

   * \param model true for Weak Es Model

407

*/

387

  virtual void SetWeakEsModel (bool model) = 0;

408

  virtual void SetWeakEsModel (bool model) = 0;

409

/**

410

   * \brief Get the Weak Es Model status

411

412

   * RFC1122 term for whether host accepts datagram with a dest. address on another interface

413

   * \returns true for Weak Es Model activated

414

*/

388

  virtual bool GetWeakEsModel (void) const = 0;

415

  virtual bool GetWeakEsModel (void) const = 0;

389

};

416

};

390

417

(-)a/src/internet/model/ipv6-address-generator.h (-1 / +1 lines)

Lines 51-57	Link Here

 * but can also be a pseudo-random value (\RFC{3041}).  This implementation

 * but can also be a pseudo-random value (\RFC{3041}).  This implementation

 * does not generate EUI-64-based interface IDs.

 * does not generate EUI-64-based interface IDs.

 * BEWARE: this class acts as a Singleton.

 * \note BEWARE: this class acts as a Singleton.

 * In other terms, two different instances of Ipv6AddressGenerator will

 * In other terms, two different instances of Ipv6AddressGenerator will

 * pick IPv6 numbers from the same pool. Changing the network in one of them

 * pick IPv6 numbers from the same pool. Changing the network in one of them

 * will also change the network in the other instances.

 * will also change the network in the other instances.




   */
  typedef std::list<Ipv6EndPoint *>::iterator EndPointsI;

  /**
   * \brief Constructor.
   */
  Ipv6EndPointDemux ();

  /**
   * \brief Destructor.
   */
  ~Ipv6EndPointDemux ();

  /**

   * \param src source address to test
   * \param sport source port to test
   * \param incomingInterface the incoming interface
   * \return list of IPv6EndPoints (could be 0 element)
   */
  EndPoints Lookup (Ipv6Address dst, uint16_t dport, Ipv6Address src, uint16_t sport, Ptr<Ipv6Interface> incomingInterface);


(-)a/src/internet/model/ipv6-end-point.h (-8 / +17 lines)

Lines 35-42	Link Here

class Packet;

class Packet;

/**

/**

 * \class Ipv6EndPoint

 * \brief A representation of an internet IPv6 endpoint/connection

 * \brief An IPv6 end point, four tuples identification.

 * This class provides an internet four-tuple (source and destination ports

 * and addresses).  These are used in the ns3::Ipv6EndPointDemux as targets

 * of lookups.  The class also has a callback for notification to higher

 * layers that a packet from a lower layer was received.  In the ns3

 * internet-stack, these notifications are automatically registered to be

 * received by the corresponding socket.

*/

*/

class Ipv6EndPoint

class Ipv6EndPoint

Lines 48-56	Link Here

*/

*/

  Ipv6EndPoint (Ipv6Address addr, uint16_t port);

  Ipv6EndPoint (Ipv6Address addr, uint16_t port);

/**

   * \brief Destructor.

*/

  ~Ipv6EndPoint ();

  ~Ipv6EndPoint ();

/**

/**

Lines 113-119	Link Here

113

   * the socket can not receive any packets as a result.

116

   * the socket can not receive any packets as a result.

114

117

115

   * \param netdevice Pointer to Netdevice of desired interface

118

   * \param netdevice Pointer to Netdevice of desired interface

116

   * \returns nothing

117

*/

119

*/

118

  void BindToNetDevice (Ptr<NetDevice> netdevice);

120

  void BindToNetDevice (Ptr<NetDevice> netdevice);

119

121

Lines 148-153	Link Here

148

150

149

/**

151

/**

150

   * \brief Forward the packet to the upper level.

152

   * \brief Forward the packet to the upper level.

153

154

   * Called from an L4Protocol implementation to notify an endpoint of a

155

   * packet reception.

156

151

   * \param p the packet

157

   * \param p the packet

152

   * \param header the packet header

158

   * \param header the packet header

153

   * \param port source port

159

   * \param port source port

Lines 155-162	Link Here

155

  void ForwardUp (Ptr<Packet> p, Ipv6Header header, uint16_t port);

161

  void ForwardUp (Ptr<Packet> p, Ipv6Header header, uint16_t port);

156

162

157

/**

163

/**

158

   * \brief Function called from an L4Protocol implementation

164

   * \brief Forward the ICMP packet to the upper level.

159

   * to notify an endpoint of an icmp message reception.

165

166

   * Called from an L4Protocol implementation to notify an endpoint of

167

   * an icmp message reception.

168

160

   * \param src source IPv6 address

169

   * \param src source IPv6 address

161

   * \param ttl time-to-live

170

   * \param ttl time-to-live

162

   * \param type ICMPv6 type

171

   * \param type ICMPv6 type

(-)a/src/internet/model/ipv6-interface-address.h (-1 / +1 lines)

Lines 53-59	Link Here

/**

/**

   * \enum Scope_e

   * \enum Scope_e

   * \brief Scope of address.

   * \brief Address scope.

*/

*/

  enum Scope_e

  enum Scope_e

(-)a/src/internet/model/ipv6-interface.h (-2 / +2 lines)

Lines 42-48	Link Here

 * \brief The IPv6 representation of a network interface

 * \brief The IPv6 representation of a network interface

 * By default IPv6 interfaces are created in the "down" state

 * By default IPv6 interfaces are created in the "down" state

 * with IP "fe80::1" and a /64 prefix. Before becoming useable,

 * with IP "fe80::1" and a /64 prefix. Before becoming usable,

 * the user must invoke SetUp on them once the final IPv6 address

 * the user must invoke SetUp on them once the final IPv6 address

 * and mask has been set.

 * and mask has been set.

*/

*/

Lines 268-274	Link Here

268

  typedef std::list<Ipv6InterfaceAddress>::iterator Ipv6InterfaceAddressListI;

268

  typedef std::list<Ipv6InterfaceAddress>::iterator Ipv6InterfaceAddressListI;

269

270

/**

270

/**

271

   * \brief Const Container Itareator for the Ipv6InterfaceAddresses.

271

   * \brief Const Container Iterator for the Ipv6InterfaceAddresses.

272

*/

272

*/

273

  typedef std::list<Ipv6InterfaceAddress>::const_iterator Ipv6InterfaceAddressListCI;

273

  typedef std::list<Ipv6InterfaceAddress>::const_iterator Ipv6InterfaceAddressListCI;

274




  virtual ~Ipv6L3Protocol ();

  /**
   * \brief Set node associated with this stack.
   * \param node node to set
   */
  void SetNode (Ptr<Node> node);


  /**
   * \brief Copy constructor.
   *
   * Defined but not implemented to avoid misuse
   */
  Ipv6L3Protocol (const Ipv6L3Protocol&);

  /**
   * \brief Copy constructor.
   *
   * Defined but not implemented to avoid misuse
   * \returns the copied object
   */
  Ipv6L3Protocol &operator = (const Ipv6L3Protocol&);

  /**
   * \brief Construct an IPv6 header.

  void IpForward (Ptr<const NetDevice> idev, Ptr<Ipv6Route> rtentry, Ptr<const Packet> p, const Ipv6Header& header);

  /**
   * \brief Forward a multicast packet.
   * \param idev Pointer to ingress network device
   * \param mrtentry route 
   * \param p packet to forward




   */
  static bool Compare (const Ipv6RoutingProtocolEntry& a, const Ipv6RoutingProtocolEntry& b);

  Ipv6RoutingProtocolList m_routingProtocols; //!<  List of routing protocols.
  Ptr<Ipv6> m_ipv6;  //!< Ipv6 this protocol is associated with.
   */
  Ipv6RoutingProtocolList m_routingProtocols;

  /**
   * \brief Ipv6 reference.
   */
  Ptr<Ipv6> m_ipv6;
};

} // namespace ns3

(-)a/src/internet/model/ipv6-raw-socket-factory-impl.h (+2 lines)

Lines 27-32	Link Here

/**

/**

 * \ingroup socket

 * \class Ipv6RawSocketFactoryImpl

 * \class Ipv6RawSocketFactoryImpl

 * \brief Implementation of IPv6 raw socket factory.

 * \brief Implementation of IPv6 raw socket factory.

*/

*/




/**
 * \class Ipv6RawSocketImpl
 * \brief IPv6 raw socket.
 * \ingroup socket
 *
 * A RAW Socket typically is used to access specific IP layers not usually
 * available through L4 sockets, e.g., ICMP. The implementer should take

   */
  static TypeId GetTypeId ();

  /**
   * \brief Constructor.
   */
  Ipv6RawSocketImpl ();

  /**
   * \brief Destructor.
   */
  virtual ~Ipv6RawSocketImpl ();

  /**
   * \brief Set the node associated with this socket.
   * \param node node to set
   */
  void SetNode (Ptr<Node> node);

  /**
   * \brief Get last error number.
   * \return error number
   */
  virtual enum Socket::SocketErrno GetErrno () const;

  /**

   */
  virtual enum Socket::SocketType GetSocketType () const;

  /**
   * \brief Get node.
   * \return node associated with this raw socket.
   */
  virtual Ptr<Node> GetNode () const;

  /**
   * \brief Bind the socket to address.
   * \param address bind to this address
   * \return 0 if success, -1 otherwise
   */
  virtual int Bind (const Address& address);

  /**
   * \brief Bind socket.
   * \return 0 if success, -1 otherwise
   */
  virtual int Bind ();
  virtual int Bind6 ();

  /**
   * \brief Get socket address.
   * \param address socket address if method success
   * \return 0 if success, -1 otherwise
   */
  virtual int GetSockName (Address& address) const;

  /**
   * \brief Close the socket.
   * \return 0 if success, -1 otherwise
   */
  virtual int Close ();

  /**
   * \brief Shutdown send capability.
   * \return 0 if success, -1 otherwise
   */
  virtual int ShutdownSend ();

  /**
   * \brief Shutdown receive capability.
   * \return 0 if success, -1 otherwise
   */
  virtual int ShutdownRecv ();

  /**
   * \brief Connect to address.
   * \param address address
   * \return 0 if success, -1 otherwise
   */
  virtual int Connect (const Address& address);

  /**
   * \brief Listen.
   * \return 0 if success, -1 otherwise
   */
  virtual int Listen ();

  /**
   * \brief Get TX size available.
   * \return TX size
   */
  virtual uint32_t GetTxAvailable () const;

  /**
   * \brief Get RX size available.
   * \return RX size
   */
  virtual uint32_t GetRxAvailable () const;

  /**
   * \brief Send a packet.
   * \param p packet to send
   * \param flags additionnal flags
   * \return 0 if success, -1 otherwise
   */
  virtual int Send (Ptr<Packet> p, uint32_t flags);

  /**
   * \brief Send a packet.
   * \param p packet to send
   * \param flags additionnal flags
   * \param toAddress destination address
   * \return 0 if success, -1 otherwise
   */
  virtual int SendTo (Ptr<Packet> p, uint32_t flags, const Address& toAddress);

  /**
   * \brief Receive packet.
   * \param maxSize maximum size
   * \param flags additionnal flags
   * \return packet received
   */
  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);

  /**
   * \brief Receive packet.
   * \param maxSize maximum size
   * \param flags additionnal flags
   * \param fromAddress source address
   * \return packet received
   */
  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags, Address& fromAddress);

  /**




};

/**
 * \brief Stream insertion operator.
 *
 * \param os the reference to the output stream
 * \param route the Ipv6 routing table entry
 * \returns the reference to the output stream
 */
std::ostream& operator<< (std::ostream& os, Ipv6RoutingTableEntry const& route);

/**

};

/**
 * \brief Stream insertion operator.
 *
 * \param os the reference to the output stream
 * \param route the Ipv6 multicast routing table entry
 * \returns the reference to the output stream
 */
std::ostream& operator<< (std::ostream& os, Ipv6MulticastRoutingTableEntry const& route);

} /* namespace ns3 */




/**
 * \ingroup ipv6StaticRouting
 * \class Ipv6StaticRouting
 *
 * \brief Static routing protocol for IP version 6 stacks.
 *
 * This class provides a basic set of methods for inserting static
 * unicast and multicast routes into the Ipv6 routing system.
 * This particular protocol is designed to be inserted into an
 * Ipv6ListRouting protocol but can be used also as a standalone
 * protocol.
 *
 * The Ipv6StaticRouting class inherits from the abstract base class
 * Ipv6RoutingProtocol that defines the interface methods that a routing
 * protocol must support.
 *
 * \see Ipv6RoutingProtocol
 * \see Ipv6ListRouting
 * \see Ipv6ListRouting::AddRoutingProtocol
 */
class Ipv6StaticRouting : public Ipv6RoutingProtocol
{

   */
  static TypeId GetTypeId ();

  /**
   * \brief Constructor.
   */
  Ipv6StaticRouting ();

  /**
   * \brief Destructor.
   */
  virtual ~Ipv6StaticRouting ();

  /**

(-)a/src/internet/model/loopback-net-device.h (-4 / +25 lines)

Lines 38-43	Link Here

class LoopbackNetDevice : public NetDevice

class LoopbackNetDevice : public NetDevice

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  LoopbackNetDevice ();

  LoopbackNetDevice ();

Lines 72-84	Link Here

protected:

protected:

  virtual void DoDispose (void);

  virtual void DoDispose (void);

private:

private:

/**

   * Receive a packet from tge Loopback NetDevice.

   * \param packet a reference to the received packet

   * \param protocol the protocol

   * \param to destination address

   * \param from source address

*/

  void Receive (Ptr<Packet> packet, uint16_t protocol, Mac48Address to, Mac48Address from);

  void Receive (Ptr<Packet> packet, uint16_t protocol, Mac48Address to, Mac48Address from);

/**

   * The callback used to notify higher layers that a packet has been received.

*/

  NetDevice::ReceiveCallback m_rxCallback;

  NetDevice::ReceiveCallback m_rxCallback;

/**

   * The callback used to notify higher layers that a packet has been received in promiscuous mode.

*/

  NetDevice::PromiscReceiveCallback m_promiscCallback;

  NetDevice::PromiscReceiveCallback m_promiscCallback;

  Ptr<Node> m_node;

  uint16_t m_mtu;

  Ptr<Node> m_node; //!< the node this NetDevice is associated with

  uint32_t m_ifIndex;

100

  uint16_t m_mtu; //!< device MTU

  Mac48Address m_address;

101

  uint32_t m_ifIndex; //!< interface index

102

  Mac48Address m_address; //!< NetDevice MAC address

};

103

};

104

} // namespace ns3

105

} // namespace ns3

(-)a/src/internet/model/ndisc-cache.h (-5 / +14 lines)

Lines 412-431	Link Here

412

};

412

};

413

414

private:

414

private:

415

/**

416

   * \brief Neighbor Discovery Cache container

417

*/

415

  typedef sgi::hash_map<Ipv6Address, NdiscCache::Entry *, Ipv6AddressHash> Cache;

418

  typedef sgi::hash_map<Ipv6Address, NdiscCache::Entry *, Ipv6AddressHash> Cache;

419

/**

420

   * \brief Neighbor Discovery Cache container iterator

421

*/

416

  typedef sgi::hash_map<Ipv6Address, NdiscCache::Entry *, Ipv6AddressHash>::iterator CacheI;

422

  typedef sgi::hash_map<Ipv6Address, NdiscCache::Entry *, Ipv6AddressHash>::iterator CacheI;

417

423

418

/**

424

/**

419

   * \brief Copy constructor.

425

   * \brief Copy constructor.

420

   * \param a cache to copy

426

427

   * Not implemented to avoid misuse

421

*/

428

*/

422

  NdiscCache (NdiscCache const &a);

429

  NdiscCache (NdiscCache const &);

423

430

424

/**

431

/**

425

   * \brief Equal operator.

432

   * \brief Copy constructor.

426

   * \param a cache to copy

433

434

   * Not implemented to avoid misuse

435

   * \returns

427

*/

436

*/

428

  NdiscCache& operator= (NdiscCache const &a);

437

  NdiscCache& operator= (NdiscCache const &);

429

438

430

/**

439

/**

431

   * \brief Dispose this object.

440

   * \brief Dispose this object.

(-)a/src/internet/model/nsc-sysctl.cc (-1 / +11 lines)

Lines 23-31	Link Here

namespace ns3 {

namespace ns3 {

/**

 * \ingroup nsctcp

 * This object represent the underlying nsc stack attributes and

 * provide a ns-3-like system to access them though sysctls

*/

class NscStackStringAccessor : public AttributeAccessor

class NscStackStringAccessor : public AttributeAccessor

public:

public:

/**

   * \brief Constructor

   * \param name name of the attribute

*/

  NscStackStringAccessor (std::string name) : m_name (name) {}

  NscStackStringAccessor (std::string name) : m_name (name) {}

  virtual bool Set (ObjectBase * object, const AttributeValue &val) const;

  virtual bool Set (ObjectBase * object, const AttributeValue &val) const;

Lines 33-39	Link Here

  virtual bool HasGetter (void) const;

  virtual bool HasGetter (void) const;

  virtual bool HasSetter (void) const;

  virtual bool HasSetter (void) const;

private:

private:

  std::string m_name;

  std::string m_name; //!< name of the attribute

};

};

bool NscStackStringAccessor::HasGetter (void) const

bool NscStackStringAccessor::HasGetter (void) const

(-)a/src/internet/model/nsc-sysctl.h (-4 / +26 lines)

Lines 25-44	Link Here

namespace ns3 {

namespace ns3 {

// This object represents the underlying nsc stack,

/**

// which is aggregated to a Node object, and which provides access to the

 * \ingroup nsctcp

// sysctls of the nsc stack through attributes.

 * This object represents the underlying nsc stack,

 * which is aggregated to a Node object, and which provides access to the

 * sysctls of the nsc stack through attributes.

*/

class Ns3NscStack : public Object

class Ns3NscStack : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual TypeId GetInstanceTypeId (void) const;

/**

   * \brief Set the underlying stack

   * \param stack the stack

*/

  void SetStack (INetStack *stack) { m_stack = stack; }

  void SetStack (INetStack *stack) { m_stack = stack; }

private:

private:

  friend class NscStackStringAccessor;

  friend class NscStackStringAccessor;

/**

   * \brief Set an attribute

   * \param name the attribute name

   * \param value the attribute value

*/

  void Set (std::string name, std::string value);

  void Set (std::string name, std::string value);

/**

   * \brief Get an attribute

   * \param name the attribute name

   * \returns the attribute value

*/

  std::string Get (std::string name) const;

  std::string Get (std::string name) const;

  INetStack *m_stack;

  INetStack *m_stack; //!< the underlying stack

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/internet/model/nsc-tcp-l4-protocol.cc (-4 / +40 lines)

Lines 55-70	Link Here

/* see http://www.iana.org/assignments/protocol-numbers */

/* see http://www.iana.org/assignments/protocol-numbers */

const uint8_t NscTcpL4Protocol::PROT_NUMBER = 6;

const uint8_t NscTcpL4Protocol::PROT_NUMBER = 6;

/**

 * \ingroup nsctcp

 * \brief Nsc interface implementation class.

*/

class NscInterfaceImpl : public ISendCallback, public IInterruptCallback

class NscInterfaceImpl : public ISendCallback, public IInterruptCallback

public:

public:

/**

   * Constructor

   * \param prot the NSC TCP protocol

*/

  NscInterfaceImpl (Ptr<NscTcpL4Protocol> prot);

  NscInterfaceImpl (Ptr<NscTcpL4Protocol> prot);

private:

private:

/**

   * \brief Invoked by NSCs 'ethernet driver' to re-inject a packet into ns-3.

   * A packet is an octet soup consisting of an IP Header, TCP Header

   * and user payload, if any

   * \param data the data

   * \param datalen the data length

*/

  virtual void send_callback (const void *data, int datalen);

  virtual void send_callback (const void *data, int datalen);

/**

   * \brief Called by the NSC stack whenever something of interest has happened

   * Examples: when data arrives on a socket, a listen socket

   * has a new connection pending, etc.

*/

  virtual void wakeup ();

  virtual void wakeup ();

/**

   * \brief Called by the Linux stack RNG initialization

   * Its also used by the cradle code to add a timestamp to

   * printk/printf/debug output.

*/

  virtual void gettime (unsigned int *, unsigned int *);

  virtual void gettime (unsigned int *, unsigned int *);

private:

private:

  Ptr<NscTcpL4Protocol> m_prot;

  Ptr<NscTcpL4Protocol> m_prot; //!< the NSC TCP protocol

};

};

NscInterfaceImpl::NscInterfaceImpl (Ptr<NscTcpL4Protocol> prot)

NscInterfaceImpl::NscInterfaceImpl (Ptr<NscTcpL4Protocol> prot)

Lines 113-121	Link Here

113

  return tid;

142

  return tid;

114

143

115

144

145

/**

146

 * \brief External Random number generator

147

148

 * \todo make it random...

149

150

 * \returns a random number

151

*/

116

int external_rand ()

152

int external_rand ()

117

153

118

  return 1;   /// \todo

154

  return 1;

119

155

120

156

121

NscTcpL4Protocol::NscTcpL4Protocol ()

157

NscTcpL4Protocol::NscTcpL4Protocol ()

Lines 385-391	Link Here

385

421

386

void NscTcpL4Protocol::wakeup ()

422

void NscTcpL4Protocol::wakeup ()

387

423

388

  /// \todo

424

  // \todo

389

  // this should schedule a timer to read from all tcp sockets now... this is

425

  // this should schedule a timer to read from all tcp sockets now... this is

390

  // an indication that data might be waiting on the socket

426

  // an indication that data might be waiting on the socket

391

427

Lines 451-457	Link Here

451

          // IP address of the subnet but this was found to fail for

487

          // IP address of the subnet but this was found to fail for

452

          // some use cases in /30 subnets.

488

          // some use cases in /30 subnets.

453

489

454

          /// \todo \bugid{1398} NSC's limitation to single-interface nodes

490

          // \todo \bugid{1398} NSC's limitation to single-interface nodes

455

          m_nscStack->add_default_gateway (addrOss.str ().c_str ());

491

          m_nscStack->add_default_gateway (addrOss.str ().c_str ());

456

492

457

493

(-)a/src/internet/model/nsc-tcp-l4-protocol.h (-33 / +116 lines)

Lines 45-62	Link Here

*/

*/

class NscTcpL4Protocol : public IpL4Protocol {

class NscTcpL4Protocol : public IpL4Protocol {

public:

public:

  static const uint8_t PROT_NUMBER;

  static const uint8_t PROT_NUMBER; //!< protocol number (0x6)

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

   * \brief Constructor

*/

  NscTcpL4Protocol ();

  NscTcpL4Protocol ();

  virtual ~NscTcpL4Protocol ();

  virtual ~NscTcpL4Protocol ();

/**

   * Set node associated with this stack

   * \param node the node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

/**

   * Set the NSC library to be used

   * \param lib the library path

*/

  void SetNscLibrary (const std::string &lib);

  void SetNscLibrary (const std::string &lib);

/**

   * Get the NSC library being used

   * \returns the library path

*/

  std::string GetNscLibrary (void) const;

  std::string GetNscLibrary (void) const;

  virtual int GetProtocolNumber (void) const;

  virtual int GetProtocolNumber (void) const;

/**

   * Get the NSC version

   * \returns the NSC version

*/

  virtual int GetVersion (void) const;

  virtual int GetVersion (void) const;

/**

/**

Lines 65-91	Link Here

*/

*/

  Ptr<Socket> CreateSocket (void);

  Ptr<Socket> CreateSocket (void);

/**

   * \brief Allocate an IPv4 Endpoint

   * \return the Endpoint

*/

  Ipv4EndPoint *Allocate (void);

  Ipv4EndPoint *Allocate (void);

/**

   * \brief Allocate an IPv4 Endpoint

   * \param address address to use

   * \return the Endpoint

*/

  Ipv4EndPoint *Allocate (Ipv4Address address);

  Ipv4EndPoint *Allocate (Ipv4Address address);

100

/**

101

   * \brief Allocate an IPv4 Endpoint

102

   * \param port port to use

103

   * \return the Endpoint

104

*/

  Ipv4EndPoint *Allocate (uint16_t port);

105

  Ipv4EndPoint *Allocate (uint16_t port);

106

/**

107

   * \brief Allocate an IPv4 Endpoint

108

   * \param address address to use

109

   * \param port port to use

110

   * \return the Endpoint

111

*/

  Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port);

112

  Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port);

113

/**

114

   * \brief Allocate an IPv4 Endpoint

115

   * \param localAddress local address to use

116

   * \param localPort local port to use

117

   * \param peerAddress remote address to use

118

   * \param peerPort remote port to use

119

   * \return the Endpoint

120

*/

  Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort,

121

  Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort,

                          Ipv4Address peerAddress, uint16_t peerPort);

122

                          Ipv4Address peerAddress, uint16_t peerPort);

123

124

125

/**

126

   * \brief Remove an IPv4 Endpoint.

127

   * \param endPoint the end point to remove

128

*/

  void DeAllocate (Ipv4EndPoint *endPoint);

129

  void DeAllocate (Ipv4EndPoint *endPoint);

130

/**

   * \brief Receive a packet up the protocol stack

   * \param p The Packet to dump the contents into

   * \param header IPv4 Header information

   * \param incomingInterface The Ipv4Interface it was received on

*/

  virtual IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

131

  virtual IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

                                            Ipv4Header const &header,

132

                                          Ipv4Header const &header,

                                            Ptr<Ipv4Interface> incomingInterface);

133

                                          Ptr<Ipv4Interface> incomingInterface);

  virtual IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

134

  virtual IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

                                                 Ipv6Header const &header,

135

                                          Ipv6Header const &header,

                                                 Ptr<Ipv6Interface> interface);

136

                                          Ptr<Ipv6Interface> interface);

137

  // From IpL4Protocol

138

  // From IpL4Protocol

  virtual void SetDownTarget (IpL4Protocol::DownTargetCallback cb);

139

  virtual void SetDownTarget (IpL4Protocol::DownTargetCallback cb);

Lines 97-134	Link Here

  virtual void DoDispose (void);

145

  virtual void DoDispose (void);

  virtual void NotifyNewAggregate ();

146

  virtual void NotifyNewAggregate ();

private:

147

private:

148

/**

149

   * \brief Copy constructor

150

151

   * Defined and not implemented to avoid misuse

152

*/

100

  NscTcpL4Protocol (NscTcpL4Protocol const &);

153

  NscTcpL4Protocol (NscTcpL4Protocol const &);

154

/**

155

   * \brief Copy constructor

156

157

   * Defined and not implemented to avoid misuse

158

   * \returns

159

*/

101

  NscTcpL4Protocol& operator= (NscTcpL4Protocol const &);

160

  NscTcpL4Protocol& operator= (NscTcpL4Protocol const &);

102

161

103

  // NSC callbacks.

162

  // NSC callbacks.

104

  // NSC invokes these hooks to interact with the simulator.

163

  // NSC invokes these hooks to interact with the simulator.

105

  // In any case, these methods are only to be called by NSC.

164

  // In any case, these methods are only to be called by NSC.

106

//

165

107

  // send_callback is invoked by NSCs 'ethernet driver' to re-inject

166

/**

108

  // a packet (i.e. an octet soup consisting of an IP Header, TCP Header

167

   * \brief Invoked by NSCs 'ethernet driver' to re-inject a packet into ns-3.

109

  // and user payload, if any), into ns-3.

168

169

   * A packet is an octet soup consisting of an IP Header, TCP Header

170

   * and user payload, if any

171

172

   * \param data the data

173

   * \param datalen the data length

174

*/

110

  void send_callback (const void *data, int datalen);

175

  void send_callback (const void *data, int datalen);

111

  // This is called by the NSC stack whenever something of interest

176

/**

112

  // has happened, e.g. when data arrives on a socket, a listen socket

177

   * \brief Called by the NSC stack whenever something of interest has happened

113

  // has a new connection pending, etc.

178

179

   * Examples: when data arrives on a socket, a listen socket

180

   * has a new connection pending, etc.

181

*/

114

  void wakeup ();

182

  void wakeup ();

115

  // This is called by the Linux stack RNG initialization.

183

/**

116

  // Its also used by the cradle code to add a timestamp to

184

   * \brief Called by the Linux stack RNG initialization

117

  // printk/printf/debug output.

185

186

   * Its also used by the cradle code to add a timestamp to

187

   * printk/printf/debug output.

188

   * \param sec seconds

189

   * \param usec microseconds

190

*/

118

  void gettime (unsigned int *sec, unsigned int *usec);

191

  void gettime (unsigned int *sec, unsigned int *usec);

192

/**

193

   * \brief Add an interface

194

195

   * Actually NSC only supports one interface per node (\bugid{1398})

196

*/

119

  void AddInterface (void);

197

  void AddInterface (void);

198

199

/**

200

   * \brief Provide a "soft" interrupt to NSC

201

*/

120

  void SoftInterrupt (void);

202

  void SoftInterrupt (void);

121

  friend class NscInterfaceImpl;

203

  friend class NscInterfaceImpl;

122

  friend class NscTcpSocketImpl;

204

  friend class NscTcpSocketImpl;

123

  Ptr<Node> m_node;

205

124

  Ipv4EndPointDemux *m_endPoints;

206

  Ptr<Node> m_node; //!< the node this stack is associated with

125

  INetStack* m_nscStack;

207

  Ipv4EndPointDemux *m_endPoints; //!< A list of IPv4 end points.

126

  NscInterfaceImpl *m_nscInterface;

208

  INetStack* m_nscStack; //!< the NSC stack.

127

  void *m_dlopenHandle;

209

  NscInterfaceImpl *m_nscInterface; //!< the NSC Interface.

128

  std::string m_nscLibrary;

210

  void *m_dlopenHandle; //!< dynamic library handle.

129

  Timer m_softTimer;

211

  std::string m_nscLibrary; //!< path to the NSC library.

130

  std::vector<Ptr<NscTcpSocketImpl> > m_sockets;

212

  Timer m_softTimer; //!< Soft interrupt timer

131

  IpL4Protocol::DownTargetCallback m_downTarget;

213

  std::vector<Ptr<NscTcpSocketImpl> > m_sockets; //!< list of sockets

214

  IpL4Protocol::DownTargetCallback m_downTarget; //!< Callback to send packets over IPv4

132

};

215

};

133

216

134

} // namespace ns3

217

} // namespace ns3

(-)a/src/internet/model/nsc-tcp-socket-factory-impl.h (-1 / +5 lines)

Lines 47-52	Link Here

  NscTcpSocketFactoryImpl ();

  NscTcpSocketFactoryImpl ();

  virtual ~NscTcpSocketFactoryImpl ();

  virtual ~NscTcpSocketFactoryImpl ();

/**

   * \brief Set the associated TCP L4 protocol.

   * \param tcp the TCP L4 protocol

*/

  void SetTcp (Ptr<NscTcpL4Protocol> tcp);

  void SetTcp (Ptr<NscTcpL4Protocol> tcp);

  virtual Ptr<Socket> CreateSocket (void);

  virtual Ptr<Socket> CreateSocket (void);

Lines 54-60	Link Here

protected:

protected:

  virtual void DoDispose (void);

  virtual void DoDispose (void);

private:

private:

  Ptr<NscTcpL4Protocol> m_tcp;

  Ptr<NscTcpL4Protocol> m_tcp; //!< the associated TCP L4 protocol

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/internet/model/nsc-tcp-socket-impl.h (-35 / +113 lines)

Lines 53-67	Link Here

class NscTcpSocketImpl : public TcpSocket

class NscTcpSocketImpl : public TcpSocket

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * Create an unbound tcp socket.

   * Create an unbound tcp socket.

*/

*/

  NscTcpSocketImpl ();

  NscTcpSocketImpl ();

/**

   * Clone a TCP socket, for use upon receiving a connection request in LISTEN state

   * \param sock the original Tcp Socket

*/

  NscTcpSocketImpl (const NscTcpSocketImpl& sock);

  NscTcpSocketImpl (const NscTcpSocketImpl& sock);

  virtual ~NscTcpSocketImpl ();

  virtual ~NscTcpSocketImpl ();

/**

   * \brief Set the associated node.

   * \param node the node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

/**

   * \brief Set the associated TCP L4 protocol.

   * \param tcp the TCP L4 protocol

*/

  void SetTcp (Ptr<NscTcpL4Protocol> tcp);

  void SetTcp (Ptr<NscTcpL4Protocol> tcp);

  virtual enum SocketErrno GetErrno (void) const;

  virtual enum SocketErrno GetErrno (void) const;

Lines 87-108	Link Here

  virtual bool GetAllowBroadcast () const;

106

  virtual bool GetAllowBroadcast () const;

107

private:

108

private:

109

/**

110

   * \brief Called by NscTcpSocketImpl::ForwardUp()

111

112

   * Actually performs the ForwardUp operations

113

*/

  void NSCWakeup (void);

114

  void NSCWakeup (void);

  friend class Tcp;

115

  friend class Tcp;

  // invoked by Tcp class

116

  // invoked by Tcp class

117

/**

118

   * Finish the binding process

119

   * \returns 0 on success, -1 on failure

120

*/

  int FinishBind (void);

121

  int FinishBind (void);

122

/**

123

   * \brief Called by the L3 protocol when it received a packet to pass on to TCP.

124

125

   * \param p the incoming packet

126

   * \param header the packet's IPv4 header

127

   * \param port the incoming port

128

   * \param incomingInterface the incoming interface

129

*/

  void ForwardUp (Ptr<Packet> p, Ipv4Header header, uint16_t port,

130

  void ForwardUp (Ptr<Packet> p, Ipv4Header header, uint16_t port,

                  Ptr<Ipv4Interface> incomingInterface);

131

                  Ptr<Ipv4Interface> incomingInterface);

132

/**

133

   * \brief Kill this socket by zeroing its attributes (IPv4)

134

135

   * This is a callback function configured to m_endpoint in

136

   * SetupCallback(), invoked when the endpoint is destroyed.

137

*/

  void Destroy (void);

138

  void Destroy (void);

  //methods for state

139

  //methods for state

140

/**

141

   * \brief Send all the pending data

142

   * \returns true on success

143

*/

  bool SendPendingData (void);

144

  bool SendPendingData (void);

145

/**

146

   * \brief Read all the pending data

147

   * \returns true on success

148

*/

  bool ReadPendingData (void);

149

  bool ReadPendingData (void);

150

/**

151

   * \brief Accept an incoming connection

152

   * \returns true on success

153

*/

100

  bool Accept (void);

154

  bool Accept (void);

155

/**

156

   * \brief Complete the Fork operations (after a connection has been accepted)

157

*/

101

  void CompleteFork (void);

158

  void CompleteFork (void);

159

160

/**

161

   * \brief Called when a connection is in Established state

162

*/

102

  void ConnectionSucceeded ();

163

  void ConnectionSucceeded ();

103

164

104

  // Manage data tx/rx

165

  // Manage data tx/rx

105

  /// \todo This should be virtual and overridden

166

  // \todo This should be virtual and overridden

167

/**

168

   * \brief Copy self

169

   * \returns a copy of self

170

*/

106

  Ptr<NscTcpSocketImpl> Copy ();

171

  Ptr<NscTcpSocketImpl> Copy ();

107

172

108

  // attribute related

173

  // attribute related

Lines 112-118	Link Here

112

  virtual uint32_t GetRcvBufSize (void) const;

177

  virtual uint32_t GetRcvBufSize (void) const;

113

  virtual void SetSegSize (uint32_t size);

178

  virtual void SetSegSize (uint32_t size);

114

  virtual uint32_t GetSegSize (void) const;

179

  virtual uint32_t GetSegSize (void) const;

180

/**

181

   * \brief Set the Advertised Window size

182

   * \param window the window size

183

*/

115

  virtual void SetAdvWin (uint32_t window);

184

  virtual void SetAdvWin (uint32_t window);

185

/**

186

   * \brief Get the Advertised Window size

187

   * \returns the window size

188

*/

116

  virtual uint32_t GetAdvWin (void) const;

189

  virtual uint32_t GetAdvWin (void) const;

117

  virtual void SetSSThresh (uint32_t threshold);

190

  virtual void SetSSThresh (uint32_t threshold);

118

  virtual uint32_t GetSSThresh (void) const;

191

  virtual uint32_t GetSSThresh (void) const;

Lines 131-187	Link Here

131

  virtual void SetPersistTimeout (Time timeout);

204

  virtual void SetPersistTimeout (Time timeout);

132

  virtual Time GetPersistTimeout (void) const;

205

  virtual Time GetPersistTimeout (void) const;

133

206

207

/**

208

   * \brief Translate between a NSC error and a ns-3 error code

209

   * \param err NSC error

210

   * \returns ns-3 error code

211

*/

134

  enum Socket::SocketErrno GetNativeNs3Errno (int err) const;

212

  enum Socket::SocketErrno GetNativeNs3Errno (int err) const;

135

  uint32_t m_delAckMaxCount;

213

  uint32_t m_delAckMaxCount;  //!< Number of packet to fire an ACK before delay timeout

136

  Time m_delAckTimeout;

214

  Time m_delAckTimeout;       //!< Time to delay an ACK

137

  bool m_noDelay;

215

  bool m_noDelay;             //!< Disable ACk delay

138

216

139

  Ipv4EndPoint *m_endPoint;

217

  Ipv4EndPoint *m_endPoint;     //!< the IPv4 endpoint

140

  Ptr<Node> m_node;

218

  Ptr<Node> m_node;             //!< the associated node

141

  Ptr<NscTcpL4Protocol> m_tcp;

219

  Ptr<NscTcpL4Protocol> m_tcp;  //!< the associated TCP L4 protocol

142

  Ipv4Address m_remoteAddress;

220

  Ipv4Address m_remoteAddress;  //!< peer IP address

143

  uint16_t m_remotePort;

221

  uint16_t m_remotePort;        //!< peer port

144

  //these two are so that the socket/endpoint cloning works

222

  //these two are so that the socket/endpoint cloning works

145

  Ipv4Address m_localAddress;

223

  Ipv4Address m_localAddress;   //!< local address

146

  uint16_t m_localPort;

224

  uint16_t m_localPort;         //!< local port

147

  InetSocketAddress m_peerAddress;

225

  InetSocketAddress m_peerAddress; //!< peer IP and port

148

  enum SocketErrno m_errno;

226

  enum SocketErrno m_errno;     //!< last error number

149

  bool m_shutdownSend;

227

  bool m_shutdownSend;          //!< Send no longer allowed

150

  bool m_shutdownRecv;

228

  bool m_shutdownRecv;          //!< Receive no longer allowed

151

  bool m_connected;

229

  bool m_connected;             //!< Connection established

152

230

153

  //manage the state information

231

  //manage the state information

154

  TracedValue<TcpStates_t> m_state;

232

  TracedValue<TcpStates_t> m_state; //!< state information

155

  bool m_closeOnEmpty;

233

  bool m_closeOnEmpty;              //!< true if socket will close when buffer is empty

156

234

157

  //needed to queue data when in SYN_SENT state

235

  //needed to queue data when in SYN_SENT state

158

  std::queue<Ptr<Packet> > m_txBuffer;

236

  std::queue<Ptr<Packet> > m_txBuffer; //!< transmission buffer

159

  uint32_t m_txBufferSize;

237

  uint32_t m_txBufferSize;             //!< transmission buffer size

160

238

161

  // Window management

239

  // Window management

162

  uint32_t                       m_segmentSize;          //SegmentSize

240

  uint32_t                       m_segmentSize;          //!< SegmentSize

163

  uint32_t                       m_rxWindowSize;

241

  uint32_t                       m_rxWindowSize;         //!< Receive window size

164

  uint32_t                       m_advertisedWindowSize; //Window to advertise

242

  uint32_t                       m_advertisedWindowSize; //!< Window to advertise

165

  TracedValue<uint32_t>          m_cWnd;                 //Congestion window

243

  TracedValue<uint32_t>          m_cWnd;                 //!< Congestion window

166

  uint32_t                       m_ssThresh;             //Slow Start Threshold

244

  uint32_t                       m_ssThresh;             //!< Slow Start Threshold

167

  uint32_t                       m_initialCWnd;          //Initial cWnd value

245

  uint32_t                       m_initialCWnd;          //!< Initial cWnd value

168

246

169

  // Round trip time estimation

247

  // Round trip time estimation

170

  Time m_lastMeasuredRtt;

248

  Time m_lastMeasuredRtt; //!< Last measured RTT

171

249

172

  // Timer-related members

250

  // Timer-related members

173

  Time              m_cnTimeout;

251

  Time              m_cnTimeout;       //!< Timeout for connection retry

174

  uint32_t          m_cnCount;

252

  uint32_t          m_cnCount;         //!< Count of remaining connection retries

175

  Time              m_persistTimeout;

253

  Time              m_persistTimeout;  //!< Time between sending 1-byte probes

176

254

177

  // Temporary queue for delivering data to application

255

  // Temporary queue for delivering data to application

178

  std::queue<Ptr<Packet> > m_deliveryQueue;

256

  std::queue<Ptr<Packet> > m_deliveryQueue; //!< receive buffer

179

  uint32_t m_rxAvailable;

257

  uint32_t m_rxAvailable;                   //!< receive buffer available size

180

  INetStreamSocket* m_nscTcpSocket;

258

  INetStreamSocket* m_nscTcpSocket;         //!< the real NSC TCP socket

181

259

182

  // Attributes

260

  // Attributes

183

  uint32_t m_sndBufSize;   // buffer limit for the outgoing queue

261

  uint32_t m_sndBufSize;   //!< buffer limit for the outgoing queue

184

  uint32_t m_rcvBufSize;   // maximum receive socket buffer size

262

  uint32_t m_rcvBufSize;   //!< maximum receive socket buffer size

185

};

263

};

186

264

187

} // namespace ns3

265

} // namespace ns3

(-)a/src/internet/model/pending-data.h (-17 / +89 lines)

Lines 41-57	Link Here

class PendingData {

class PendingData {

public:

public:

  PendingData ();

  PendingData ();

/**

   * Constructor

   * \param s size

   * \param d data

   * \param msg message size

   * \param resp response size

*/

  PendingData (uint32_t s, uint8_t* d = NULL, uint32_t msg = 0, uint32_t resp = 0);

  PendingData (uint32_t s, uint8_t* d = NULL, uint32_t msg = 0, uint32_t resp = 0);

  PendingData (const std::string&); // Construct from string

/**

  PendingData (uint8_t*, uint32_t&, Packet*); // Construct from serialized buffer

   * Constructor from string

  PendingData (const PendingData&);   // Copy constructor

   * \param s string

*/

  PendingData (const std::string& s); // Construct from string

  // not implemented ?

  // PendingData (uint8_t*, uint32_t&, Packet*); // Construct from serialized buffer

/**

   * Copy constructor

   * \param o object to copy

*/

  PendingData (const PendingData& o);   // Copy constructor

  virtual ~PendingData ();     // Destructor

  virtual ~PendingData ();     // Destructor

/**

   * Returns the size of the pending data

   * \returns size of pending data

*/

  uint32_t Size () const { return size; }

  uint32_t Size () const { return size; }

  // Serialization

  // Serialization

  uint8_t*  Serialize (uint8_t*, uint32_t&); // Serialize to a buffer

  // not implemented ?

  uint8_t*  Construct (uint8_t*, uint32_t&); // Construct from buffer

  // uint8_t*  Serialize (uint8_t*, uint32_t&); // Serialize to a buffer

  virtual void Clear (); // Remove all associated data

  // not implemented ?

  virtual void Add (uint32_t s, const uint8_t* d = 0); // Add some data to end

  // uint8_t*  Construct (uint8_t*, uint32_t&); // Construct from buffer

/**

   * \brief Remove all associated data

*/

  virtual void Clear ();

/**

   * \brief Add some data to end

   * \param s the data size.

   * \param d the data to store.

*/

  virtual void Add (uint32_t s, const uint8_t* d = 0); //

/**

   * \brief Add some data to end

   * \param p packet containing the data.

*/

  virtual void Add (Ptr<Packet> p);

  virtual void Add (Ptr<Packet> p);

/**

/**

   * This method returns the number of bytes in the PendingData buffer

   * This method returns the number of bytes in the PendingData buffer

Lines 89-97	Link Here

   * \return seqOffset-seqFront

126

   * \return seqOffset-seqFront

*/

127

*/

  virtual uint32_t OffsetFromSeq (const SequenceNumber32& seqFront, const SequenceNumber32& seqOffset);

128

  virtual uint32_t OffsetFromSeq (const SequenceNumber32& seqFront, const SequenceNumber32& seqOffset);

  virtual Ptr<Packet> CopyFromOffset (uint32_t, uint32_t);  // Size, offset, ret packet

129

  // Copy data, size, offset specified by sequence difference

130

/**

  virtual Ptr<Packet> CopyFromSeq (uint32_t, const SequenceNumber32&, const SequenceNumber32&);

131

   * \brief Copy data starting from a give offset

132

   * \param s size of data to copy

133

   * \param o offset

134

   * \returns a packet containing the requested data

135

*/

136

  virtual Ptr<Packet> CopyFromOffset  (uint32_t s, uint32_t o);  // Size, offset, ret packet

137

/**

138

   * \brief Copy data starting from a give offset

139

   * \param s size of data to copy

140

   * \param f Front sequence

141

   * \param o Offset sequence

142

143

   * \see PendingData::OffsetFromSeq()

144

   * \returns a packet containing the requested data

145

*/

146

  virtual Ptr<Packet> CopyFromSeq (uint32_t s, const SequenceNumber32& f, const SequenceNumber32& o);

/**

147

/**

   * Permits object to clear any pending data between seqFront and

148

   * Permits object to clear any pending data between seqFront and

   * seqOffset - 1).  Callers should check the return value to determine

149

   * seqOffset - 1).  Callers should check the return value to determine

Lines 102-116	Link Here

102

   * \return number of bytes from the front that were removed from the buffer

154

   * \return number of bytes from the front that were removed from the buffer

103

*/

155

*/

104

  virtual uint32_t RemoveToSeq (const SequenceNumber32& seqFront, const SequenceNumber32& seqOffset);

156

  virtual uint32_t RemoveToSeq (const SequenceNumber32& seqFront, const SequenceNumber32& seqOffset);

105

  PendingData*   Copy () const;          // Create a copy of this header

157

106

  PendingData*   CopyS (uint32_t);         // Copy with new size

158

/**

107

  PendingData*   CopySD (uint32_t, uint8_t*); // Copy with new size, new data

159

   * \brief Create a copy of self

160

   * \returns copy of pending data

161

*/

162

  PendingData*   Copy () const;

163

/**

164

   * \brief Create a copy of self with new size

165

166

   * Assumes no associated data

167

   * \param s new size

168

   * \returns copy of pending data

169

*/

170

  PendingData*   CopyS (uint32_t s);         // Copy

171

/**

172

   * \brief Create a copy of self with new size, new data

173

174

   * Assumes no associated data

175

   * \param s new size

176

   * \param d new data

177

   * \returns copy of pending data

178

*/

179

  PendingData*   CopySD (uint32_t s, uint8_t* d);

108

public:

180

public:

109

  uint32_t size;        // Number of data bytes

181

  uint32_t size;        //!< Number of data bytes

110

  std::vector<Ptr<Packet> > data;         // Corresponding data (may be null)

182

  std::vector<Ptr<Packet> > data;         //!< Corresponding data (may be null)

111

  // The next two fields allow simulated applications to exchange some info

183

  // The next two fields allow simulated applications to exchange some info

112

  uint32_t msgSize;     // Total size of message

184

  uint32_t msgSize;     //!< Total size of message

113

  uint32_t responseSize; // Size of response requested

185

  uint32_t responseSize; //!< Size of response requested

114

};

186

};

115

187

116

} //namepsace ns3

188

} //namepsace ns3

(-)a/src/internet/model/rtt-estimator.h (-17 / +48 lines)

Lines 39-53	Link Here

*/

*/

class RttHistory {

class RttHistory {

public:

public:

/**

   * \brief Constructor - builds an RttHistory with the given parameters

   * \param s First sequence number in packet sent

   * \param c Number of bytes sent

   * \param t Time this one was sent

*/

  RttHistory (SequenceNumber32 s, uint32_t c, Time t);

  RttHistory (SequenceNumber32 s, uint32_t c, Time t);

/**

   * \brief Copy constructor

   * \param h the object to copy

*/

  RttHistory (const RttHistory& h); // Copy constructor

  RttHistory (const RttHistory& h); // Copy constructor

public:

public:

  SequenceNumber32  seq;  // First sequence number in packet sent

  SequenceNumber32  seq;  //!< First sequence number in packet sent

  uint32_t        count;  // Number of bytes sent

  uint32_t        count;  //!< Number of bytes sent

  Time            time;   // Time this one was sent

  Time            time;   //!< Time this one was sent

  bool            retx;   // True if this has been retransmitted

  bool            retx;   //!< True if this has been retransmitted

};

};

/// Container for RttHistory objects

typedef std::deque<RttHistory> RttHistory_t;

typedef std::deque<RttHistory> RttHistory_t;

/**

/**

Lines 57-66	Link Here

*/

*/

class RttEstimator : public Object {

class RttEstimator : public Object {

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  RttEstimator();

  RttEstimator();

  RttEstimator (const RttEstimator&);

/**

   * \brief Copy constructor

   * \param r the object to copy

*/

  RttEstimator (const RttEstimator& r);

  virtual ~RttEstimator();

  virtual ~RttEstimator();

Lines 97-102	Link Here

*/

116

*/

  virtual Time RetransmitTimeout () = 0;

117

  virtual Time RetransmitTimeout () = 0;

118

119

/**

120

   * \brief Copy object

121

   * \returns a copy of itself

122

*/

100

  virtual Ptr<RttEstimator> Copy () const = 0;

123

  virtual Ptr<RttEstimator> Copy () const = 0;

101

124

102

/**

125

/**

Lines 139-154	Link Here

139

  Time GetCurrentEstimate (void) const;

162

  Time GetCurrentEstimate (void) const;

140

163

141

private:

164

private:

142

  SequenceNumber32 m_next;    // Next expected sequence to be sent

165

  SequenceNumber32 m_next;    //!< Next expected sequence to be sent

143

  RttHistory_t m_history;     // List of sent packet

166

  RttHistory_t m_history;     //!< List of sent packet

144

  uint16_t m_maxMultiplier;

167

  uint16_t m_maxMultiplier;   //!< Maximum RTO Multiplier

145

  Time m_initialEstimatedRtt;

168

  Time m_initialEstimatedRtt; //!< Initial RTT estimation

146

169

147

protected:

170

protected:

148

  Time         m_currentEstimatedRtt;     // Current estimate

171

  Time         m_currentEstimatedRtt;     //!< Current estimate

149

  Time         m_minRto;                  // minimum value of the timeout

172

  Time         m_minRto;                  //!< minimum value of the timeout

150

  uint32_t     m_nSamples;                // Number of samples

173

  uint32_t     m_nSamples;                //!< Number of samples

151

  uint16_t     m_multiplier;              // RTO Multiplier

174

  uint16_t     m_multiplier;              //!< RTO Multiplier

152

};

175

};

153

176

154

/**

177

/**

Lines 163-173	Link Here

163

*/

186

*/

164

class RttMeanDeviation : public RttEstimator {

187

class RttMeanDeviation : public RttEstimator {

165

public:

188

public:

189

/**

190

   * \brief Get the type ID.

191

   * \return the object TypeId

192

*/

166

  static TypeId GetTypeId (void);

193

  static TypeId GetTypeId (void);

167

194

168

  RttMeanDeviation ();

195

  RttMeanDeviation ();

169

196

170

  RttMeanDeviation (const RttMeanDeviation&);

197

/**

198

   * \brief Copy constructor

199

   * \param r the object to copy

200

*/

201

  RttMeanDeviation (const RttMeanDeviation& r);

171

202

172

  virtual TypeId GetInstanceTypeId (void) const;

203

  virtual TypeId GetInstanceTypeId (void) const;

173

204

Lines 186-192	Link Here

186

  Ptr<RttEstimator> Copy () const;

217

  Ptr<RttEstimator> Copy () const;

187

218

188

/**

219

/**

189

   * \brief Resets sthe estimator.

220

   * \brief Resets the estimator.

190

*/

221

*/

191

  void Reset ();

222

  void Reset ();

192

223

Lines 197-204	Link Here

197

  void Gain (double g);

228

  void Gain (double g);

198

229

199

private:

230

private:

200

  double       m_gain;       // Filter gain

231

  double       m_gain;       //!< Filter gain

201

  Time         m_variance;   // Current variance

232

  Time         m_variance;   //!< Current variance

202

};

233

};

203

} // namespace ns3

234

} // namespace ns3

204

235

(-)a/src/internet/model/sim_interface.h (-24 / +250 lines)

Lines 24-72	Link Here

#define NSC_VERSION 0x000500

#define NSC_VERSION 0x000500

/**

 * \ingroup nsctcp

 * \brief Struct interface to NSC stack

*/

struct INetStack

struct INetStack

  virtual ~INetStack() {}

  virtual ~INetStack() {}

/**

   * \brief Initialize the stack

   * \param hz timer_interrupt frequency

*/

  virtual void init (int hz) = 0;

  virtual void init (int hz) = 0;

/**

   * \brief Deliver complete packet to the NSC network stack

   * \param if_id interface ID

   * \param data data

   * \param datalen data length

*/

  virtual void if_receive_packet (int if_id, const void *data, int datalen) = 0;

  virtual void if_receive_packet (int if_id, const void *data, int datalen) = 0;

/**

   * \brief Send complete packet to the NSC network stack

   * \param data data

   * \param datalen data length

*/

  virtual void if_send_packet (const void *data, int datalen) = 0;

  virtual void if_send_packet (const void *data, int datalen) = 0;

/**

   * \brief Signal the completion of send procedure to the NSC network stack

   * \param if_id interface ID

*/

  virtual void if_send_finish (int if_id) = 0;

  virtual void if_send_finish (int if_id) = 0;

/**

   * \brief Attach an interface to the stack

   * \param addr address

   * \param mask network mask

   * \param mtu MTU

*/

  virtual void if_attach (const char *addr, const char *mask, int mtu) = 0;

  virtual void if_attach (const char *addr, const char *mask, int mtu) = 0;

/**

   * \brief Add a default gateway to the interface

   * \param addr gateway address

*/

  virtual void add_default_gateway (const char *addr) = 0;

  virtual void add_default_gateway (const char *addr) = 0;

  /** Purely for debugging/diagnostic purposes. This returns the internal id

/**

   * of the stack instance.

   * \brief Returns the internal id of the stack instance.

   * Purely for debugging/diagnostic purposes.

   * \return internal stack id

*/

*/

  virtual int get_id () = 0;

  virtual int get_id () = 0;

  /** Should return a short one-word name of the stack. Eg. Linux 2.4.x ->

/**

   * \brief Return a short one-word name of the stack

   * Should return a short one-word name of the stack. Eg. Linux 2.4.x ->

   * linux24, FreeBSD 5.x -> freebsd5. This can be used to identify output

   * linux24, FreeBSD 5.x -> freebsd5. This can be used to identify output

   * from a stack, for example a packet trace file. */

   * from a stack, for example a packet trace file.

   * \return short one-word name of the stack

*/

  virtual const char *get_name () = 0;

  virtual const char *get_name () = 0;

  /** This is used so the simulator can call the stack timer_interrupt function

/**

   * \brief Get the timer_interrupt frequency

   * This is used so the simulator can call the stack timer_interrupt function

   * the correct amount of times per second. For example, lwip has a hz of 10,

   * the correct amount of times per second. For example, lwip has a hz of 10,

   * which it returns here to say that it's timer_interrupt should be called

   * which it returns here to say that it's timer_interrupt should be called

   * 10 times a second. FreeBSD uses 100, as does Linux 2.4, while Linux 2.6

   * 10 times a second. FreeBSD uses 100, as does Linux 2.4, while Linux 2.6

   * uses 1000. (This is often configurable in the kernel in question, also.)

   * uses 1000. (This is often configurable in the kernel in question, also.)

100

   * \return frequency

*/

101

*/

  virtual int get_hz () = 0;

102

  virtual int get_hz () = 0;

103

104

/**

105

   * \brief The stack timer_interrupt function

106

*/

  virtual void timer_interrupt () = 0;

107

  virtual void timer_interrupt () = 0;

108

109

/**

110

   * \brief Increment the time ticks

111

*/

  virtual void increment_ticks () = 0;

112

  virtual void increment_ticks () = 0;

113

114

/**

115

   * \brief Set the buffer size

116

*/

  virtual void buffer_size (int size) = 0;

117

  virtual void buffer_size (int size) = 0;

118

119

/**

120

   * \brief Create a new UDP socket

121

*/

  virtual struct INetDatagramSocket *new_udp_socket () { return NULL; }

122

  virtual struct INetDatagramSocket *new_udp_socket () { return NULL; }

123

/**

124

   * \brief Create a new TCP socket

125

*/

  virtual struct INetStreamSocket *new_tcp_socket () { return NULL; }

126

  virtual struct INetStreamSocket *new_tcp_socket () { return NULL; }

127

/**

128

   * \brief Create a new SCTP socket

129

*/

  virtual struct INetStreamSocket *new_sctp_socket () { return NULL; }

130

  virtual struct INetStreamSocket *new_sctp_socket () { return NULL; }

131

  // The following I've made optional to implement for now. Eases

132

  // The following I've made optional to implement for now. Eases

  // integration of new features.

133

  // integration of new features.

134

/**

135

   * \brief use sysctl to modify system parameters

136

   * \param sysctl_name name of the parameter to modify

137

   * \param oldval old value

138

   * \param oldlenp old value length

139

   * \param newval new value

140

   * \param newlen new value length

141

   * \returns

142

*/

  virtual int sysctl (const char *sysctl_name, void *oldval, size_t *oldlenp,

143

  virtual int sysctl (const char *sysctl_name, void *oldval, size_t *oldlenp,

                      void *newval, size_t newlen)

144

                      void *newval, size_t newlen)

145

Lines 77-82	Link Here

  // to convert the string-value to something that the stack can handle.

150

  // to convert the string-value to something that the stack can handle.

  // The idea here is that this is a front-end to the sysctl(2) call,

151

  // The idea here is that this is a front-end to the sysctl(2) call,

  // much like the sysctl(8) program.

152

  // much like the sysctl(8) program.

153

/**

154

   * \brief Set system parameters using sysctl

155

   * \param name name of the parameter to modify

156

   * \param value new value

157

   * \returns

158

*/

  virtual int sysctl_set (const char *name, const char *value)

159

  virtual int sysctl_set (const char *name, const char *value)

160

    return -1;

161

    return -1;

Lines 85-129	Link Here

  // same as above, cradle code is expected to convert the sysctl value

164

  // same as above, cradle code is expected to convert the sysctl value

  // into a string.

165

  // into a string.

  // returns length of the string in value, i.e. retval > len: 'output truncated'.

166

  // returns length of the string in value, i.e. retval > len: 'output truncated'.

167

/**

168

   * \brief Get system parameters using sysctl

169

   * \param name name of the parameter to modify

170

   * \param value value

171

   * \param len value length

172

   * \returns length of the string in value, i.e. retval > len: 'output truncated'.

173

*/

  virtual int sysctl_get (const char *name, char *value, size_t len)

174

  virtual int sysctl_get (const char *name, char *value, size_t len)

175

    return -1;

176

    return -1;

177

178

  // this tells the cradle code to put the name of sysctl number 'idx'

179

/**

  // into name[].

180

   * \brief Tell the cradle code to put the name of sysctl number 'idx' into name[].

  // The idea is that this can be used to get a list of all available sysctls:

181

  // char buf[256]

182

   * The idea is that this can be used to get a list of all available sysctls:

  // for (i=0; sysctl_getnum(i, buf, sizeof(buf)) > 0 ;i++)

183

   * \verbatim

  //    puts(buf);

184

     char buf[256]

  // returns -1 if idx is out of range and the length of the sysctl name otherwise.

185

     for (i=0; sysctl_getnum(i, buf, sizeof(buf)) > 0 ;i++)

186

        puts(buf);

187

     \endverbatim

188

189

   * \param idx index

190

   * \param name sysctl name

191

   * \param len sysctl length

192

   * \returns -1 if idx is out of range and the length of the sysctl name otherwise.

193

*/

100

  virtual int sysctl_getnum (size_t idx, char *name, size_t len)

194

  virtual int sysctl_getnum (size_t idx, char *name, size_t len)

101

195

102

    return -1;

196

    return -1;

103

197

104

198

199

/**

200

   * \brief Show the NSC configuration

201

*/

105

  virtual void show_config ()

202

  virtual void show_config ()

106

203

107

204

108

205

109

206

110

  /* Optional functions used to get and set variables for this stack */

207

/**

208

   * \brief Optional function to get variables for this stack

209

   * \param var the variable

210

   * \param result the result

211

   * \param result_len result length

212

   * \returns true on success

213

*/

111

  virtual bool get_var (const char *var, char *result, int result_len)

214

  virtual bool get_var (const char *var, char *result, int result_len)

112

215

113

    return false;

216

    return false;

114

217

115

218

219

/**

220

   * \brief Optional function to set variables for this stack

221

   * \param var the variable

222

   * \param val the new value

223

   * \returns true on success

224

*/

116

  virtual bool set_var (const char *var, const char *val)

225

  virtual bool set_var (const char *var, const char *val)

117

226

118

    return false;

227

    return false;

119

228

120

229

121

  /** The level of debugging or diagnostic information to print out. This

230

/**

122

   * normally means kernel messages printed out during initialisation but

231

   * \brief Set the level of debugging or diagnostic information to print out.

123

   * may also include extra debugging messages that are part of NSC. */

232

233

   * This normally means kernel messages printed out during initialisation but

234

   * may also include extra debugging messages that are part of NSC.

235

236

   * \param level debugging/diagnostic level

237

*/

124

  virtual void set_diagnostic (int level) {}

238

  virtual void set_diagnostic (int level) {}

125

239

126

  /** Simple interface to support sending any textual command to a stack

240

/**

241

   * \brief Simple interface to support sending any textual command to a stack

127

242

128

   * @returns 0 on success

243

   * @returns 0 on success

129

*/

244

*/

Lines 133-194	Link Here

133

248

134

};

249

};

135

250

251

/**

252

 * \ingroup nsctcp

253

 * \brief Struct interface to NSC Stream (i.e., TCP) Sockets

254

*/

136

struct INetStreamSocket

255

struct INetStreamSocket

137

256

138

  virtual ~INetStreamSocket() {}

257

  virtual ~INetStreamSocket() {}

139

258

259

/**

260

   * \brief Connect to a remote peer

261

*/

140

  virtual void connect (const char *, int) = 0;

262

  virtual void connect (const char *, int) = 0;

263

/**

264

   * \brief Disconnect from a remote peer

265

*/

141

  virtual void disconnect () = 0;

266

  virtual void disconnect () = 0;

267

/**

268

   * \brief Put the socket in Listening state on a port

269

*/

142

  virtual void listen (int) = 0;

270

  virtual void listen (int) = 0;

271

/**

272

   * \brief Accept an incoming connection

273

*/

143

  virtual int accept (INetStreamSocket **) = 0;

274

  virtual int accept (INetStreamSocket **) = 0;

275

/**

276

   * \brief Send some data

277

   * \param data the data

278

   * \param datalen data length

279

   * \return the number of data sent or -1 on error

280

*/

144

  virtual int send_data (const void *data, int datalen) = 0;

281

  virtual int send_data (const void *data, int datalen) = 0;

282

/**

283

   * \brief Read some data

284

   * \param buf the buffer to store the data

285

   * \param buflen buffer length

286

   * \return the number of data read or -1 on error

287

*/

145

  virtual int read_data (void *buf, int *buflen) = 0;

288

  virtual int read_data (void *buf, int *buflen) = 0;

146

  /* We need to pass the option name in as a string here. The reason for

289

/**

290

   * \brief Set the socket options

291

292

   * We need to pass the option name in as a string here. The reason for

147

   * this is that different operating systems you compile on will have

293

   * this is that different operating systems you compile on will have

148

   * different numbers defined for the constants SO_SNDBUF and so on. */

294

   * different numbers defined for the constants SO_SNDBUF and so on.

295

296

   * \param optname name of the option

297

   * \param val option value

298

   * \param valsize size of the option value

299

   * \returns

300

*/

149

  virtual int setsockopt (char *optname, void *val, size_t valsize) = 0;

301

  virtual int setsockopt (char *optname, void *val, size_t valsize) = 0;

302

/**

303

   * \brief Print the socket state

304

*/

150

  virtual void print_state (FILE *) = 0;

305

  virtual void print_state (FILE *) = 0;

306

/**

307

   * \brief Check the connection state

308

   * \returns true if socket is in connected state

309

*/

151

  virtual bool is_connected () = 0;

310

  virtual bool is_connected () = 0;

311

/**

312

   * \brief Check the listening state

313

   * \returns true if socket is in listening state

314

*/

152

  virtual bool is_listening () = 0;

315

  virtual bool is_listening () = 0;

153

316

/**

317

   * \brief Get the peer name

318

319

   * \note not implemented

320

321

   * \param sa sockaddr structure to fill

322

   * \param salen sockaddr structure length

323

   * \returns -1 on error (always returns -1)

324

*/

154

  virtual int getpeername (struct sockaddr *sa, size_t *salen) {

325

  virtual int getpeername (struct sockaddr *sa, size_t *salen) {

155

    return -1;

326

    return -1;

156

327

328

/**

329

   * \brief Get the socket local name

330

331

   * \note not implemented

332

333

   * \param sa sockaddr structure to fill

334

   * \param salen sockaddr structure length

335

   * \returns -1 on error (always returns -1)

336

*/

157

  virtual int getsockname (struct sockaddr *sa, size_t *salen) {

337

  virtual int getsockname (struct sockaddr *sa, size_t *salen) {

158

    return -1;

338

    return -1;

159

339

160

  /* Optional functions used to get and set variables for this TCP

340

/**

161

   * connection. */

341

   * \brief Optional function used to get variables for this TCP connection.

342

343

   * \note not implemented

344

345

   * \param var variable requested

346

   * \param result result result

347

   * \param result_len result length

348

   * \return always false

349

*/

162

  virtual bool get_var (const char *var, char *result, int result_len)

350

  virtual bool get_var (const char *var, char *result, int result_len)

163

351

164

    return false;

352

    return false;

165

353

166

354

/**

355

   * \brief Optional function used to set variables for this TCP connection.

356

357

   * \note not implemented

358

359

   * \param var variable to set

360

   * \param val value to set

361

   * \return always false

362

*/

167

  virtual bool set_var (const char *var, const char *val)

363

  virtual bool set_var (const char *var, const char *val)

168

364

169

    return false;

365

    return false;

170

366

171

};

367

};

172

368

369

/**

370

 * \ingroup nsctcp

371

 * \brief Struct interface to NSC Datagram (i.e., UDP) Sockets

372

*/

173

struct INetDatagramSocket

373

struct INetDatagramSocket

174

374

175

  virtual ~INetDatagramSocket() {}

375

  virtual ~INetDatagramSocket() {}

176

376

377

/**

378

   * \brief Set the destination address and port

379

*/

177

  virtual void set_destination (const char *, int) = 0;

380

  virtual void set_destination (const char *, int) = 0;

381

/**

382

   * \brief Send a datagram

383

   * \param data the data

384

   * \param datalen data length

385

*/

178

  virtual void send_data (const void *data, int datalen) = 0;

386

  virtual void send_data (const void *data, int datalen) = 0;

179

};

387

};

388

389

/**

390

 * \ingroup nsctcp

391

 * \brief Struct interface to NSC send capabilities

392

*/

180

struct ISendCallback

393

struct ISendCallback

181

394

182

  virtual ~ISendCallback() {}

395

  virtual ~ISendCallback() {}

183

396

397

/**

398

   * \brief Invoked by NSCs 'ethernet driver' to re-inject a packet into ns-3.

399

*/

184

  virtual void send_callback (const void *data, int datalen) = 0;

400

  virtual void send_callback (const void *data, int datalen) = 0;

185

};

401

};

186

402

403

/**

404

 * \ingroup nsctcp

405

 * \brief Struct interface to NSC soft interrupt capabilities

406

*/

187

struct IInterruptCallback

407

struct IInterruptCallback

188

408

189

  virtual ~IInterruptCallback() {}

409

  virtual ~IInterruptCallback() {}

190

410

411

/**

412

   * \brief Called by the NSC stack whenever something of interest has happened

413

*/

191

  virtual void wakeup () = 0;

414

  virtual void wakeup () = 0;

415

/**

416

   * \brief Get the actual time

417

*/

192

  virtual void gettime (unsigned int *, unsigned int *) = 0;

418

  virtual void gettime (unsigned int *, unsigned int *) = 0;

193

};

419

};

194

420

(-)a/src/internet/model/tcp-header.h (-13 / +25 lines)

Lines 175-183	Link Here

175

                           Address destination,

175

                           Address destination,

176

                           uint8_t protocol);

176

                           uint8_t protocol);

177

178

/**

179

   * \brief TCP flag field values

180

*/

178

  typedef enum { NONE = 0, FIN = 1, SYN = 2, RST = 4, PSH = 8, ACK = 16,

181

  typedef enum { NONE = 0, FIN = 1, SYN = 2, RST = 4, PSH = 8, ACK = 16,

179

                 URG = 32, ECE = 64, CWR = 128} Flags_t;

182

                 URG = 32, ECE = 64, CWR = 128} Flags_t;

180

183

184

/**

185

   * \brief Get the type ID.

186

   * \return the object TypeId

187

*/

181

  static TypeId GetTypeId (void);

188

  static TypeId GetTypeId (void);

182

  virtual TypeId GetInstanceTypeId (void) const;

189

  virtual TypeId GetInstanceTypeId (void) const;

183

  virtual void Print (std::ostream &os) const;

190

  virtual void Print (std::ostream &os) const;

Lines 192-213	Link Here

192

  bool IsChecksumOk (void) const;

199

  bool IsChecksumOk (void) const;

193

200

194

private:

201

private:

202

/**

203

   * \brief Calculate the header checksum

204

   * \param size packet size

205

   * \returns the checksum

206

*/

195

  uint16_t CalculateHeaderChecksum (uint16_t size) const;

207

  uint16_t CalculateHeaderChecksum (uint16_t size) const;

196

  uint16_t m_sourcePort;

208

  uint16_t m_sourcePort;        //!< Source port

197

  uint16_t m_destinationPort;

209

  uint16_t m_destinationPort;   //!< Destination port

198

  SequenceNumber32 m_sequenceNumber;

210

  SequenceNumber32 m_sequenceNumber;  //!< Sequence number

199

  SequenceNumber32 m_ackNumber;

211

  SequenceNumber32 m_ackNumber;       //!< ACK number

200

  uint8_t m_length; // really a uint4_t

212

  uint8_t m_length;             //!< Length (really a uint4_t)

201

  uint8_t m_flags;      // really a uint6_t

213

  uint8_t m_flags;              //!< Flags (really a uint6_t)

202

  uint16_t m_windowSize;

214

  uint16_t m_windowSize;        //!< Window size

203

  uint16_t m_urgentPointer;

215

  uint16_t m_urgentPointer;     //!< Urgent pointer

204

216

205

  Address m_source;

217

  Address m_source;       //!< Source IP address

206

  Address m_destination;

218

  Address m_destination;  //!< Destination IP address

207

  uint8_t m_protocol;

219

  uint8_t m_protocol;     //!< Protocol number

208

220

209

  bool m_calcChecksum;

221

  bool m_calcChecksum;    //!< Flag to calculate checksum

210

  bool m_goodChecksum;

222

  bool m_goodChecksum;    //!< Flag to indicate that checksum is correct

211

};

223

};

212

224

213

} // namespace ns3

225

} // namespace ns3

(-)a/src/internet/model/tcp-l4-protocol.h (-36 / +122 lines)

Lines 55-97	Link Here

class TcpL4Protocol : public IpL4Protocol {

class TcpL4Protocol : public IpL4Protocol {

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  static const uint8_t PROT_NUMBER;

  static const uint8_t PROT_NUMBER; //!< protocol number (0x6)

/**

   * \brief Constructor

*/

  TcpL4Protocol ();

  TcpL4Protocol ();

  virtual ~TcpL4Protocol ();

  virtual ~TcpL4Protocol ();

/**

   * Set node associated with this stack

   * \param node the node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

  virtual int GetProtocolNumber (void) const;

  virtual int GetProtocolNumber (void) const;

/**

/**

   * \brief Create a TCP socket

   * \return A smart Socket pointer to a TcpSocket allocated by this instance

   * \return A smart Socket pointer to a TcpSocket allocated by this instance

   * of the TCP protocol

   * of the TCP protocol

*/

*/

  Ptr<Socket> CreateSocket (void);

  Ptr<Socket> CreateSocket (void);

/**

   * \brief Create a TCP socket

   * \return A smart Socket pointer to a TcpSocket allocated by this instance

   * of the TCP protocol

   * \warning using a socketTypeId other than TCP is a bad idea.

   * \param socketTypeId the socket TypeId

*/

  Ptr<Socket> CreateSocket (TypeId socketTypeId);

  Ptr<Socket> CreateSocket (TypeId socketTypeId);

/**

   * \brief Allocate an IPv4 Endpoint

   * \return the Endpoint

*/

  Ipv4EndPoint *Allocate (void);

  Ipv4EndPoint *Allocate (void);

/**

   * \brief Allocate an IPv4 Endpoint

100

   * \param address address to use

101

   * \return the Endpoint

102

*/

  Ipv4EndPoint *Allocate (Ipv4Address address);

103

  Ipv4EndPoint *Allocate (Ipv4Address address);

104

/**

105

   * \brief Allocate an IPv4 Endpoint

106

   * \param port port to use

107

   * \return the Endpoint

108

*/

  Ipv4EndPoint *Allocate (uint16_t port);

109

  Ipv4EndPoint *Allocate (uint16_t port);

110

/**

111

   * \brief Allocate an IPv4 Endpoint

112

   * \param address address to use

113

   * \param port port to use

114

   * \return the Endpoint

115

*/

  Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port);

116

  Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port);

117

/**

118

   * \brief Allocate an IPv4 Endpoint

119

   * \param localAddress local address to use

120

   * \param localPort local port to use

121

   * \param peerAddress remote address to use

122

   * \param peerPort remote port to use

123

   * \return the Endpoint

124

*/

  Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort,

125

  Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort,

                          Ipv4Address peerAddress, uint16_t peerPort);

126

                          Ipv4Address peerAddress, uint16_t peerPort);

127

/**

128

   * \brief Allocate an IPv6 Endpoint

129

   * \return the Endpoint

130

*/

  Ipv6EndPoint *Allocate6 (void);

131

  Ipv6EndPoint *Allocate6 (void);

132

/**

133

   * \brief Allocate an IPv6 Endpoint

134

   * \param address address to use

135

   * \return the Endpoint

136

*/

  Ipv6EndPoint *Allocate6 (Ipv6Address address);

137

  Ipv6EndPoint *Allocate6 (Ipv6Address address);

138

/**

139

   * \brief Allocate an IPv6 Endpoint

140

   * \param port port to use

141

   * \return the Endpoint

142

*/

  Ipv6EndPoint *Allocate6 (uint16_t port);

143

  Ipv6EndPoint *Allocate6 (uint16_t port);

144

/**

145

   * \brief Allocate an IPv6 Endpoint

146

   * \param address address to use

147

   * \param port port to use

148

   * \return the Endpoint

149

*/

  Ipv6EndPoint *Allocate6 (Ipv6Address address, uint16_t port);

150

  Ipv6EndPoint *Allocate6 (Ipv6Address address, uint16_t port);

151

/**

152

   * \brief Allocate an IPv6 Endpoint

153

   * \param localAddress local address to use

154

   * \param localPort local port to use

155

   * \param peerAddress remote address to use

156

   * \param peerPort remote port to use

157

   * \return the Endpoint

158

*/

  Ipv6EndPoint *Allocate6 (Ipv6Address localAddress, uint16_t localPort,

159

  Ipv6EndPoint *Allocate6 (Ipv6Address localAddress, uint16_t localPort,

                           Ipv6Address peerAddress, uint16_t peerPort);

160

                           Ipv6Address peerAddress, uint16_t peerPort);

161

162

/**

163

   * \brief Remove an IPv4 Endpoint.

164

   * \param endPoint the end point to remove

165

*/

  void DeAllocate (Ipv4EndPoint *endPoint);

166

  void DeAllocate (Ipv4EndPoint *endPoint);

167

/**

168

   * \brief Remove an IPv6 Endpoint.

169

   * \param endPoint the end point to remove

170

*/

  void DeAllocate (Ipv6EndPoint *endPoint);

171

  void DeAllocate (Ipv6EndPoint *endPoint);

172

/**

173

/**

   * \brief Send a packet via TCP

174

   * \brief Send a packet via TCP (IPv4)

   * \param packet The packet to send

175

   * \param packet The packet to send

   * \param saddr The source Ipv4Address

176

   * \param saddr The source Ipv4Address

   * \param daddr The destination Ipv4Address

177

   * \param daddr The destination Ipv4Address

Lines 102-134	Link Here

102

  void Send (Ptr<Packet> packet,

182

  void Send (Ptr<Packet> packet,

103

             Ipv4Address saddr, Ipv4Address daddr,

183

             Ipv4Address saddr, Ipv4Address daddr,

104

             uint16_t sport, uint16_t dport, Ptr<NetDevice> oif = 0);

184

             uint16_t sport, uint16_t dport, Ptr<NetDevice> oif = 0);

185

/**

186

   * \brief Send a packet via TCP (IPv6)

187

   * \param packet The packet to send

188

   * \param saddr The source Ipv4Address

189

   * \param daddr The destination Ipv4Address

190

   * \param sport The source port number

191

   * \param dport The destination port number

192

   * \param oif The output interface bound. Defaults to null (unspecified).

193

*/

105

  void Send (Ptr<Packet> packet,

194

  void Send (Ptr<Packet> packet,

106

             Ipv6Address saddr, Ipv6Address daddr,

195

             Ipv6Address saddr, Ipv6Address daddr,

107

             uint16_t sport, uint16_t dport, Ptr<NetDevice> oif = 0);

196

             uint16_t sport, uint16_t dport, Ptr<NetDevice> oif = 0);

108

/**

197

109

   * \brief Receive a packet up the protocol stack

198

110

   * \param p The Packet to dump the contents into

111

   * \param header IPv4 Header information

112

   * \param incomingInterface The Ipv4Interface it was received on

113

*/

114

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

199

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

115

                                                 Ipv4Header const &header,

200

                                               Ipv4Header const &header,

116

                                                 Ptr<Ipv4Interface> incomingInterface);

201

                                               Ptr<Ipv4Interface> incomingInterface);

117

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

202

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

118

                                                 Ipv6Header const &header,

203

                                               Ipv6Header const &header,

119

                                                 Ptr<Ipv6Interface> interface);

204

                                               Ptr<Ipv6Interface> incomingInterface);

120

205

121

/**

122

   * \brief Receive an ICMP packet

123

   * \param icmpSource The IP address of the source of the packet.

124

   * \param icmpTtl The time to live from the IP header

125

   * \param icmpType The type of the message from the ICMP header

126

   * \param icmpCode The message code from the ICMP header

127

   * \param icmpInfo 32-bit integer carrying informational value of varying semantics.

128

   * \param payloadSource The IP source address from the IP header of the packet

129

   * \param payloadDestination The IP destination address from the IP header of the packet

130

   * \param payload Payload of the ICMP packet

131

*/

132

  virtual void ReceiveIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

206

  virtual void ReceiveIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

133

                            uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo,

207

                            uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo,

134

                            Ipv4Address payloadSource,Ipv4Address payloadDestination,

208

                            Ipv4Address payloadSource,Ipv4Address payloadDestination,

Lines 153-175	Link Here

153

*/

227

*/

154

  virtual void NotifyNewAggregate ();

228

  virtual void NotifyNewAggregate ();

155

private:

229

private:

156

  Ptr<Node> m_node;

230

  Ptr<Node> m_node; //!< the node this stack is associated with

157

  Ipv4EndPointDemux *m_endPoints;

231

  Ipv4EndPointDemux *m_endPoints; //!< A list of IPv4 end points.

158

  Ipv6EndPointDemux *m_endPoints6;

232

  Ipv6EndPointDemux *m_endPoints6; //!< A list of IPv6 end points.

159

  TypeId m_rttTypeId;

233

  TypeId m_rttTypeId; //!< The RTT Estimator TypeId

160

  TypeId m_socketTypeId;

234

  TypeId m_socketTypeId; //!< The socket TypeId

161

private:

235

private:

162

  friend class TcpSocketBase;

236

  friend class TcpSocketBase;

163

  void SendPacket (Ptr<Packet>, const TcpHeader &,

237

  void SendPacket (Ptr<Packet>, const TcpHeader &,

164

                   Ipv4Address, Ipv4Address, Ptr<NetDevice> oif = 0);

238

                   Ipv4Address, Ipv4Address, Ptr<NetDevice> oif = 0);

165

  void SendPacket (Ptr<Packet>, const TcpHeader &,

239

  void SendPacket (Ptr<Packet>, const TcpHeader &,

166

                   Ipv6Address, Ipv6Address, Ptr<NetDevice> oif = 0);

240

                   Ipv6Address, Ipv6Address, Ptr<NetDevice> oif = 0);

167

  TcpL4Protocol (const TcpL4Protocol &o);

168

  TcpL4Protocol &operator = (const TcpL4Protocol &o);

169

241

170

  std::vector<Ptr<TcpSocketBase> > m_sockets;

242

/**

171

  IpL4Protocol::DownTargetCallback m_downTarget;

243

   * \brief Copy constructor

172

  IpL4Protocol::DownTargetCallback6 m_downTarget6;

244

245

   * Defined and not implemented to avoid misuse

246

*/

247

  TcpL4Protocol (const TcpL4Protocol &);

248

/**

249

   * \brief Copy constructor

250

251

   * Defined and not implemented to avoid misuse

252

   * \returns

253

*/

254

  TcpL4Protocol &operator = (const TcpL4Protocol &);

255

256

  std::vector<Ptr<TcpSocketBase> > m_sockets;      //!< list of sockets

257

  IpL4Protocol::DownTargetCallback m_downTarget;   //!< Callback to send packets over IPv4

258

  IpL4Protocol::DownTargetCallback6 m_downTarget6; //!< Callback to send packets over IPv6

173

};

259

};

174

260

175

} // namespace ns3

261

} // namespace ns3




{
}

/* We initialize m_cWnd from this function, after attributes initialized */
int
TcpNewReno::Listen (void)
{

  return TcpSocketBase::Listen ();
}

/* We initialize m_cWnd from this function, after attributes initialized */
int
TcpNewReno::Connect (const Address & address)
{

  return TcpSocketBase::Connect (address);
}

/* Limit the size of in-flight data by cwnd and receiver's rxwin */
uint32_t
TcpNewReno::Window (void)
{

  return CopyObject<TcpNewReno> (this);
}

/* New ACK (up to seqnum seq) received. Increase cwnd and call TcpSocketBase::NewAck() */
void
TcpNewReno::NewAck (const SequenceNumber32& seq)
{

  TcpSocketBase::NewAck (seq);
}

/* Cut cwnd and enter fast recovery mode upon triple dupack */
void
TcpNewReno::DupAck (const TcpHeader& t, uint32_t count)
{

    };
}

/* Retransmit timeout */
void
TcpNewReno::Retransmit (void)
{

(-)a/src/internet/model/tcp-newreno.h (-8 / +19 lines)

Lines 36-46	Link Here

class TcpNewReno : public TcpSocketBase

class TcpNewReno : public TcpSocketBase

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * Create an unbound tcp socket.

   * Create an unbound tcp socket.

*/

*/

  TcpNewReno (void);

  TcpNewReno (void);

/**

   * \brief Copy constructor

   * \param sock the object to copy

*/

  TcpNewReno (const TcpNewReno& sock);

  TcpNewReno (const TcpNewReno& sock);

  virtual ~TcpNewReno (void);

  virtual ~TcpNewReno (void);

Lines 62-77	Link Here

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual uint32_t GetInitialCwnd (void) const;

  virtual uint32_t GetInitialCwnd (void) const;

private:

private:

  void InitializeCwnd (void);            // set m_cWnd when connection starts

/**

   * \brief Set the congestion window when connection starts

*/

  void InitializeCwnd (void);

protected:

protected:

  TracedValue<uint32_t>  m_cWnd;         //< Congestion window

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  uint32_t               m_ssThresh;     //< Slow Start Threshold

  uint32_t               m_ssThresh;     //!< Slow Start Threshold

  uint32_t               m_initialCWnd;  //< Initial cWnd value

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  SequenceNumber32       m_recover;      //< Previous highest Tx seqnum for fast recovery

  SequenceNumber32       m_recover;      //!< Previous highest Tx seqnum for fast recovery

  uint32_t               m_retxThresh;   //< Fast Retransmit threshold

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

  bool                   m_inFastRec;    //< currently in fast recovery

  bool                   m_inFastRec;    //!< currently in fast recovery

  bool                   m_limitedTx;    //< perform limited transmit

  bool                   m_limitedTx;    //!< perform limited transmit

};

};

} // namespace ns3

} // namespace ns3




{
}

/* We initialize m_cWnd from this function, after attributes initialized */
int
TcpReno::Listen (void)
{

  return TcpSocketBase::Listen ();
}

/* We initialize m_cWnd from this function, after attributes initialized */
int
TcpReno::Connect (const Address & address)
{

  return TcpSocketBase::Connect (address);
}

/* Limit the size of in-flight data by cwnd and receiver's rxwin */
uint32_t
TcpReno::Window (void)
{

  return CopyObject<TcpReno> (this);
}

/* New ACK (up to seqnum seq) received. Increase cwnd and call TcpSocketBase::NewAck() */
void
TcpReno::NewAck (const SequenceNumber32& seq)
{

(-)a/src/internet/model/tcp-reno.h (-6 / +17 lines)

Lines 38-48	Link Here

class TcpReno : public TcpSocketBase

class TcpReno : public TcpSocketBase

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * Create an unbound tcp socket.

   * Create an unbound tcp socket.

*/

*/

  TcpReno (void);

  TcpReno (void);

/**

   * \brief Copy constructor

   * \param sock the object to copy

*/

  TcpReno (const TcpReno& sock);

  TcpReno (const TcpReno& sock);

  virtual ~TcpReno (void);

  virtual ~TcpReno (void);

Lines 64-77	Link Here

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual uint32_t GetInitialCwnd (void) const;

  virtual uint32_t GetInitialCwnd (void) const;

private:

private:

  void InitializeCwnd (void);            // set m_cWnd when connection starts

/**

   * \brief Set the congestion window when connection starts

*/

  void InitializeCwnd (void);

protected:

protected:

  TracedValue<uint32_t>  m_cWnd;         //< Congestion window

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  uint32_t               m_ssThresh;     //< Slow Start Threshold

  uint32_t               m_ssThresh;     //!< Slow Start Threshold

  uint32_t               m_initialCWnd;  //< Initial cWnd value

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  uint32_t               m_retxThresh;   //< Fast Retransmit threshold

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

  bool                   m_inFastRec;    //< currently in fast recovery

  bool                   m_inFastRec;    //!< currently in fast recovery

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/internet/model/tcp-rfc793.h (+8 lines)

Lines 39-49	Link Here

class TcpRfc793 : public TcpSocketBase

class TcpRfc793 : public TcpSocketBase

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * Create an unbound tcp socket.

   * Create an unbound tcp socket.

*/

*/

  TcpRfc793 (void);

  TcpRfc793 (void);

/**

   * \brief Copy constructor

   * \param sock the object to copy

*/

  TcpRfc793 (const TcpRfc793& sock);

  TcpRfc793 (const TcpRfc793& sock);

  virtual ~TcpRfc793 (void);

  virtual ~TcpRfc793 (void);

(-)a/src/internet/model/tcp-rx-buffer.h (-8 / +60 lines)

Lines 40-59	Link Here

class TcpRxBuffer : public Object

class TcpRxBuffer : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

   * \brief Constructor

   * \param n initial Sequence number to be received

*/

  TcpRxBuffer (uint32_t n = 0);

  TcpRxBuffer (uint32_t n = 0);

  virtual ~TcpRxBuffer ();

  virtual ~TcpRxBuffer ();

  // Accessors

  // Accessors

/**

   * \brief Get Next Rx Sequence number

   * \returns Next Rx Sequence number

*/

  SequenceNumber32 NextRxSequence (void) const;

  SequenceNumber32 NextRxSequence (void) const;

/**

   * \brief Get the lowest sequence number that this TcpRxBuffer cannot accept

   * \returns the lowest sequence number that this TcpRxBuffer cannot accept

*/

  SequenceNumber32 MaxRxSequence (void) const;

  SequenceNumber32 MaxRxSequence (void) const;

/**

   * \brief Increment the Next Sequence number

*/

  void IncNextRxSequence (void);

  void IncNextRxSequence (void);

/**

   * \brief Set the Next Sequence number

   * \param s the Sequence number

*/

  void SetNextRxSequence (const SequenceNumber32& s);

  void SetNextRxSequence (const SequenceNumber32& s);

/**

   * \brief Set the FIN Sequence number (i.e., the one closing the connection)

   * \param s the Sequence number

*/

  void SetFinSequence (const SequenceNumber32& s);

  void SetFinSequence (const SequenceNumber32& s);

/**

   * \brief Get the Maximum buffer size

   * \returns the Maximum buffer size

*/

  uint32_t MaxBufferSize (void) const;

  uint32_t MaxBufferSize (void) const;

/**

   * \brief Set the Maximum buffer size

   * \param s the Maximum buffer size

*/

  void SetMaxBufferSize (uint32_t s);

  void SetMaxBufferSize (uint32_t s);

/**

   * \brief Get the actual buffer occupancy

   * \returns buffer occupancy (in bytes)

*/

  uint32_t Size (void) const;

  uint32_t Size (void) const;

/**

   * \brief Get the actual number of bytes available to be read

   * \returns size of available data (in bytes)

*/

  uint32_t Available () const;

  uint32_t Available () const;

100

/**

101

   * \brief Check if the buffer did receive all the data (and the connection is closed)

102

   * \returns true if all data have been received

103

*/

  bool Finished (void);

104

  bool Finished (void);

105

/**

106

/**

Lines 63-68	Link Here

   * removing data from the buffer that overlaps the tail of the inputted

110

   * removing data from the buffer that overlaps the tail of the inputted

   * packet

111

   * packet

112

113

   * \param p packet

114

   * \param tcph packet's TCP header

   * \return True when success, false otherwise.

115

   * \return True when success, false otherwise.

*/

116

*/

  bool Add (Ptr<Packet> p, TcpHeader const& tcph);

117

  bool Add (Ptr<Packet> p, TcpHeader const& tcph);

Lines 70-87	Link Here

/**

119

/**

   * Extract data from the head of the buffer as indicated by nextRxSeq.

120

   * Extract data from the head of the buffer as indicated by nextRxSeq.

   * The extracted data is going to be forwarded to the application.

121

   * The extracted data is going to be forwarded to the application.

122

123

   * \param maxSize maximum number of bytes to extract

124

   * \returns a packet

*/

125

*/

  Ptr<Packet> Extract (uint32_t maxSize);

126

  Ptr<Packet> Extract (uint32_t maxSize);

public:

127

public:

128

  /// container for data stored in the buffer

  typedef std::map<SequenceNumber32, Ptr<Packet> >::iterator BufIterator;

129

  typedef std::map<SequenceNumber32, Ptr<Packet> >::iterator BufIterator;

  TracedValue<SequenceNumber32> m_nextRxSeq; //< Seqnum of the first missing byte in data (RCV.NXT)

130

  TracedValue<SequenceNumber32> m_nextRxSeq; //!< Seqnum of the first missing byte in data (RCV.NXT)

  SequenceNumber32 m_finSeq;                 //< Seqnum of the FIN packet

131

  SequenceNumber32 m_finSeq;                 //!< Seqnum of the FIN packet

  bool m_gotFin;                             //< Did I received FIN packet?

132

  bool m_gotFin;                             //!< Did I received FIN packet?

  uint32_t m_size;                           //< Number of total data bytes in the buffer, not necessarily contiguous

133

  uint32_t m_size;                           //!< Number of total data bytes in the buffer, not necessarily contiguous

  uint32_t m_maxBuffer;                      //< Upper bound of the number of data bytes in buffer (RCV.WND)

134

  uint32_t m_maxBuffer;                      //!< Upper bound of the number of data bytes in buffer (RCV.WND)

  uint32_t m_availBytes;                     //< Number of bytes available to read, i.e. contiguous block at head

135

  uint32_t m_availBytes;                     //!< Number of bytes available to read, i.e. contiguous block at head

  std::map<SequenceNumber32, Ptr<Packet> > m_data;

136

  std::map<SequenceNumber32, Ptr<Packet> > m_data; //!< Corresponding data (may be null)

  //< Corresponding data (may be null)

};

137

};

138

} //namepsace ns3

139

} //namepsace ns3




   * \brief Called by the L3 protocol when it received a packet to pass on to TCP.
   *
   * \param packet the incoming packet
   * \param header the packet's IPv4 header
   * \param port the incoming port
   * \param incomingInterface the incoming interface
   */

   * \brief Called by the L3 protocol when it received a packet to pass on to TCP.
   *
   * \param packet the incoming packet
   * \param header the packet's IPv6 header
   * \param port the incoming port
   */
  void ForwardUp6 (Ptr<Packet> packet, Ipv6Header header, uint16_t port);

   * \brief Called by TcpSocketBase::ForwardUp().
   *
   * \param packet the incoming packet
   * \param header the packet's IPv4 header
   * \param port the incoming port
   * \param incomingInterface the incoming interface
   */

   * \brief Called by TcpSocketBase::ForwardUp6().
   *
   * \param packet the incoming packet
   * \param header the packet's IPv6 header
   * \param port the incoming port
   */
  virtual void DoForwardUp (Ptr<Packet> packet, Ipv6Header header, uint16_t port);




{
}

/* We initialize m_cWnd from this function, after attributes initialized */
int
TcpTahoe::Listen (void)
{

  return TcpSocketBase::Listen ();
}

/* We initialize m_cWnd from this function, after attributes initialized */
int
TcpTahoe::Connect (const Address & address)
{

  return TcpSocketBase::Connect (address);
}

/* Limit the size of in-flight data by cwnd and receiver's rxwin */
uint32_t
TcpTahoe::Window (void)
{

  return CopyObject<TcpTahoe> (this);
}

/* New ACK (up to seqnum seq) received. Increase cwnd and call TcpSocketBase::NewAck() */
void
TcpTahoe::NewAck (SequenceNumber32 const& seq)
{

  TcpSocketBase::NewAck (seq);           // Complete newAck processing
}

/* Cut down ssthresh upon triple dupack */
void
TcpTahoe::DupAck (const TcpHeader& t, uint32_t count)
{

    }
}

/* Retransmit timeout */
void TcpTahoe::Retransmit (void)
{
  NS_LOG_FUNCTION (this);

(-)a/src/internet/model/tcp-tahoe.h (-5 / +16 lines)

Lines 42-52	Link Here

class TcpTahoe : public TcpSocketBase

class TcpTahoe : public TcpSocketBase

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * Create an unbound tcp socket.

   * Create an unbound tcp socket.

*/

*/

  TcpTahoe (void);

  TcpTahoe (void);

/**

   * \brief Copy constructor

   * \param sock the object to copy

*/

  TcpTahoe (const TcpTahoe& sock);

  TcpTahoe (const TcpTahoe& sock);

  virtual ~TcpTahoe (void);

  virtual ~TcpTahoe (void);

Lines 68-80	Link Here

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual uint32_t GetInitialCwnd (void) const;

  virtual uint32_t GetInitialCwnd (void) const;

private:

private:

  void InitializeCwnd (void);            // set m_cWnd when connection starts

/**

   * \brief Set the congestion window when connection starts

*/

  void InitializeCwnd (void);

protected:

protected:

  TracedValue<uint32_t>  m_cWnd;         //< Congestion window

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  uint32_t               m_ssThresh;     //< Slow Start Threshold

  uint32_t               m_ssThresh;     //!< Slow Start Threshold

  uint32_t               m_initialCWnd;  //< Initial cWnd value

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  uint32_t               m_retxThresh;   //< Fast Retransmit threshold

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/internet/model/tcp-tx-buffer.h (-4 / +25 lines)

Lines 40-46	Link Here

class TcpTxBuffer : public Object

class TcpTxBuffer : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

   * \brief Constructor

   * \param n initial Sequence number to be transmitted

*/

  TcpTxBuffer (uint32_t n = 0);

  TcpTxBuffer (uint32_t n = 0);

  virtual ~TcpTxBuffer (void);

  virtual ~TcpTxBuffer (void);

Lines 48-78	Link Here

/**

/**

   * Returns the first byte's sequence number

   * Returns the first byte's sequence number

   * \returns the first byte's sequence number

*/

*/

  SequenceNumber32 HeadSequence (void) const;

  SequenceNumber32 HeadSequence (void) const;

/**

/**

   * Returns the last byte's sequence number + 1

   * Returns the last byte's sequence number + 1

   * \returns the last byte's sequence number + 1

*/

*/

  SequenceNumber32 TailSequence (void) const;

  SequenceNumber32 TailSequence (void) const;

/**

/**

   * Returns total number of bytes in this Tx buffer

   * Returns total number of bytes in this Tx buffer

   * \returns total number of bytes in this Tx buffer

*/

*/

  uint32_t Size (void) const;

  uint32_t Size (void) const;

/**

/**

   * Returns the Tx window size

   * Returns the Tx window size

   * \returns the Tx window size (in bytes)

*/

*/

  uint32_t MaxBufferSize (void) const;

  uint32_t MaxBufferSize (void) const;

/**

/**

   * Set the Tx window size

   * Set the Tx window size

   * \param n Tx window size (in bytes)

*/

*/

  void SetMaxBufferSize (uint32_t n);

  void SetMaxBufferSize (uint32_t n);

/**

/**

   * Returns the available capacity in this Tx window

   * Returns the available capacity in this Tx window

   * \returns available capacity in this Tx window

*/

*/

  uint32_t Available (void) const;

  uint32_t Available (void) const;

Lines 86-102	Link Here

100

/**

101

/**

   * Returns the number of bytes from the buffer in the range [seq, tailSequence)

102

   * Returns the number of bytes from the buffer in the range [seq, tailSequence)

103

   * \param seq initial sequence number

104

   * \returns the number of bytes from the buffer in the range

*/

105

*/

  uint32_t SizeFromSequence (const SequenceNumber32& seq) const;

106

  uint32_t SizeFromSequence (const SequenceNumber32& seq) const;

107

/**

108

/**

   * Copy data of size numBytes into a packet, data from the range [seq, seq+numBytes)

109

   * Copy data of size numBytes into a packet, data from the range [seq, seq+numBytes)

110

   * \param numBytes number of bytes to copy

111

   * \param seq start sequence number to extract

112

   * \returns a packet

*/

113

*/

  Ptr<Packet> CopyFromSequence (uint32_t numBytes, const SequenceNumber32& seq);

114

  Ptr<Packet> CopyFromSequence (uint32_t numBytes, const SequenceNumber32& seq);

115

/**

116

/**

   * Set the m_firstByteSeq to seq. Supposed to be called only when the

117

   * Set the m_firstByteSeq to seq. Supposed to be called only when the

   * connection is just set up and we did not send any data out yet.

118

   * connection is just set up and we did not send any data out yet.

119

   * \param seq The sequence number of the head byte

100

*/

120

*/

101

  void SetHeadSequence (const SequenceNumber32& seq);

121

  void SetHeadSequence (const SequenceNumber32& seq);

102

122

Lines 108-119	Link Here

108

  void DiscardUpTo (const SequenceNumber32& seq);

128

  void DiscardUpTo (const SequenceNumber32& seq);

109

129

110

private:

130

private:

131

  /// container for data stored in the buffer

111

  typedef std::list<Ptr<Packet> >::iterator BufIterator;

132

  typedef std::list<Ptr<Packet> >::iterator BufIterator;

112

133

113

  TracedValue<SequenceNumber32> m_firstByteSeq; //< Sequence number of the first byte in data (SND.UNA)

134

  TracedValue<SequenceNumber32> m_firstByteSeq; //!< Sequence number of the first byte in data (SND.UNA)

114

  uint32_t m_size;                              //< Number of data bytes

135

  uint32_t m_size;                              //!< Number of data bytes

115

  uint32_t m_maxBuffer;                         //< Max number of data bytes in buffer (SND.WND)

136

  uint32_t m_maxBuffer;                         //!< Max number of data bytes in buffer (SND.WND)

116

  std::list<Ptr<Packet> > m_data;               //< Corresponding data (may be null)

137

  std::list<Ptr<Packet> > m_data;               //!< Corresponding data (may be null)

117

};

138

};

118

139

119

} // namepsace ns3

140

} // namepsace ns3

(-)a/src/internet/model/tcp-westwood.h (-72 / +39 lines)

Lines 62-79	Link Here

class TcpWestwood : public TcpSocketBase

class TcpWestwood : public TcpSocketBase

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  TcpWestwood (void);

  TcpWestwood (void);

/**

   * \brief Copy constructor

   * \param sock the object to copy

*/

  TcpWestwood (const TcpWestwood& sock);

  TcpWestwood (const TcpWestwood& sock);

  virtual ~TcpWestwood (void);

  virtual ~TcpWestwood (void);

/**

   * \brief Protocol variant (Westwood or Westwood+)

*/

  enum ProtocolType

  enum ProtocolType

    WESTWOOD,

    WESTWOOD,

    WESTWOODPLUS

    WESTWOODPLUS

};

};

/**

   * \brief Filter type (None or Tustin)

*/

  enum FilterType

  enum FilterType

    NONE,

    NONE,

Lines 85-101	Link Here

  virtual int Listen (void);

  virtual int Listen (void);

100

protected:

101

protected:

/**

102

  virtual uint32_t Window (void); // Return the max possible number of unacked bytes

   * Limit the size of outstanding data based on the cwnd and the receiver's advertised window

103

  virtual Ptr<TcpSocketBase> Fork (void); // Call CopyObject<TcpTahoe> to clone me

104

  virtual void NewAck (SequenceNumber32 const& seq); // Inc cwnd and call NewAck() of parent

   * \return the max. possible number of unacked bytes

105

  virtual void DupAck (const TcpHeader& t, uint32_t count);  // Treat 3 dupack as timeout

*/

106

  virtual void Retransmit (void); // Retransmit time out

  virtual uint32_t Window (void);

/**

   * Call CopyObject<TcpWestwood> to clone me

*/

  virtual Ptr<TcpSocketBase> Fork (void);

107

100

/**

108

/**

101

   * Process the newly received ACK

109

   * Process the newly received ACK

Lines 106-163	Link Here

106

  virtual void ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader);

114

  virtual void ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader);

107

115

108

/**

116

/**

109

   * Adjust the cwnd based on the current congestion control phase,

110

   * and then call the TcpSocketBase::NewAck() to complete the processing

111

112

   * \param seq the acknowledgment number

113

*/

114

  virtual void NewAck (SequenceNumber32 const& seq);

115

116

/**

117

   * Adjust the cwnd using the currently estimated bandwidth,

118

   * retransmit the missing packet, and enter fast recovery if 3 DUPACKs are received

119

120

   * \param header the TCP header of the ACK packet

121

   * \param count the number of DUPACKs

122

*/

123

  virtual void DupAck (const TcpHeader& header, uint32_t count);

124

125

/**

126

   * Upon an RTO event, adjust the cwnd using the currently estimated bandwidth,

127

   * retransmit the missing packet, and exit fast recovery

128

*/

129

  virtual void Retransmit (void);

130

131

/**

132

   * Estimate the RTT, record the minimum value,

117

   * Estimate the RTT, record the minimum value,

133

   * and run a clock on the RTT to trigger Westwood+ bandwidth sampling

118

   * and run a clock on the RTT to trigger Westwood+ bandwidth sampling

119

   * \param header the packet header

134

*/

120

*/

135

  virtual void EstimateRtt (const TcpHeader& header);

121

  virtual void EstimateRtt (const TcpHeader& header);

136

122

137

  // Implementing ns3::TcpSocket -- Attribute get/set

123

  // Implementing ns3::TcpSocket -- Attribute get/set

138

/**

124

  virtual void     SetSegSize (uint32_t size);

139

   * \param size the segment size to be used in a connection

125

  virtual void     SetSSThresh (uint32_t threshold);

140

*/

141

  virtual void SetSegSize (uint32_t size);

142

143

/**

144

   * \param the slow-start threshold

145

*/

146

  virtual void SetSSThresh (uint32_t threshold);

147

148

/**

149

   * \return the slow-start threshold

150

*/

151

  virtual uint32_t GetSSThresh (void) const;

126

  virtual uint32_t GetSSThresh (void) const;

152

127

  virtual void     SetInitialCwnd (uint32_t cwnd);

153

/**

154

   * \param cwnd the initial cwnd

155

*/

156

  virtual void SetInitialCwnd (uint32_t cwnd);

157

158

/**

159

   * \return the initial cwnd

160

*/

161

  virtual uint32_t GetInitialCwnd (void) const;

128

  virtual uint32_t GetInitialCwnd (void) const;

162

129

163

private:

130

private:

Lines 196-219	Link Here

196

  void Filtering (void);

163

  void Filtering (void);

197

164

198

protected:

165

protected:

199

  TracedValue<uint32_t>  m_cWnd;                   //< Congestion window

166

  TracedValue<uint32_t>  m_cWnd;                   //!< Congestion window

200

  uint32_t               m_ssThresh;               //< Slow Start Threshold

167

  uint32_t               m_ssThresh;               //!< Slow Start Threshold

201

  uint32_t               m_initialCWnd;            //< Initial cWnd value

168

  uint32_t               m_initialCWnd;            //!< Initial cWnd value

202

  bool                   m_inFastRec;              //< Currently in fast recovery if TRUE

169

  bool                   m_inFastRec;              //!< Currently in fast recovery if TRUE

203

170

204

  TracedValue<double>    m_currentBW;              //< Current value of the estimated BW

171

  TracedValue<double>    m_currentBW;              //!< Current value of the estimated BW

205

  double                 m_lastSampleBW;           //< Last bandwidth sample

172

  double                 m_lastSampleBW;           //!< Last bandwidth sample

206

  double                 m_lastBW;                 //< Last bandwidth sample after being filtered

173

  double                 m_lastBW;                 //!< Last bandwidth sample after being filtered

207

  Time                   m_minRtt;                 //< Minimum RTT

174

  Time                   m_minRtt;                 //!< Minimum RTT

208

  double                 m_lastAck;                //< The time last ACK was received

175

  double                 m_lastAck;                //!< The time last ACK was received

209

  SequenceNumber32       m_prevAckNo;              //< Previously received ACK number

176

  SequenceNumber32       m_prevAckNo;              //!< Previously received ACK number

210

  int                    m_accountedFor;           //< The number of received DUPACKs

177

  int                    m_accountedFor;           //!< The number of received DUPACKs

211

  enum ProtocolType      m_pType;                  //< 0 for Westwood, 1 for Westwood+

178

  enum ProtocolType      m_pType;                  //!< 0 for Westwood, 1 for Westwood+

212

  enum FilterType        m_fType;                  //< 0 for none, 1 for Tustin

179

  enum FilterType        m_fType;                  //!< 0 for none, 1 for Tustin

213

180

214

  int                    m_ackedSegments;          //< The number of segments ACKed between RTTs

181

  int                    m_ackedSegments;          //!< The number of segments ACKed between RTTs

215

  bool                   m_IsCount;                //< Start keeping track of m_ackedSegments for Westwood+ if TRUE

182

  bool                   m_IsCount;                //!< Start keeping track of m_ackedSegments for Westwood+ if TRUE

216

  EventId                m_bwEstimateEvent;        //< The BW estimation event for Westwood+

183

  EventId                m_bwEstimateEvent;        //!< The BW estimation event for Westwood+

217

184

218

};

185

};

219

186

(-)a/src/internet/model/udp-header.h (-8 / +17 lines)

Lines 114-119	Link Here

114

                           Ipv6Address destination,

114

                           Ipv6Address destination,

115

                           uint8_t protocol);

115

                           uint8_t protocol);

116

117

/**

118

   * \brief Get the type ID.

119

   * \return the object TypeId

120

*/

117

  static TypeId GetTypeId (void);

121

  static TypeId GetTypeId (void);

118

  virtual TypeId GetInstanceTypeId (void) const;

122

  virtual TypeId GetInstanceTypeId (void) const;

119

  virtual void Print (std::ostream &os) const;

123

  virtual void Print (std::ostream &os) const;

Lines 128-143	Link Here

128

  bool IsChecksumOk (void) const;

132

  bool IsChecksumOk (void) const;

129

133

130

private:

134

private:

135

/**

136

   * \brief Calculate the header checksum

137

   * \param size packet size

138

   * \returns the checksum

139

*/

131

  uint16_t CalculateHeaderChecksum (uint16_t size) const;

140

  uint16_t CalculateHeaderChecksum (uint16_t size) const;

132

  uint16_t m_sourcePort;

141

  uint16_t m_sourcePort;      //!< Source port

133

  uint16_t m_destinationPort;

142

  uint16_t m_destinationPort; //!< Destination port

134

  uint16_t m_payloadSize;

143

  uint16_t m_payloadSize;     //!< Payload size

135

144

136

  Address m_source;

145

  Address m_source;           //!< Source IP address

137

  Address m_destination;

146

  Address m_destination;      //!< Destination IP address

138

  uint8_t m_protocol;

147

  uint8_t m_protocol;         //!< Protocol number

139

  bool m_calcChecksum;

148

  bool m_calcChecksum;        //!< Flag to calculate checksum

140

  bool m_goodChecksum;

149

  bool m_goodChecksum;        //!< Flag to indicate that checksum is correct

141

};

150

};

142

151

143

} // namespace ns3

152

} // namespace ns3

(-)a/src/internet/model/udp-l4-protocol.h (-32 / +129 lines)

Lines 47-58	Link Here

*/

*/

class UdpL4Protocol : public IpL4Protocol {

class UdpL4Protocol : public IpL4Protocol {

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  static const uint8_t PROT_NUMBER;

  static const uint8_t PROT_NUMBER; //!< protocol number (0x11)

  UdpL4Protocol ();

  UdpL4Protocol ();

  virtual ~UdpL4Protocol ();

  virtual ~UdpL4Protocol ();

/**

   * Set node associated with this stack

   * \param node the node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

  virtual int GetProtocolNumber (void) const;

  virtual int GetProtocolNumber (void) const;

Lines 63-87	Link Here

*/

*/

  Ptr<Socket> CreateSocket (void);

  Ptr<Socket> CreateSocket (void);

/**

   * \brief Allocate an IPv4 Endpoint

   * \return the Endpoint

*/

  Ipv4EndPoint *Allocate (void);

  Ipv4EndPoint *Allocate (void);

/**

   * \brief Allocate an IPv4 Endpoint

   * \param address address to use

   * \return the Endpoint

*/

  Ipv4EndPoint *Allocate (Ipv4Address address);

  Ipv4EndPoint *Allocate (Ipv4Address address);

/**

   * \brief Allocate an IPv4 Endpoint

   * \param port port to use

   * \return the Endpoint

*/

  Ipv4EndPoint *Allocate (uint16_t port);

  Ipv4EndPoint *Allocate (uint16_t port);

/**

   * \brief Allocate an IPv4 Endpoint

   * \param address address to use

   * \param port port to use

   * \return the Endpoint

*/

  Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port);

  Ipv4EndPoint *Allocate (Ipv4Address address, uint16_t port);

/**

   * \brief Allocate an IPv4 Endpoint

100

   * \param localAddress local address to use

101

   * \param localPort local port to use

102

   * \param peerAddress remote address to use

103

   * \param peerPort remote port to use

104

   * \return the Endpoint

105

*/

  Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort,

106

  Ipv4EndPoint *Allocate (Ipv4Address localAddress, uint16_t localPort,

                          Ipv4Address peerAddress, uint16_t peerPort);

107

                          Ipv4Address peerAddress, uint16_t peerPort);

108

109

/**

110

   * \brief Allocate an IPv6 Endpoint

111

   * \return the Endpoint

112

*/

  Ipv6EndPoint *Allocate6 (void);

113

  Ipv6EndPoint *Allocate6 (void);

114

/**

115

   * \brief Allocate an IPv6 Endpoint

116

   * \param address address to use

117

   * \return the Endpoint

118

*/

  Ipv6EndPoint *Allocate6 (Ipv6Address address);

119

  Ipv6EndPoint *Allocate6 (Ipv6Address address);

120

/**

121

   * \brief Allocate an IPv6 Endpoint

122

   * \param port port to use

123

   * \return the Endpoint

124

*/

  Ipv6EndPoint *Allocate6 (uint16_t port);

125

  Ipv6EndPoint *Allocate6 (uint16_t port);

126

/**

127

   * \brief Allocate an IPv6 Endpoint

128

   * \param address address to use

129

   * \param port port to use

130

   * \return the Endpoint

131

*/

  Ipv6EndPoint *Allocate6 (Ipv6Address address, uint16_t port);

132

  Ipv6EndPoint *Allocate6 (Ipv6Address address, uint16_t port);

133

/**

134

   * \brief Allocate an IPv6 Endpoint

135

   * \param localAddress local address to use

136

   * \param localPort local port to use

137

   * \param peerAddress remote address to use

138

   * \param peerPort remote port to use

139

   * \return the Endpoint

140

*/

  Ipv6EndPoint *Allocate6 (Ipv6Address localAddress, uint16_t localPort,

141

  Ipv6EndPoint *Allocate6 (Ipv6Address localAddress, uint16_t localPort,

                          Ipv6Address peerAddress, uint16_t peerPort);

142

                           Ipv6Address peerAddress, uint16_t peerPort);

143

144

/**

145

   * \brief Remove an IPv4 Endpoint.

146

   * \param endPoint the end point to remove

147

*/

  void DeAllocate (Ipv4EndPoint *endPoint);

148

  void DeAllocate (Ipv4EndPoint *endPoint);

149

/**

150

   * \brief Remove an IPv6 Endpoint.

151

   * \param endPoint the end point to remove

152

*/

  void DeAllocate (Ipv6EndPoint *endPoint);

153

  void DeAllocate (Ipv6EndPoint *endPoint);

154

  // called by UdpSocket.

155

  // called by UdpSocket.

/**

156

/**

   * \brief Send a packet via UDP

157

   * \brief Send a packet via UDP (IPv4)

   * \param packet The packet to send

158

   * \param packet The packet to send

   * \param saddr The source Ipv4Address

159

   * \param saddr The source Ipv4Address

   * \param daddr The destination Ipv4Address

160

   * \param daddr The destination Ipv4Address

Lines 91-130	Link Here

  void Send (Ptr<Packet> packet,

164

  void Send (Ptr<Packet> packet,

             Ipv4Address saddr, Ipv4Address daddr,

165

             Ipv4Address saddr, Ipv4Address daddr,

             uint16_t sport, uint16_t dport);

166

             uint16_t sport, uint16_t dport);

167

/**

168

   * \brief Send a packet via UDP (IPv4)

169

   * \param packet The packet to send

170

   * \param saddr The source Ipv4Address

171

   * \param daddr The destination Ipv4Address

172

   * \param sport The source port number

173

   * \param dport The destination port number

174

   * \param route The route

175

*/

  void Send (Ptr<Packet> packet,

176

  void Send (Ptr<Packet> packet,

             Ipv4Address saddr, Ipv4Address daddr,

177

             Ipv4Address saddr, Ipv4Address daddr,

             uint16_t sport, uint16_t dport, Ptr<Ipv4Route> route);

178

             uint16_t sport, uint16_t dport, Ptr<Ipv4Route> route);

179

/**

180

   * \brief Send a packet via UDP (IPv6)

181

   * \param packet The packet to send

182

   * \param saddr The source Ipv4Address

183

   * \param daddr The destination Ipv4Address

184

   * \param sport The source port number

185

   * \param dport The destination port number

186

*/

  void Send (Ptr<Packet> packet,

187

  void Send (Ptr<Packet> packet,

             Ipv6Address saddr, Ipv6Address daddr,

188

             Ipv6Address saddr, Ipv6Address daddr,

             uint16_t sport, uint16_t dport);

189

             uint16_t sport, uint16_t dport);

190

/**

191

   * \brief Send a packet via UDP (IPv6)

192

   * \param packet The packet to send

193

   * \param saddr The source Ipv4Address

194

   * \param daddr The destination Ipv4Address

195

   * \param sport The source port number

196

   * \param dport The destination port number

197

   * \param route The route

198

*/

100

  void Send (Ptr<Packet> packet,

199

  void Send (Ptr<Packet> packet,

101

             Ipv6Address saddr, Ipv6Address daddr,

200

             Ipv6Address saddr, Ipv6Address daddr,

102

             uint16_t sport, uint16_t dport, Ptr<Ipv6Route> route);

201

             uint16_t sport, uint16_t dport, Ptr<Ipv6Route> route);

103

/**

202

104

   * \brief Receive a packet up the protocol stack

105

   * \param p The Packet to dump the contents into

106

   * \param header IPv4 Header information

107

   * \param interface the interface from which the packet is coming.

108

*/

109

  // inherited from Ipv4L4Protocol

203

  // inherited from Ipv4L4Protocol

110

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

204

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

111

                                                 Ipv4Header const &header,

205

                                               Ipv4Header const &header,

112

                                                 Ptr<Ipv4Interface> interface);

206

                                               Ptr<Ipv4Interface> interface);

113

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

207

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

114

                                                 Ipv6Header const &header,

208

                                               Ipv6Header const &header,

115

                                                 Ptr<Ipv6Interface> interface);

209

                                               Ptr<Ipv6Interface> interface);

116

210

117

/**

118

   * \brief Receive an ICMP packet

119

   * \param icmpSource The IP address of the source of the packet.

120

   * \param icmpTtl The time to live from the IP header

121

   * \param icmpType The type of the message from the ICMP header

122

   * \param icmpCode The message code from the ICMP header

123

   * \param icmpInfo 32-bit integer carrying informational value of varying semantics.

124

   * \param payloadSource The IP source address from the IP header of the packet

125

   * \param payloadDestination The IP destination address from the IP header of the packet

126

   * \param payload Payload of the ICMP packet

127

*/

128

  virtual void ReceiveIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

211

  virtual void ReceiveIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

129

                            uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo,

212

                            uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo,

130

                            Ipv4Address payloadSource,Ipv4Address payloadDestination,

213

                            Ipv4Address payloadSource,Ipv4Address payloadDestination,

Lines 149-162	Link Here

149

*/

232

*/

150

  virtual void NotifyNewAggregate ();

233

  virtual void NotifyNewAggregate ();

151

private:

234

private:

152

  Ptr<Node> m_node;

235

  Ptr<Node> m_node; //!< the node this stack is associated with

153

  Ipv4EndPointDemux *m_endPoints;

236

  Ipv4EndPointDemux *m_endPoints; //!< A list of IPv4 end points.

154

  Ipv6EndPointDemux *m_endPoints6;

237

  Ipv6EndPointDemux *m_endPoints6; //!< A list of IPv6 end points.

155

  UdpL4Protocol (const UdpL4Protocol &o);

238

156

  UdpL4Protocol &operator = (const UdpL4Protocol &o);

239

/**

157

  std::vector<Ptr<UdpSocketImpl> > m_sockets;

240

   * \brief Copy constructor

158

  IpL4Protocol::DownTargetCallback m_downTarget;

241

159

  IpL4Protocol::DownTargetCallback6 m_downTarget6;

242

   * Defined and not implemented to avoid misuse

243

*/

244

  UdpL4Protocol (const UdpL4Protocol &);

245

/**

246

   * \brief Copy constructor

247

248

   * Defined and not implemented to avoid misuse

249

   * \returns

250

*/

251

  UdpL4Protocol &operator = (const UdpL4Protocol &);

252

253

  std::vector<Ptr<UdpSocketImpl> > m_sockets;      //!< list of sockets

254

  IpL4Protocol::DownTargetCallback m_downTarget;   //!< Callback to send packets over IPv4

255

  IpL4Protocol::DownTargetCallback6 m_downTarget6; //!< Callback to send packets over IPv6

256

160

};

257

};

161

258

162

} // namespace ns3

259

} // namespace ns3

(-)a/src/internet/model/udp-socket-factory-impl.h (-1 / +5 lines)

Lines 57-62	Link Here

  UdpSocketFactoryImpl ();

  UdpSocketFactoryImpl ();

  virtual ~UdpSocketFactoryImpl ();

  virtual ~UdpSocketFactoryImpl ();

/**

   * \brief Set the associated UDP L4 protocol.

   * \param udp the UDP L4 protocol

*/

  void SetUdp (Ptr<UdpL4Protocol> udp);

  void SetUdp (Ptr<UdpL4Protocol> udp);

/**

/**

Lines 71-77	Link Here

protected:

protected:

  virtual void DoDispose (void);

  virtual void DoDispose (void);

private:

private:

  Ptr<UdpL4Protocol> m_udp;

  Ptr<UdpL4Protocol> m_udp; //!< the associated UDP L4 protocol

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/internet/model/udp-socket-factory.h (+4 lines)

Lines 40-45	Link Here

class UdpSocketFactory : public SocketFactory

class UdpSocketFactory : public SocketFactory

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

};

};

(-)a/src/internet/model/udp-socket-impl.cc (-3 / +6 lines)

Lines 45-51	Link Here

NS_OBJECT_ENSURE_REGISTERED (UdpSocketImpl)

NS_OBJECT_ENSURE_REGISTERED (UdpSocketImpl)

static const uint32_t MAX_IPV4_UDP_DATAGRAM_SIZE = 65507;

// The correct maximum UDP message size is 65507, as determined by the following formula:

// 0xffff - (sizeof(IP Header) + sizeof(UDP Header)) = 65535-(20+8) = 65507

// \todo MAX_IPV4_UDP_DATAGRAM_SIZE is correct only for IPv4

static const uint32_t MAX_IPV4_UDP_DATAGRAM_SIZE = 65507; //!< Maximum UDP datagram size

// Add attributes generic to all UdpSockets to base class UdpSocket

// Add attributes generic to all UdpSockets to base class UdpSocket

TypeId

TypeId

Lines 736-744	Link Here

736

739

737

740

738

741

739

//  maximum message size for UDP broadcast is limited by MTU

742

// maximum message size for UDP broadcast is limited by MTU

740

// size of underlying link; we are not checking that now.

743

// size of underlying link; we are not checking that now.

741

/// \todo Check MTU size of underlying link

744

// \todo Check MTU size of underlying link

742

uint32_t

745

uint32_t

743

UdpSocketImpl::GetTxAvailable (void) const

746

UdpSocketImpl::GetTxAvailable (void) const

744

747

(-)a/src/internet/model/udp-socket-impl.h (-30 / +121 lines)

Lines 50-55	Link Here

class UdpSocketImpl : public UdpSocket

class UdpSocketImpl : public UdpSocket

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * Create an unbound udp socket.

   * Create an unbound udp socket.

Lines 57-63	Link Here

  UdpSocketImpl ();

  UdpSocketImpl ();

  virtual ~UdpSocketImpl ();

  virtual ~UdpSocketImpl ();

/**

   * \brief Set the associated node.

   * \param node the node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

/**

   * \brief Set the associated UDP L4 protocol.

   * \param udp the UDP L4 protocol

*/

  void SetUdp (Ptr<UdpL4Protocol> udp);

  void SetUdp (Ptr<UdpL4Protocol> udp);

  virtual enum SocketErrno GetErrno (void) const;

  virtual enum SocketErrno GetErrno (void) const;

Lines 101-148	Link Here

101

113

102

  friend class UdpSocketFactory;

114

  friend class UdpSocketFactory;

103

  // invoked by Udp class

115

  // invoked by Udp class

116

117

/**

118

   * Finish the binding process

119

   * \returns 0 on success, -1 on failure

120

*/

104

  int FinishBind (void);

121

  int FinishBind (void);

105

  void ForwardUp (Ptr<Packet> p, Ipv4Header header, uint16_t port,

122

106

                  Ptr<Ipv4Interface> incomingInterface);

123

/**

107

  void ForwardUp6 (Ptr<Packet> p, Ipv6Header header, uint16_t port);

124

   * \brief Called by the L3 protocol when it received a packet to pass on to TCP.

125

126

   * \param packet the incoming packet

127

   * \param header the packet's IPv4 header

128

   * \param port the incoming port

129

   * \param incomingInterface the incoming interface

130

*/

131

  void ForwardUp (Ptr<Packet> packet, Ipv4Header header, uint16_t port, Ptr<Ipv4Interface> incomingInterface);

132

133

/**

134

   * \brief Called by the L3 protocol when it received a packet to pass on to TCP.

135

136

   * \param packet the incoming packet

137

   * \param header the packet's IPv6 header

138

   * \param port the incoming port

139

*/

140

  void ForwardUp6 (Ptr<Packet> packet, Ipv6Header header, uint16_t port);

141

142

/**

143

   * \brief Kill this socket by zeroing its attributes (IPv4)

144

145

   * This is a callback function configured to m_endpoint in

146

   * SetupCallback(), invoked when the endpoint is destroyed.

147

*/

108

  void Destroy (void);

148

  void Destroy (void);

149

150

/**

151

   * \brief Kill this socket by zeroing its attributes (IPv6)

152

153

   * This is a callback function configured to m_endpoint in

154

   * SetupCallback(), invoked when the endpoint is destroyed.

155

*/

109

  void Destroy6 (void);

156

  void Destroy6 (void);

157

158

/**

159

   * \brief Send a packet

160

   * \param p packet

161

   * \returns 0 on success, -1 on failure

162

*/

110

  int DoSend (Ptr<Packet> p);

163

  int DoSend (Ptr<Packet> p);

164

/**

165

   * \brief Send a packet to a specific destination

166

   * \param p packet

167

   * \param daddr destination address

168

   * \returns 0 on success, -1 on failure

169

*/

111

  int DoSendTo (Ptr<Packet> p, const Address &daddr);

170

  int DoSendTo (Ptr<Packet> p, const Address &daddr);

171

/**

172

   * \brief Send a packet to a specific destination and port (IPv4)

173

   * \param p packet

174

   * \param daddr destination address

175

   * \param dport destination port

176

   * \returns 0 on success, -1 on failure

177

*/

112

  int DoSendTo (Ptr<Packet> p, Ipv4Address daddr, uint16_t dport);

178

  int DoSendTo (Ptr<Packet> p, Ipv4Address daddr, uint16_t dport);

179

/**

180

   * \brief Send a packet to a specific destination and port (IPv6)

181

   * \param p packet

182

   * \param daddr destination address

183

   * \param dport destination port

184

   * \returns 0 on success, -1 on failure

185

*/

113

  int DoSendTo (Ptr<Packet> p, Ipv6Address daddr, uint16_t dport);

186

  int DoSendTo (Ptr<Packet> p, Ipv6Address daddr, uint16_t dport);

114

  void ForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,

115

                    uint8_t icmpType, uint8_t icmpCode,

116

                    uint32_t icmpInfo);

117

  void ForwardIcmp6 (Ipv6Address icmpSource, uint8_t icmpTtl,

118

                     uint8_t icmpType, uint8_t icmpCode,

119

                     uint32_t icmpInfo);

120

187

121

  Ipv4EndPoint *m_endPoint;

188

/**

122

  Ipv6EndPoint *m_endPoint6;

189

   * \brief Called by the L3 protocol when it received an ICMP packet to pass on to TCP.

123

  Ptr<Node> m_node;

190

124

  Ptr<UdpL4Protocol> m_udp;

191

   * \param icmpSource the ICMP source address

125

  Address m_defaultAddress;

192

   * \param icmpTtl the ICMP Time to Live

126

  uint16_t m_defaultPort;

193

   * \param icmpType the ICMP Type

127

  TracedCallback<Ptr<const Packet> > m_dropTrace;

194

   * \param icmpCode the ICMP Code

195

   * \param icmpInfo the ICMP Info

196

*/

197

  void ForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo);

128

198

129

  enum SocketErrno m_errno;

199

/**

130

  bool m_shutdownSend;

200

   * \brief Called by the L3 protocol when it received an ICMPv6 packet to pass on to TCP.

131

  bool m_shutdownRecv;

201

132

  bool m_connected;

202

   * \param icmpSource the ICMP source address

133

  bool m_allowBroadcast;

203

   * \param icmpTtl the ICMP Time to Live

204

   * \param icmpType the ICMP Type

205

   * \param icmpCode the ICMP Code

206

   * \param icmpInfo the ICMP Info

207

*/

208

  void ForwardIcmp6 (Ipv6Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo);

134

209

135

  std::queue<Ptr<Packet> > m_deliveryQueue;

210

  // Connections to other layers of TCP/IP

136

  uint32_t m_rxAvailable;

211

  Ipv4EndPoint*       m_endPoint;   //!< the IPv4 endpoint

212

  Ipv6EndPoint*       m_endPoint6;  //!< the IPv6 endpoint

213

  Ptr<Node>           m_node;       //!< the associated node

214

  Ptr<UdpL4Protocol> m_udp;         //!< the associated UDP L4 protocol

215

  Callback<void, Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback;  //!< ICMP callback

216

  Callback<void, Ipv6Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback6; //!< ICMPv6 callback

217

218

  Address m_defaultAddress; //!< Default address

219

  uint16_t m_defaultPort;   //!< Default port

220

  TracedCallback<Ptr<const Packet> > m_dropTrace; //!< Trace for dropped packets

221

222

  enum SocketErrno         m_errno;           //!< Socket error code

223

  bool                     m_shutdownSend;    //!< Send no longer allowed

224

  bool                     m_shutdownRecv;    //!< Receive no longer allowed

225

  bool                     m_connected;       //!< Connection established

226

  bool                     m_allowBroadcast;  //!< Allow send broadcast packets

227

228

  std::queue<Ptr<Packet> > m_deliveryQueue; //!< Queue for incoming packets

229

  uint32_t m_rxAvailable;                   //!< Number of available bytes to be received

137

230

138

  // Socket attributes

231

  // Socket attributes

139

  uint32_t m_rcvBufSize;

232

  uint32_t m_rcvBufSize;    //!< Receive buffer size

140

  uint8_t m_ipMulticastTtl;

233

  uint8_t m_ipMulticastTtl; //!< Multicast TTL

141

  int32_t m_ipMulticastIf;

234

  int32_t m_ipMulticastIf;  //!< Multicast Interface

142

  bool m_ipMulticastLoop;

235

  bool m_ipMulticastLoop;   //!< Allow multicast loop

143

  bool m_mtuDiscover;

236

  bool m_mtuDiscover;       //!< Allow MTU discovery

144

  Callback<void, Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback;

145

  Callback<void, Ipv6Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback6;

146

};

237

};

147

238

148

} // namespace ns3

239

} // namespace ns3

(-)a/src/internet/model/udp-socket.h (+57 lines)

Lines 46-51	Link Here

class UdpSocket : public Socket

class UdpSocket : public Socket

public:

public:

/**

   * Get the type ID.

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  UdpSocket (void);

  UdpSocket (void);

Lines 99-113	Link Here

104

100

private:

105

private:

101

  // Indirect the attribute setting and getting through private virtual methods

106

  // Indirect the attribute setting and getting through private virtual methods

107

/**

108

   * \brief Set the receiving buffer size

109

   * \param size the buffer size

110

*/

102

  virtual void SetRcvBufSize (uint32_t size) = 0;

111

  virtual void SetRcvBufSize (uint32_t size) = 0;

112

/**

113

   * \brief Get the receiving buffer size

114

   * \returns the buffer size

115

*/

103

  virtual uint32_t GetRcvBufSize (void) const = 0;

116

  virtual uint32_t GetRcvBufSize (void) const = 0;

117

/**

118

   * \brief Set the IP multicast TTL

119

   * \param ipTtl the IP multicast TTL

120

*/

104

  virtual void SetIpMulticastTtl (uint8_t ipTtl) = 0;

121

  virtual void SetIpMulticastTtl (uint8_t ipTtl) = 0;

122

/**

123

   * \brief Get the IP multicast TTL

124

   * \returns the IP multicast TTL

125

*/

105

  virtual uint8_t GetIpMulticastTtl (void) const = 0;

126

  virtual uint8_t GetIpMulticastTtl (void) const = 0;

127

/**

128

   * \brief Set the IP multicast interface

129

   * \param ipIf the IP multicast interface

130

*/

106

  virtual void SetIpMulticastIf (int32_t ipIf) = 0;

131

  virtual void SetIpMulticastIf (int32_t ipIf) = 0;

132

/**

133

   * \brief Get the IP multicast interface

134

   * \returns the IP multicast interface

135

*/

107

  virtual int32_t GetIpMulticastIf (void) const = 0;

136

  virtual int32_t GetIpMulticastIf (void) const = 0;

137

/**

138

   * \brief Set the IP multicast loop capability

139

140

   * This means that the socket will receive the packets

141

   * sent by itself on a multicast address.

142

   * Equivalent to setsockopt  IP_MULTICAST_LOOP

143

144

   * \param loop the IP multicast loop capability

145

*/

108

  virtual void SetIpMulticastLoop (bool loop) = 0;

146

  virtual void SetIpMulticastLoop (bool loop) = 0;

147

/**

148

   * \brief Get the IP multicast loop capability

149

150

   * This means that the socket will receive the packets

151

   * sent by itself on a multicast address.

152

   * Equivalent to setsockopt  IP_MULTICAST_LOOP

153

154

   * \returns the IP multicast loop capability

155

*/

109

  virtual bool GetIpMulticastLoop (void) const = 0;

156

  virtual bool GetIpMulticastLoop (void) const = 0;

157

/**

158

   * \brief Set the MTU discover capability

159

160

   * \param discover the MTU discover capability

161

*/

110

  virtual void SetMtuDiscover (bool discover) = 0;

162

  virtual void SetMtuDiscover (bool discover) = 0;

163

/**

164

   * \brief Get the MTU discover capability

165

166

   * \returns the MTU discover capability

167

*/

111

  virtual bool GetMtuDiscover (void) const = 0;

168

  virtual bool GetMtuDiscover (void) const = 0;

112

};

169

};

113

170

(-)a/src/network/model/socket.h (-1 / +5 lines)

Lines 119-124	Link Here

119

*/

119

*/

120

  static Ptr<Socket> CreateSocket (Ptr<Node> node, TypeId tid);

120

  static Ptr<Socket> CreateSocket (Ptr<Node> node, TypeId tid);

121

/**

121

/**

122

   * \brief Get last error number.

123

122

   * \return the errno associated to the last call which failed in this

124

   * \return the errno associated to the last call which failed in this

123

   *         socket. Each socket's errno is initialized to zero

125

   *         socket. Each socket's errno is initialized to zero

124

   *         when the socket is created.

126

   *         when the socket is created.

Lines 129-135	Link Here

129

*/

131

*/

130

  virtual enum Socket::SocketType GetSocketType (void) const = 0;

132

  virtual enum Socket::SocketType GetSocketType (void) const = 0;

131

/**

133

/**

132

   * \returns the node this socket is associated with.

134

   * \brief Return the node this socket is associated with.

135

   * \returns the node

133

*/

136

*/

134

  virtual Ptr<Node> GetNode (void) const = 0;

137

  virtual Ptr<Node> GetNode (void) const = 0;

135

/**

138

/**

Lines 551-556	Link Here

551

  int RecvFrom (uint8_t* buf, uint32_t size, uint32_t flags,

554

  int RecvFrom (uint8_t* buf, uint32_t size, uint32_t flags,

552

                Address &fromAddress);

555

                Address &fromAddress);

553

/**

556

/**

557

   * \brief Get socket address.

554

   * \param address the address name this socket is associated with.

558

   * \param address the address name this socket is associated with.

555

   * \returns 0 if success, -1 otherwise

559

   * \returns 0 if success, -1 otherwise

556

*/

560

*/

Return to bug 938