Attachment #1790 for bug #938

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

(-)a/src/network/helper/application-container.h (-1 / +2 lines)

Lines 64-69	Link Here

*/

*/

  ApplicationContainer (std::string name);

  ApplicationContainer (std::string name);

  /// Application container iterator

  typedef std::vector<Ptr<Application> >::const_iterator Iterator;

  typedef std::vector<Ptr<Application> >::const_iterator Iterator;

/**

/**

Lines 209-215	Link Here

209

  void Stop (Time stop);

210

  void Stop (Time stop);

210

211

private:

212

private:

212

  std::vector<Ptr<Application> > m_applications;

213

  std::vector<Ptr<Application> > m_applications; //!< Applications smart pointers

213

};

214

};

214

215

} // namespace ns3

216

} // namespace ns3

(-)a/src/network/helper/delay-jitter-estimation.cc (-1 / +15 lines)

Lines 25-34	Link Here

namespace ns3 {

namespace ns3 {

/**

 * Tag to perform Delay and Jitter estimations

 * The tag holds the packet's creation timestamp

*/

class DelayJitterEstimationTimestampTag : public Tag

class DelayJitterEstimationTimestampTag : public Tag

public:

public:

  DelayJitterEstimationTimestampTag ();

  DelayJitterEstimationTimestampTag ();

/**

   * \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;

Lines 37-45	Link Here

  virtual void Deserialize (TagBuffer i);

  virtual void Deserialize (TagBuffer i);

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

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

/**

   * \brief Get the Transmission time stored in the tag

   * \return the transmission time

*/

  Time GetTxTime (void) const;

  Time GetTxTime (void) const;

private:

private:

  uint64_t m_creationTime;

  uint64_t m_creationTime; //!< The time stored in the tag

};

};

DelayJitterEstimationTimestampTag::DelayJitterEstimationTimestampTag ()

DelayJitterEstimationTimestampTag::DelayJitterEstimationTimestampTag ()

(-)a/src/network/helper/delay-jitter-estimation.h (-4 / +4 lines)

Lines 69-78	Link Here

  uint64_t GetLastJitter (void) const;

  uint64_t GetLastJitter (void) const;

private:

private:

  Time m_previousRx;

  Time m_previousRx;   //!< Previous Rx time

  Time m_previousRxTx;

  Time m_previousRxTx; //!< Previous Rx or Tx time

  int64x64_t m_jitter;

  int64x64_t m_jitter; //!< Jitter estimation

  Time m_delay;

  Time m_delay;        //!< Delay estimation

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/network/helper/net-device-container.h (-1 / +2 lines)

Lines 41-46	Link Here

class NetDeviceContainer

class NetDeviceContainer

public:

public:

  /// NetDevice container iterator

  typedef std::vector<Ptr<NetDevice> >::const_iterator Iterator;

  typedef std::vector<Ptr<NetDevice> >::const_iterator Iterator;

/**

/**

Lines 195-201	Link Here

195

  void Add (std::string deviceName);

196

  void Add (std::string deviceName);

196

197

private:

198

private:

198

  std::vector<Ptr<NetDevice> > m_devices;

199

  std::vector<Ptr<NetDevice> > m_devices; //!< NetDevices smart pointers

199

};

200

};

200

201

} // namespace ns3

202

} // namespace ns3

(-)a/src/network/helper/node-container.h (-1 / +2 lines)

Lines 38-43	Link Here

class NodeContainer

class NodeContainer

public:

public:

  /// Node container iterator

  typedef std::vector<Ptr<Node> >::const_iterator Iterator;

  typedef std::vector<Ptr<Node> >::const_iterator Iterator;

/**

/**

Lines 288-294	Link Here

288

  static NodeContainer GetGlobal (void);

289

  static NodeContainer GetGlobal (void);

289

290

private:

291

private:

291

  std::vector<Ptr<Node> > m_nodes;

292

  std::vector<Ptr<Node> > m_nodes; //!< Nodes smart pointers

292

};

293

};

293

294

} // namespace ns3

295

} // namespace ns3




   * @param prefix prefix string
   * @param device NetDevice
   * @param useObjectNames use node and device names instead of indexes
   * @returns file name
   */
  std::string GetFilenameFromDevice (std::string prefix, Ptr<NetDevice> device, bool useObjectNames = true);


   * @param object interface (such as Ipv4Interface or Ipv6Interface)
   * @param interface interface id
   * @param useObjectNames use node and device names instead of indexes
   * @returns file name
   */
  std::string GetFilenameFromInterfacePair (std::string prefix, Ptr<Object> object, 
                                            uint32_t interface, bool useObjectNames = true);

   * @param dataLinkType data link type of packet data
   * @param snapLen maximum length of packet data stored in records
   * @param tzCorrection time zone correction to be applied to timestamps of packets
   * @returns a smart pointer to the Pcap file
   */
  Ptr<PcapFileWrapper> CreateFile (std::string filename, std::ios::openmode filemode,
                                   uint32_t dataLinkType,  uint32_t snapLen = 65535, int32_t tzCorrection = 0);

  template <typename T> void HookDefaultSink (Ptr<T> object, std::string traceName, Ptr<PcapFileWrapper> file);

private:
  /**
   * The basic default trace sink.
   *
   * This one just writes the packet to the pcap
   * file which is good enough for most kinds of captures.
   *
   * @param file the file to write to
   * @param p the packet to write
   */
  static void DefaultSink (Ptr<PcapFileWrapper> file, Ptr<const Packet> p);
};


   * @param prefix prefix string
   * @param device NetDevice
   * @param useObjectNames use node and device names instead of indexes
   * @returns file name
   */
  std::string GetFilenameFromDevice (std::string prefix, Ptr<NetDevice> device, bool useObjectNames = true);


   * @param object interface (such as Ipv4Interface or Ipv6Interface)
   * @param interface interface id
   * @param useObjectNames use node and device names instead of indexes
   * @returns file name
   */
  std::string GetFilenameFromInterfacePair (std::string prefix, Ptr<Object> object, 
                                            uint32_t interface, bool useObjectNames = true);

   * 
   * @param filename file name
   * @param filemode file mode
   * @returns a smart pointer to the output stream
   */
  Ptr<OutputStreamWrapper> CreateFileStream (std::string filename, 
                                             std::ios::openmode filemode = std::ios::out);

  void HookDefaultReceiveSinkWithContext (Ptr<T> object, 
                                          std::string context, std::string traceName, Ptr<OutputStreamWrapper> stream);

  /**
   * @brief Basic Enqueue default trace sink.
   *
   * When a packet has been sent to a device for transmission, the device is
   * expected to place the packet onto a transmit queue even if it does not
   * have to delay the packet at all, if only to trigger this event.  This
   * event will eventually translate into a '+' operation in the trace file.
   *
   * This is typically implemented by hooking the "TxQueue/Enqueue" trace hook
   * in the device (actually the Queue in the device).
   *
   * @param file the output file
   * @param p the packet
   */
  static void DefaultEnqueueSinkWithoutContext (Ptr<OutputStreamWrapper> file, Ptr<const Packet> p);

  /**
   * @brief Basic Enqueue default trace sink.
   *
   * When a packet has been sent to a device for transmission, the device is
   * expected to place the packet onto a transmit queue even if it does not
   * have to delay the packet at all, if only to trigger this event.  This
   * event will eventually translate into a '+' operation in the trace file.
   *
   * This is typically implemented by hooking the "TxQueue/Enqueue" trace hook
   * in the device (actually the Queue in the device).
   *
   * @param file the output file
   * @param context the context
   * @param p the packet
   */
  static void DefaultEnqueueSinkWithContext (Ptr<OutputStreamWrapper> file, std::string context, Ptr<const Packet> p);

  /**
   * @brief Basic Drop default trace sink.
   *
   * When a packet has been sent to a device for transmission, the device is
   * expected to place the packet onto a transmit queue.  If this queue is
   * full the packet will be dropped.  The device is expected to trigger an
   * event to indicate that an outbound packet is being dropped.  This event
   * will eventually translate into a 'd' operation in the trace file.
   *
   * This is typically implemented by hooking the "TxQueue/Drop" trace hook
   * in the device (actually the Queue in the device).
   *
   * @param file the output file
   * @param p the packet
   */
  static void DefaultDropSinkWithoutContext (Ptr<OutputStreamWrapper> file, Ptr<const Packet> p);

  /**
   * @brief Basic Drop default trace sink.
   *
   * When a packet has been sent to a device for transmission, the device is
   * expected to place the packet onto a transmit queue.  If this queue is
   * full the packet will be dropped.  The device is expected to trigger an
   * event to indicate that an outbound packet is being dropped.  This event
   * will eventually translate into a 'd' operation in the trace file.
   *
   * This is typically implemented by hooking the "TxQueue/Drop" trace hook
   * in the device (actually the Queue in the device).
   *
   * @param file the output file
   * @param context the context
   * @param p the packet
   */
  static void DefaultDropSinkWithContext (Ptr<OutputStreamWrapper> file, std::string context, Ptr<const Packet> p);

  /**
   * @brief Basic Dequeue default trace sink.
   *
   * When a packet has been sent to a device for transmission, the device is
   * expected to place the packet onto a transmit queue even if it does not
   * have to delay the packet at all.  The device removes the packet from the
   * transmit queue when the packet is ready to send, and this dequeue will
   * fire a corresponding event.  This event will eventually translate into a
   * '-' operation in the trace file.
   *
   * This is typically implemented by hooking the "TxQueue/Dequeue" trace hook
   * in the device (actually the Queue in the device).
   *
   * @param file the output file
   * @param p the packet
   */
  static void DefaultDequeueSinkWithoutContext (Ptr<OutputStreamWrapper> file, Ptr<const Packet> p);

  /**
   * @brief Basic Dequeue default trace sink.
   *
   * When a packet has been sent to a device for transmission, the device is
   * expected to place the packet onto a transmit queue even if it does not
   * have to delay the packet at all.  The device removes the packet from the
   * transmit queue when the packet is ready to send, and this dequeue will
   * fire a corresponding event.  This event will eventually translate into a
   * '-' operation in the trace file.
   *
   * This is typically implemented by hooking the "TxQueue/Dequeue" trace hook
   * in the device (actually the Queue in the device).
   *
   * @param file the output file
   * @param context the context
   * @param p the packet
   */
  static void DefaultDequeueSinkWithContext (Ptr<OutputStreamWrapper> file, std::string context, Ptr<const Packet> p);

  /**
   * @brief Basic Receive default trace sink.
   *
   * When a packet is received by a device for transmission, the device is
   * expected to trigger this event to indicate the reception has occurred.
   * This event will eventually translate into an 'r' operation in the trace
   * file.
   *
   * This is typically implemented by hooking the "MacRx" trace hook in the
   * device.
   *
   * @param file the output file
   * @param p the packet
   */
  static void DefaultReceiveSinkWithoutContext (Ptr<OutputStreamWrapper> file, Ptr<const Packet> p);

  /**
   * @brief Basic Receive default trace sink.
   *
   * When a packet is received by a device for transmission, the device is
   * expected to trigger this event to indicate the reception has occurred.
   * This event will eventually translate into an 'r' operation in the trace
   * file.
   *
   * This is typically implemented by hooking the "MacRx" trace hook in the
   * device.
   *
   * @param file the output file
   * @param context the context
   * @param p the packet
   */
  static void DefaultReceiveSinkWithContext (Ptr<OutputStreamWrapper> file, std::string context, Ptr<const Packet> p);
};


   * of the appropriate type.
   *
   * @param prefix Filename prefix to use for ascii files.
   * @param d container of devices
   */
  void EnableAscii (std::string prefix, NetDeviceContainer d);


   *
   * @param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * @param d container of devices
   */
  void EnableAscii (Ptr<OutputStreamWrapper> stream, NetDeviceContainer d);



private:
  /**
   * @brief Enable ascii trace output on the device specified by a global
   * node-id (of a previously created node) and associated device-id (implementation)
   *
   * @param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * @param prefix Filename prefix to use for ascii trace files.
   * @param nodeid The node identifier/number of the node on which to enable
   *               ascii tracing
   * @param deviceid The device identifier/index of the device on which to enable
   *               ascii tracing
   * @param explicitFilename Treat the prefix as an explicit filename if true
   */
  /**
   * @internal Avoid code duplication.
   */
  void EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, 

                        bool explicitFilename);

  /**
   * @brief Enable ascii trace output on each device (which is of the
   * appropriate type) in the nodes provided in the container (implementation).
   *
   * @param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * @param prefix Filename prefix to use for ascii files.
   * @param n container of nodes.
   */
  void EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, NodeContainer n);

  /**
   * @brief Enable ascii trace output on each device in the container which is
   * of the appropriate type (implementation).
   *
   * @param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * @param prefix Filename prefix to use for ascii files.
   * @param d container of devices
   */
  void EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, NetDeviceContainer d);

  /**
   * @brief Enable ascii trace output the indicated net device using a device
   * previously named using the ns-3 object name service (implementation).
   *
   * @param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * @param prefix filename prefix to use for ascii files.
   * @param ndName The name of the net device in which you want to enable tracing.
   * @param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, std::string ndName, bool explicitFilename);

  /**
   * @brief Enable ascii trace output the indicated net device (implementation).
   *
   * @param stream An OutputStreamWrapper representing an existing file to use
   *               when writing trace data.
   * @param prefix filename prefix to use for ascii files.
   * @param nd Net device for which you want to enable tracing
   * @param explicitFilename Treat the prefix as an explicit filename if true
   */
  void EnableAsciiImpl (Ptr<OutputStreamWrapper> stream, std::string prefix, Ptr<NetDevice> nd, bool explicitFilename);
};




  buffer.Read (m_data, m_len);
}

ATTRIBUTE_HELPER_CPP (Address);   //!< Macro to make help make class an ns-3 attribute


bool operator == (const Address &a, const Address &b)

  return os;
}

/**
 * \brief Converts a string representing an hex number [0x0, 0xFF] into its value.
 *
 * \param v a string
 * \returns the value
 */
static uint8_t
AsInt (std::string v)
{
  NS_LOG_FUNCTION_NOARGS ();
  uint8_t retval = strtoul (v.c_str(), 0, 16);
  iss.str (v);
  uint8_t retval;
  iss >> std::hex >> retval >> std::dec;
  return retval;
}


(-)a/src/network/model/address.h (-9 / +61 lines)

Lines 99-117	Link Here

*/

*/

100

  Address ();

100

  Address ();

101

/**

101

/**

102

   * \brief Create an address from a type and a buffer.

103

104

   * This constructor is typically invoked from the conversion

105

   * functions of various address types when they have to

106

   * convert themselves to an Address instance.

107

102

   * \param type the type of the Address to create

108

   * \param type the type of the Address to create

103

   * \param buffer a pointer to a buffer of bytes which hold

109

   * \param buffer a pointer to a buffer of bytes which hold

104

   *        a serialized representation of the address in network

110

   *        a serialized representation of the address in network

105

   *        byte order.

111

   *        byte order.

106

   * \param len the length of the buffer.

112

   * \param len the length of the buffer.

107

108

   * Create an address from a type and a buffer. This constructor

109

   * is typically invoked from the conversion functions of various

110

   * address types when they have to convert themselves to an

111

   * Address instance.

112

*/

113

*/

113

  Address (uint8_t type, const uint8_t *buffer, uint8_t len);

114

  Address (uint8_t type, const uint8_t *buffer, uint8_t len);

115

/**

116

   * \brief Create an address from another address.

117

   * \param address the address to copy

118

*/

114

  Address (const Address & address);

119

  Address (const Address & address);

120

/**

121

   * \brief Basic assignment operator.

122

   * \param address the address to copy

123

   * \returns the address

124

*/

115

  Address &operator = (const Address &address);

125

  Address &operator = (const Address &address);

116

126

117

/**

127

/**

Lines 123-132	Link Here

123

*/

133

*/

124

  bool IsInvalid (void) const;

134

  bool IsInvalid (void) const;

125

/**

135

/**

136

   * \brief Get the length of the underlying address.

126

   * \returns the length of the underlying address.

137

   * \returns the length of the underlying address.

127

*/

138

*/

128

  uint8_t GetLength (void) const;

139

  uint8_t GetLength (void) const;

129

/**

140

/**

141

   * \brief Copy the address bytes into a buffer.

130

   * \param buffer buffer to copy the address bytes to.

142

   * \param buffer buffer to copy the address bytes to.

131

   * \returns the number of bytes copied.

143

   * \returns the number of bytes copied.

132

*/

144

*/

Lines 209-222	Link Here

209

  void Deserialize (TagBuffer buffer);

221

  void Deserialize (TagBuffer buffer);

210

222

211

private:

223

private:

224

/**

225

   * \brief Equal to operator.

226

227

   * \param a the first operand

228

   * \param b the first operand

229

   * \returns true if the operands are equal

230

*/

212

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

231

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

232

233

/**

234

   * \brief Not equal to operator.

235

236

   * \param a the first operand

237

   * \param b the first operand

238

   * \returns true if the operands are not equal

239

*/

240

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

241

242

/**

243

   * \brief Less than operator.

244

245

   * \param a the first operand

246

   * \param b the first operand

247

   * \returns true if the operand a is less than operand b

248

*/

213

  friend bool operator < (const Address &a, const Address &b);

249

  friend bool operator < (const Address &a, const Address &b);

250

251

/**

252

   * \brief Stream insertion operator.

253

254

   * \param os the stream

255

   * \param address the address

256

   * \returns a reference to the stream

257

*/

214

  friend std::ostream& operator<< (std::ostream& os, const Address & address);

258

  friend std::ostream& operator<< (std::ostream& os, const Address & address);

259

260

/**

261

   * \brief Stream extraction operator.

262

263

   * \param is the stream

264

   * \param address the address

265

   * \returns a reference to the stream

266

*/

215

  friend std::istream& operator>> (std::istream& is, Address & address);

267

  friend std::istream& operator>> (std::istream& is, Address & address);

216

268

217

  uint8_t m_type;

269

  uint8_t m_type; //!< Type of the address

218

  uint8_t m_len;

270

  uint8_t m_len;  //!< Length of the address

219

  uint8_t m_data[MAX_SIZE];

271

  uint8_t m_data[MAX_SIZE]; //!< The address value

220

};

272

};

221

273

222

/**

274

/**

Lines 224-230	Link Here

224

 * \brief hold objects of type ns3::Address

276

 * \brief hold objects of type ns3::Address

225

*/

277

*/

226

278

227

ATTRIBUTE_HELPER_HEADER (Address);  /// Macro to make help make class an ns-3 attribute

279

ATTRIBUTE_HELPER_HEADER (Address);  //!< Macro to make help make class an ns-3 attribute

228

280

229

bool operator == (const Address &a, const Address &b);

281

bool operator == (const Address &a, const Address &b);

230

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

282

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




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

  virtual void DoDispose (void);
  virtual void DoInitialize (void);

  Ptr<Node>       m_node;   //!< The node that this application is installed on
  Time m_startTime;         //!< The simulation time that the application will start
  Time m_stopTime;          //!< The simulation time that the application will end
  EventId m_startEvent;     //!< The event that will fire at m_startTime to start the application
  EventId m_stopEvent;      //!< The event that will fire at m_stopTime to end the application
};

} // namespace ns3

(-)a/src/network/model/buffer.cc (-3 / +7 lines)

Lines 30-35	Link Here

namespace {

namespace {

/**

 * \ingroup packet

 * \brief Zero-filled buffer.

*/

static struct Zeroes

static struct Zeroes

  Zeroes ()

  Zeroes ()

Lines 37-45	Link Here

    memset (buffer, 0, size);

    memset (buffer, 0, size);

  char buffer[1000];

  char buffer[1000];    //!< buffer containing zero values

  const uint32_t size;

  const uint32_t size;  //!< buffer size

} g_zeroes;

} g_zeroes; //!< Zero-filled buffer

(-)a/src/network/model/buffer.h (-25 / +194 lines)

Lines 25-31	Link Here

#include <ostream>

#include <ostream>

#include "ns3/assert.h"

#include "ns3/assert.h"

#define noBUFFER_FREE_LIST 1

#define BUFFER_FREE_LIST 1

namespace ns3 {

namespace ns3 {

Lines 80-86	Link Here

 *                        |--------^ m_start

 *                        |--------^ m_start

 *                        |-------------------^ m_zeroAreaStart

 *                        |-------------------^ m_zeroAreaStart

 *                        |-----------------------------^ m_end - (m_zeroAreaEnd - m_zeroAreaStart)

 *                        |-----------------------------^ m_end - (m_zeroAreaEnd - m_zeroAreaStart)

 * virtual byte buffer:           |xxxxxxxxxxxx0000000000000.........|

 * Virtual byte buffer:           |xxxxxxxxxxxx0000000000000.........|

 *                        |--------^ m_start

 *                        |--------^ m_start

 *                        |--------------------^ m_zeroAreaStart

 *                        |--------------------^ m_zeroAreaStart

 *                        |---------------------------------^ m_zeroAreaEnd

 *                        |---------------------------------^ m_zeroAreaEnd

Lines 378-414	Link Here

378

379

private:

379

private:

380

    friend class Buffer;

380

    friend class Buffer;

381

/**

382

     * Constructor - initializes the iterator to point to the buffer start

383

384

     * \param buffer the buffer this iterator refers to

385

*/

381

    inline Iterator (Buffer const*buffer);

386

    inline Iterator (Buffer const*buffer);

382

    inline Iterator (Buffer const*buffer, bool);

387

/**

388

     * Constructor - initializes the iterator to point to the buffer end

389

390

     * \param buffer the buffer this iterator refers to

391

     * \param dummy not used param

392

*/

393

    inline Iterator (Buffer const*buffer, bool dummy);

394

/**

395

     * Initializes the iterator values

396

397

     * \param buffer the buffer this iterator refers to

398

*/

383

    inline void Construct (const Buffer *buffer);

399

    inline void Construct (const Buffer *buffer);

400

/**

401

     * Checks that the [start, end) is not in the "virtual zero area".

402

403

     * \param start start buffer position

404

     * \param end end buffer position

405

     * \returns true if [start, end) is not in the "virtual zero area".

406

*/

384

    bool CheckNoZero (uint32_t start, uint32_t end) const;

407

    bool CheckNoZero (uint32_t start, uint32_t end) const;

408

/**

409

     * Checks that the buffer position is not in the "virtual zero area".

410

411

     * \param i buffer position

412

     * \returns true if not in the "virtual zero area".

413

*/

385

    bool Check (uint32_t i) const;

414

    bool Check (uint32_t i) const;

415

/**

416

     * \return the two bytes read in the buffer.

417

418

     * Read data and advance the Iterator by the number of bytes

419

     * read.

420

     * The data is read in network format and return in host format.

421

422

     * \warning this is the slow version, please use ReadNtohU16 (void)

423

*/

386

    uint16_t SlowReadNtohU16 (void);

424

    uint16_t SlowReadNtohU16 (void);

425

/**

426

     * \return the four bytes read in the buffer.

427

428

     * Read data and advance the Iterator by the number of bytes

429

     * read.

430

     * The data is read in network format and return in host format.

431

432

     * \warning this is the slow version, please use ReadNtohU32 (void)

433

*/

387

    uint32_t SlowReadNtohU32 (void);

434

    uint32_t SlowReadNtohU32 (void);

435

/**

436

     * \brief Returns an appropriate message indicating a read error

437

     * \returns the error message

438

*/

388

    std::string GetReadErrorMessage (void) const;

439

    std::string GetReadErrorMessage (void) const;

440

/**

441

     * \brief Returns an appropriate message indicating a write error

442

443

     * The message depends on the actual Buffer::Iterator status.

444

445

     * \returns the error message

446

*/

389

    std::string GetWriteErrorMessage (void) const;

447

    std::string GetWriteErrorMessage (void) const;

390

448

391

    /* offset in virtual bytes from the start of the data buffer to the

449

/**

450

     * offset in virtual bytes from the start of the data buffer to the

392

     * start of the "virtual zero area".

451

     * start of the "virtual zero area".

393

*/

452

*/

394

    uint32_t m_zeroStart;

453

    uint32_t m_zeroStart;

395

    /* offset in virtual bytes from the start of the data buffer to the

454

/**

455

     * offset in virtual bytes from the start of the data buffer to the

396

     * end of the "virtual zero area".

456

     * end of the "virtual zero area".

397

*/

457

*/

398

    uint32_t m_zeroEnd;

458

    uint32_t m_zeroEnd;

399

    /* offset in virtual bytes from the start of the data buffer to the

459

/**

460

     * offset in virtual bytes from the start of the data buffer to the

400

     * start of the data which can be read by this iterator

461

     * start of the data which can be read by this iterator

401

*/

462

*/

402

    uint32_t m_dataStart;

463

    uint32_t m_dataStart;

403

    /* offset in virtual bytes from the start of the data buffer to the

464

/**

465

     * offset in virtual bytes from the start of the data buffer to the

404

     * end of the data which can be read by this iterator

466

     * end of the data which can be read by this iterator

405

*/

467

*/

406

    uint32_t m_dataEnd;

468

    uint32_t m_dataEnd;

407

    /* offset in virtual bytes from the start of the data buffer to the

469

/**

470

     * offset in virtual bytes from the start of the data buffer to the

408

     * current position represented by this iterator.

471

     * current position represented by this iterator.

409

*/

472

*/

410

    uint32_t m_current;

473

    uint32_t m_current;

411

    /* a pointer to the underlying byte buffer. All offsets are relative

474

/**

475

     * a pointer to the underlying byte buffer. All offsets are relative

412

     * to this pointer.

476

     * to this pointer.

413

*/

477

*/

414

    uint8_t *m_data;

478

    uint8_t *m_data;

Lines 498-507	Link Here

498

*/

562

*/

499

  inline Buffer::Iterator End (void) const;

563

  inline Buffer::Iterator End (void) const;

500

564

565

/**

566

   * \brief Create a full copy of the buffer, including

567

   * all the internal structures.

568

569

   * \returns a copy of the buffer

570

*/

501

  Buffer CreateFullCopy (void) const;

571

  Buffer CreateFullCopy (void) const;

502

572

503

/**

573

/**

504

   * \return the number of bytes required for serialization

574

   * \brief Return the number of bytes required for serialization.

575

   * \return the number of bytes.

505

*/

576

*/

506

  uint32_t GetSerializedSize (void) const;

577

  uint32_t GetSerializedSize (void) const;

507

578

Lines 527-533	Link Here

527

*/

598

*/

528

  uint32_t Deserialize (const uint8_t* buffer, uint32_t size);

599

  uint32_t Deserialize (const uint8_t* buffer, uint32_t size);

529

600

601

/**

602

   * \brief Returns the current buffer start offset

603

   * \return the offset

604

*/

530

  int32_t GetCurrentStartOffset (void) const;

605

  int32_t GetCurrentStartOffset (void) const;

606

/**

607

   * \brief Returns the current buffer end offset

608

   * \return the offset

609

*/

531

  int32_t GetCurrentEndOffset (void) const;

610

  int32_t GetCurrentEndOffset (void) const;

532

611

533

/**

612

/**

Lines 538-549	Link Here

538

*/

617

*/

539

  void CopyData (std::ostream *os, uint32_t size) const;

618

  void CopyData (std::ostream *os, uint32_t size) const;

540

619

620

/**

621

   * Copy the specified amount of data from the buffer to the given buffer.

622

623

   * @param buffer the output buffer

624

   * @param size the maximum amount of bytes to copy. If zero, nothing is copied.

625

   * @returns the amount of bytes copied

626

*/

541

  uint32_t CopyData (uint8_t *buffer, uint32_t size) const;

627

  uint32_t CopyData (uint8_t *buffer, uint32_t size) const;

542

628

629

/**

630

   * \brief Copy constructor

631

   * \param o the buffer to copy

632

*/

543

  inline Buffer (Buffer const &o);

633

  inline Buffer (Buffer const &o);

634

/**

635

   * \brief Assignment operator

636

   * \param o the buffer to copy

637

   * \return a reference to the buffer

638

*/

544

  Buffer &operator = (Buffer const &o);

639

  Buffer &operator = (Buffer const &o);

545

  Buffer ();

640

  Buffer ();

641

/**

642

   * \brief Constructor

643

644

   * The buffer will be initialized with zeroes up to its size.

645

646

   * \param dataSize the buffer size

647

*/

546

  Buffer (uint32_t dataSize);

648

  Buffer (uint32_t dataSize);

649

/**

650

   * \brief Constructor

651

652

   * If initialize is set to true, the buffer will be initialized

653

   * with zeroes up to its size.

654

655

   * \param dataSize the buffer size.

656

   * \param initialize initialize the buffer with zeroes.

657

*/

547

  Buffer (uint32_t dataSize, bool initialize);

658

  Buffer (uint32_t dataSize, bool initialize);

548

  ~Buffer ();

659

  ~Buffer ();

549

private:

660

private:

Lines 563-602	Link Here

563

*/

674

*/

564

  struct Data

675

  struct Data

565

676

566

    /* The reference count of an instance of this data structure.

677

/**

678

     * The reference count of an instance of this data structure.

567

     * Each buffer which references an instance holds a count.

679

     * Each buffer which references an instance holds a count.

568

*/

680

*/

569

    uint32_t m_count;

681

    uint32_t m_count;

570

    /* the size of the m_data field below.

682

/**

683

     * the size of the m_data field below.

571

*/

684

*/

572

    uint32_t m_size;

685

    uint32_t m_size;

573

    /* offset from the start of the m_data field below to the

686

/**

687

     * offset from the start of the m_data field below to the

574

     * start of the area in which user bytes were written.

688

     * start of the area in which user bytes were written.

575

*/

689

*/

576

    uint32_t m_dirtyStart;

690

    uint32_t m_dirtyStart;

577

    /* offset from the start of the m_data field below to the

691

/**

692

     * offset from the start of the m_data field below to the

578

     * end of the area in which user bytes were written.

693

     * end of the area in which user bytes were written.

579

*/

694

*/

580

    uint32_t m_dirtyEnd;

695

    uint32_t m_dirtyEnd;

581

    /* The real data buffer holds _at least_ one byte.

696

/**

697

     * The real data buffer holds _at least_ one byte.

582

     * Its real size is stored in the m_size field.

698

     * Its real size is stored in the m_size field.

583

*/

699

*/

584

    uint8_t m_data[1];

700

    uint8_t m_data[1];

585

};

701

};

586

702

703

/**

704

   * \brief Transform a "Virtual byte buffer" into a "Real byte buffer"

705

*/

587

  void TransformIntoRealBuffer (void) const;

706

  void TransformIntoRealBuffer (void) const;

707

/**

708

   * \brief Checks the internal buffer structures consistency

709

710

   * Used only for debugging purposes.

711

712

   * \returns true if the buffer status is consistent.

713

*/

588

  bool CheckInternalState (void) const;

714

  bool CheckInternalState (void) const;

715

716

/**

717

   * \brief Initializes the buffer with a number of zeroes.

718

719

   * \param zeroSize the zeroes size

720

*/

589

  void Initialize (uint32_t zeroSize);

721

  void Initialize (uint32_t zeroSize);

722

723

/**

724

   * \brief Get the buffer real size.

725

   * \warning The real size is the actual memory used by the buffer.

726

   * \returns the memory used by the buffer.

727

*/

590

  uint32_t GetInternalSize (void) const;

728

  uint32_t GetInternalSize (void) const;

729

730

/**

731

   * \brief Get the buffer end position.

732

   * \returns the buffer end index.

733

*/

591

  uint32_t GetInternalEnd (void) const;

734

  uint32_t GetInternalEnd (void) const;

735

736

/**

737

   * \brief Recycle the buffer memory

738

   * \param data the buffer data storage

739

*/

592

  static void Recycle (struct Buffer::Data *data);

740

  static void Recycle (struct Buffer::Data *data);

741

/**

742

   * \brief Create a buffer data storage

743

   * \param size the storage size to create

744

   * \returns a pointer to the created buffer storage

745

*/

593

  static struct Buffer::Data *Create (uint32_t size);

746

  static struct Buffer::Data *Create (uint32_t size);

747

/**

748

   * \brief Allocate a buffer data storage

749

   * \param reqSize the storage size to create

750

   * \returns a pointer to the allocated buffer storage

751

*/

594

  static struct Buffer::Data *Allocate (uint32_t reqSize);

752

  static struct Buffer::Data *Allocate (uint32_t reqSize);

753

/**

754

   * \brief Deallocate the buffer memory

755

   * \param data the buffer data storage

756

*/

595

  static void Deallocate (struct Buffer::Data *data);

757

  static void Deallocate (struct Buffer::Data *data);

596

758

597

  struct Data *m_data;

759

  struct Data *m_data; //!< the buffer data storage

598

760

599

  /* keep track of the maximum value of m_zeroAreaStart across

761

/**

762

   * keep track of the maximum value of m_zeroAreaStart across

600

   * the lifetime of a Buffer instance. This variable is used

763

   * the lifetime of a Buffer instance. This variable is used

601

   * purely as a source of information for the heuristics which

764

   * purely as a source of information for the heuristics which

602

   * decide on the position of the zero area in new buffers.

765

   * decide on the position of the zero area in new buffers.

Lines 613-644	Link Here

613

*/

776

*/

614

  static uint32_t g_recommendedStart;

777

  static uint32_t g_recommendedStart;

615

778

616

  /* offset to the start of the virtual zero area from the start

779

/**

780

   * offset to the start of the virtual zero area from the start

617

   * of m_data->m_data

781

   * of m_data->m_data

618

*/

782

*/

619

  uint32_t m_zeroAreaStart;

783

  uint32_t m_zeroAreaStart;

620

  /* offset to the end of the virtual zero area from the start

784

/**

785

   * offset to the end of the virtual zero area from the start

621

   * of m_data->m_data

786

   * of m_data->m_data

622

*/

787

*/

623

  uint32_t m_zeroAreaEnd;

788

  uint32_t m_zeroAreaEnd;

624

  /* offset to the start of the data referenced by this Buffer

789

/**

790

   * offset to the start of the data referenced by this Buffer

625

   * instance from the start of m_data->m_data

791

   * instance from the start of m_data->m_data

626

*/

792

*/

627

  uint32_t m_start;

793

  uint32_t m_start;

628

  /* offset to the end of the data referenced by this Buffer

794

/**

795

   * offset to the end of the data referenced by this Buffer

629

   * instance from the start of m_data->m_data

796

   * instance from the start of m_data->m_data

630

*/

797

*/

631

  uint32_t m_end;

798

  uint32_t m_end;

632

799

633

#ifdef BUFFER_FREE_LIST

800

#ifdef BUFFER_FREE_LIST

801

  /// Container for buffer data

634

  typedef std::vector<struct Buffer::Data*> FreeList;

802

  typedef std::vector<struct Buffer::Data*> FreeList;

803

  /// Local static destructor structure

635

  struct LocalStaticDestructor

804

  struct LocalStaticDestructor

636

805

637

    ~LocalStaticDestructor ();

806

    ~LocalStaticDestructor ();

638

};

807

};

639

  static uint32_t g_maxSize;

808

  static uint32_t g_maxSize; //!< Max observed data size

640

  static FreeList *g_freeList;

809

  static FreeList *g_freeList; //!< Buffer data container

641

  static struct LocalStaticDestructor g_localStaticDestructor;

810

  static struct LocalStaticDestructor g_localStaticDestructor; //!< Local static destructor

642

#endif

811

#endif

643

};

812

};

644

813





namespace ns3 {

/**
 * \ingroup packet
 *
 * \brief Internal representation of the byte tags stored in a packet.
 *
 * This structure is only used by ByteTagList and should not be accessed directly.
 */
struct ByteTagListData {
  uint32_t size;   //!< size of the data
  uint32_t count;  //!< use counter (for smart deallocation)
  uint32_t dirty;  //!< number of bytes actually in use
  uint8_t data[4]; //!< data
};

#ifdef USE_FREE_LIST
/**
 * \ingroup packet
 *
 * \brief Container class for struct ByteTagListData
 *
 * Internal use only.
 */
static class ByteTagListDataFreeList : public std::vector<struct ByteTagListData *>
{
public:
  ~ByteTagListDataFreeList ();
} g_freeList; //!< Container for struct ByteTagListData
static uint32_t g_maxSize = 0; //!< maximum data size (used for allocation)

ByteTagListDataFreeList::~ByteTagListDataFreeList ()
{




class ByteTagList
{
public:
  /**
   * \brief An iterator for iterating through a byte tag list
   *
   * An iterator for iterating through a byte tag list

  class Iterator
  {
public:
    /**
     * \brief An item specifies an individual tag within a byte buffer
     *
     * An item specifies an individual tag within a byte buffer

     */
    struct Item 
    {
      TypeId tid;             //!< type of the tag
      uint32_t size;          //!< size of tag data
      int32_t start;          //!< offset to the start of the tag from the virtual byte buffer
      int32_t end;            //!< offset to the end of the tag from the virtual byte buffer
      TagBuffer buf;          //!< the data for the tag as generated by Tag::Serialize
      Item (TagBuffer buf);   //!< constructs an item with the given TagBuffer
private:
      friend class ByteTagList;
      friend class ByteTagList::Iterator;
    };
    
    /**
     * \brief Used to determine if the iterator is at the end of the byteTagList
     *
     * \returns true if there are more Items in the list
     */
    bool HasNext (void) const;

    /**
     * \brief Returns the next Item from the ByteTagList
     *
     * \returns the next Item in the ByteTagList
     */        
    struct ByteTagList::Iterator::Item Next (void);
    
    /**
     * \brief Returns the offset from the start of the virtual byte buffer to the ByteTagList
     *
     * \returns offset to the start of this ByteTagList

    uint32_t GetOffsetStart (void) const;
private:
    friend class ByteTagList;

    /**
     * \brief Constructor
     * \param start Starting tag
     * \param end End tag
     * \param offsetStart offset to the start of the tag from the virtual byte buffer
     * \param offsetEnd offset to the end of the tag from the virtual byte buffer
     */
    Iterator (uint8_t *start, uint8_t *end, int32_t offsetStart, int32_t offsetEnd);

    /**
     * \brief Prepare the iterator for the next tag
     */
    void PrepareForNext (void);
    uint8_t *m_current;     //!< Current tag
    uint8_t *m_end;         //!< End tag
    int32_t m_offsetStart;  //!< Offset to the start of the tag from the virtual byte buffer
    int32_t m_offsetEnd;    //!< Offset to the end of the tag from the virtual byte buffer
    uint32_t m_nextTid;     //!< TypeId of the next tag
    uint32_t m_nextSize;    //!< Size of the next tag
    int32_t m_nextStart;    //!< Start of the next tag
    int32_t m_nextEnd;      //!< End of the next tag
  };

  ByteTagList ();

  void AddAtStart (int32_t adjustment, int32_t prependOffset);

private:
  /**
   * \brief Check that all offsets are smaller than appendOffset
   * \param appendOffset the append offset to check
   * \returns true if the check is false
   */
  bool IsDirtyAtEnd (int32_t appendOffset);
  /**
   * \brief Check that all offsets are bigger than prependOffset
   * \param prependOffset the prepend offset to check
   * \returns true if the check is false
   */
  bool IsDirtyAtStart (int32_t prependOffset);

  /**
   * Returns an iterator pointing to the very first tag in this list
   *
   * \returns an iterator
   */
  ByteTagList::Iterator BeginAll (void) const;

  /**
   * \brief Allocate the memory for the ByteTagListData
   * \param size the memory to allocate
   * \returns the ByteTagListData structure
   */
  struct ByteTagListData *Allocate (uint32_t size);

  /**
   * \brief Deallocates a ByteTagListData
   * \param data the ByteTagListData to deallocate
   */
  void Deallocate (struct ByteTagListData *data);

  uint16_t m_used; //!< the number of used bytes in the buffer
  struct ByteTagListData *m_data; //!< the ByteTagListData structure
};

} // namespace ns3

(-)a/src/network/model/channel-list.cc (-1 / +47 lines)

Lines 30-59	Link Here

/**

/**

 * \ingroup network

 * \brief private implementation detail of the ChannelList API.

 * \brief private implementation detail of the ChannelList API.

*/

*/

class ChannelListPriv : public Object

class ChannelListPriv : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  ChannelListPriv ();

  ChannelListPriv ();

  ~ChannelListPriv ();

  ~ChannelListPriv ();

/**

   * \param channel channel to add

   * \returns index of channel in list.

   * This method is called automatically from Channel::Channel so

   * the user has little reason to call it himself.

*/

  uint32_t Add (Ptr<Channel> channel);

  uint32_t Add (Ptr<Channel> channel);

/**

   * \returns a C++ iterator located at the beginning of this

   *          list.

*/

  ChannelList::Iterator Begin (void) const;

  ChannelList::Iterator Begin (void) const;

/**

   * \returns a C++ iterator located at the end of this

   *          list.

*/

  ChannelList::Iterator End (void) const;

  ChannelList::Iterator End (void) const;

/**

   * \param n index of requested channel.

   * \returns the Channel associated to index n.

*/

  Ptr<Channel> GetChannel (uint32_t n);

  Ptr<Channel> GetChannel (uint32_t n);

/**

   * \returns the number of channels currently in the list.

*/

  uint32_t GetNChannels (void);

  uint32_t GetNChannels (void);

/**

   * \brief Get the channel list object

   * \returns the channel list

*/

  static Ptr<ChannelListPriv> Get (void);

  static Ptr<ChannelListPriv> Get (void);

private:

private:

/**

   * \brief Get the channel list object

   * \returns the channel list

*/

  static Ptr<ChannelListPriv> *DoGet (void);

  static Ptr<ChannelListPriv> *DoGet (void);

/**

   * \brief Delete the channel list object

*/

  static void Delete (void);

  static void Delete (void);

/**

   * \brief Dispose the channels in the list

*/

  virtual void DoDispose (void);

100

  virtual void DoDispose (void);

  std::vector<Ptr<Channel> > m_channels;

101

102

  std::vector<Ptr<Channel> > m_channels; //!< channel objects container

};

103

};

104

NS_OBJECT_ENSURE_REGISTERED (ChannelListPriv)

105

NS_OBJECT_ENSURE_REGISTERED (ChannelListPriv)

(-)a/src/network/model/channel-list.h (+1 lines)

Lines 38-43	Link Here

class ChannelList

class ChannelList

public:

public:

  /// Channel container iterator

  typedef std::vector< Ptr<Channel> >::const_iterator Iterator;

  typedef std::vector< Ptr<Channel> >::const_iterator Iterator;

/**

/**

(-)a/src/network/model/channel.h (-1 / +5 lines)

Lines 43-48	Link Here

class Channel : public Object

class Channel : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Channel ();

  Channel ();

Lines 71-77	Link Here

  virtual Ptr<NetDevice> GetDevice (uint32_t i) const = 0;

  virtual Ptr<NetDevice> GetDevice (uint32_t i) const = 0;

private:

private:

  uint32_t m_id; // Channel id for this channel

  uint32_t m_id; //!< Channel id for this channel

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/network/model/chunk.h (+14 lines)

Lines 14-22	Link Here

class Chunk : public ObjectBase

class Chunk : public ObjectBase

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

   * \brief Deserialize the object from a buffer iterator

   * \param start the buffer iterator

   * \returns the number of deserialized bytes

*/

  virtual uint32_t Deserialize (Buffer::Iterator start) = 0;

  virtual uint32_t Deserialize (Buffer::Iterator start) = 0;

/**

   * \brief Print the object contents

   * \param os the output stream

*/

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

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

};

};

(-)a/src/network/model/header.h (+12 lines)

class Header : public Chunk

class Header : public Chunk

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual ~Header ();

  virtual ~Header ();

/**

/**

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

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

};

};

/**

100

 * \brief Stream insertion operator.

101

102

 * \param os the stream

103

 * \param header the header

104

 * \returns a reference to the stream

105

*/

std::ostream & operator << (std::ostream &os, const Header &header);

106

std::ostream & operator << (std::ostream &os, const Header &header);

107

} // namespace ns3

108

} // namespace ns3

(-)a/src/network/model/net-device.h (+4 lines)

Lines 75-80	Link Here

class NetDevice : public Object

class NetDevice : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual ~NetDevice();

  virtual ~NetDevice();

(-)a/src/network/model/nix-vector.cc (-1 / +1 lines)

Lines 27-33	Link Here

namespace ns3 {

namespace ns3 {

typedef std::vector<uint32_t> NixBits_t;  ///typedef for the nixVector

typedef std::vector<uint32_t> NixBits_t;  //!< typedef for the nixVector

NixVector::NixVector ()

NixVector::NixVector ()

  : m_nixVector (0),

  : m_nixVector (0),

(-)a/src/network/model/nix-vector.h (-14 / +34 lines)

Lines 152-189	Link Here

152

153

154

private:

154

private:

155

  /// Typedef: the NixVector bits storage.

155

  typedef std::vector<uint32_t> NixBits_t;

156

  typedef std::vector<uint32_t> NixBits_t;

156

157

158

/**

159

   * \brief Print the NixVector.

160

161

   * \param os the output stream

162

*/

157

  /* for printing of nix-vector */

163

  /* for printing of nix-vector */

158

  void DumpNixVector (std::ostream &os) const;

164

  void DumpNixVector (std::ostream &os) const;

159

  /* for printing of nix-vector */

160

  friend std::ostream & operator << ( std::ostream &outs, const NixVector &nix);

161

165

162

  /* the actual nix-vector */

166

/**

163

  NixBits_t m_nixVector;

167

   * \brief Stream insertion operator.

168

169

   * \param os the stream

170

   * \param nix the Nixvector

171

   * \returns a reference to the stream

172

*/

173

  friend std::ostream & operator << ( std::ostream &os, const NixVector &nix);

164

174

165

  /* for tracking where we are

175

  NixBits_t m_nixVector; //!< the actual nix-vector

166

   * in the nix-vector

176

  uint32_t m_used; //!< For tracking where we are in the nix-vector

167

*/

168

  uint32_t m_used;

169

177

170

  /* for tracking how many bits we

178

/**

179

   * For tracking how many bits we

171

   * have used in the current vector

180

   * have used in the current vector

172

   * entry. need this in order to

181

   * entry. need this in order to

173

   * expand the vector passed 32bits

182

   * expand the vector passed 32bits

174

*/

183

*/

175

  uint32_t m_currentVectorBitSize;

184

  uint32_t m_currentVectorBitSize;

176

185

177

  /* a counter of how total bits are in

186

/**

187

   * A counter of how total bits are in

178

   * the nix-vector

188

   * the nix-vector

179

*/

189

*/

180

  uint32_t m_totalBitSize;

190

  uint32_t m_totalBitSize;

181

191

182

  /* internal for pretty printing of nix-vector */

192

/**

183

  void PrintDec2BinNixFill (uint32_t, uint32_t, std::ostream &os) const;

193

   * Internal for pretty printing of nix-vector (fill)

194

   * \param decimalNum decimal divider

195

   * \param bitCount bit counter

196

   * \param os output stream

197

*/

198

  void PrintDec2BinNixFill (uint32_t decimalNum, uint32_t bitCount, std::ostream &os) const;

184

199

185

  /* internal for pretty printing of nix-vector */

200

/**

186

  void PrintDec2BinNix (uint32_t, uint32_t, std::ostream &os) const;

201

   * Internal for pretty printing of nix-vector (no fill)

202

   * \param decimalNum decimal divider

203

   * \param bitCount bit counter

204

   * \param os output stream

205

*/

206

  void PrintDec2BinNix (uint32_t decimalNum, uint32_t bitCount, std::ostream &os) const;

187

};

207

};

188

} // namespace ns3

208

} // namespace ns3

189

209

(-)a/src/network/model/node-list.cc (-3 / +51 lines)

Lines 33-60	Link Here

/**

/**

 * \ingroup network

 * \brief private implementation detail of the NodeList API.

 * \brief private implementation detail of the NodeList API.

*/

*/

class NodeListPriv : public Object

class NodeListPriv : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  NodeListPriv ();

  NodeListPriv ();

  ~NodeListPriv ();

  ~NodeListPriv ();

/**

   * \param node node to add

   * \returns index of node in list.

   * This method is called automatically from Node::Node so

   * the user has little reason to call it himself.

*/

  uint32_t Add (Ptr<Node> node);

  uint32_t Add (Ptr<Node> node);

/**

   * \returns a C++ iterator located at the beginning of this

   *          list.

*/

  NodeList::Iterator Begin (void) const;

  NodeList::Iterator Begin (void) const;

/**

   * \returns a C++ iterator located at the end of this

   *          list.

*/

  NodeList::Iterator End (void) const;

  NodeList::Iterator End (void) const;

/**

   * \param n index of requested node.

   * \returns the Node associated to index n.

*/

  Ptr<Node> GetNode (uint32_t n);

  Ptr<Node> GetNode (uint32_t n);

/**

   * \returns the number of nodes currently in the list.

*/

  uint32_t GetNNodes (void);

  uint32_t GetNNodes (void);

/**

   * \brief Get the node list object

   * \returns the node list

*/

  static Ptr<NodeListPriv> Get (void);

  static Ptr<NodeListPriv> Get (void);

private:

private:

/**

   * \brief Get the node list object

   * \returns the node list

*/

  static Ptr<NodeListPriv> *DoGet (void);

/**

   * \brief Delete the nodes list object

*/

  static void Delete (void);

100

/**

101

   * \brief Dispose the nodes in the list

102

*/

  virtual void DoDispose (void);

103

  virtual void DoDispose (void);

  static Ptr<NodeListPriv> *DoGet (void);

104

  static void Delete (void);

105

  std::vector<Ptr<Node> > m_nodes; //!< node objects container

  std::vector<Ptr<Node> > m_nodes;

};

106

};

107

NS_OBJECT_ENSURE_REGISTERED (NodeListPriv)

108

NS_OBJECT_ENSURE_REGISTERED (NodeListPriv)

(-)a/src/network/model/node-list.h (+1 lines)

Lines 40-45	Link Here

class NodeList

class NodeList

public:

public:

  /// Node container iterator

  typedef std::vector< Ptr<Node> >::const_iterator Iterator;

  typedef std::vector< Ptr<Node> >::const_iterator Iterator;

/**

/**

(-)a/src/network/model/node.cc (+3 lines)

Lines 39-44	Link Here

NS_OBJECT_ENSURE_REGISTERED (Node)

NS_OBJECT_ENSURE_REGISTERED (Node)

/**

 * \brief A global switch to enable all checksums for all protocols.

*/

GlobalValue g_checksumEnabled  = GlobalValue ("ChecksumEnabled",

GlobalValue g_checksumEnabled  = GlobalValue ("ChecksumEnabled",

                                              "A global switch to enable all checksums for all protocols",

                                              "A global switch to enable all checksums for all protocols",

                                              BooleanValue (false),

                                              BooleanValue (false),

(-)a/src/network/model/node.h (-13 / +62 lines)

Lines 55-60	Link Here

class Node : public Object

class Node : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Node();

  Node();

Lines 175-181	Link Here

175

   * \param listener the listener to add

179

   * \param listener the listener to add

176

180

177

   * Add a new listener to the list of listeners for the device-added

181

   * Add a new listener to the list of listeners for the device-added

178

   * event. When a new listener is added, it is notified of the existance

182

   * event. When a new listener is added, it is notified of the existence

179

   * of all already-added devices to make discovery of devices easier.

183

   * of all already-added devices to make discovery of devices easier.

180

*/

184

*/

181

  void RegisterDeviceAdditionListener (DeviceAdditionListener listener);

185

  void RegisterDeviceAdditionListener (DeviceAdditionListener listener);

Lines 204-233	Link Here

204

  virtual void DoDispose (void);

208

  virtual void DoDispose (void);

205

  virtual void DoInitialize (void);

209

  virtual void DoInitialize (void);

206

private:

210

private:

211

212

/**

213

   * \brief Notifies all the DeviceAdditionListener about the new device added.

214

   * \param device the added device to notify.

215

*/

207

  void NotifyDeviceAdded (Ptr<NetDevice> device);

216

  void NotifyDeviceAdded (Ptr<NetDevice> device);

208

  bool NonPromiscReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet>, uint16_t protocol, const Address &from);

217

209

  bool PromiscReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet>, uint16_t protocol,

218

/**

219

   * \brief Receive a packet from a device in non-promiscuous mode.

220

   * \param device the device

221

   * \param packet the packet

222

   * \param protocol the protocol

223

   * \param from the sender

224

   * \returns true if the packet has been delivered to a protocol handler.

225

*/

226

  bool NonPromiscReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol, const Address &from);

227

/**

228

   * \brief Receive a packet from a device in promiscuous mode.

229

   * \param device the device

230

   * \param packet the packet

231

   * \param protocol the protocol

232

   * \param from the sender

233

   * \param to the destination

234

   * \param packetType the packet type

235

   * \returns true if the packet has been delivered to a protocol handler.

236

*/

237

  bool PromiscReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol,

210

                                 const Address &from, const Address &to, NetDevice::PacketType packetType);

238

                                 const Address &from, const Address &to, NetDevice::PacketType packetType);

239

/**

240

   * \brief Receive a packet from a device.

241

   * \param device the device

242

   * \param packet the packet

243

   * \param protocol the protocol

244

   * \param from the sender

245

   * \param to the destination

246

   * \param packetType the packet type

247

   * \param promisc true if received in promiscuous mode

248

   * \returns true if the packet has been delivered to a protocol handler.

249

*/

211

  bool ReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet>, uint16_t protocol,

250

  bool ReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet>, uint16_t protocol,

212

                          const Address &from, const Address &to, NetDevice::PacketType packetType, bool promisc);

251

                          const Address &from, const Address &to, NetDevice::PacketType packetType, bool promisc);

213

252

253

/**

254

   * \brief Finish node's construction by setting the correct node ID.

255

*/

214

  void Construct (void);

256

  void Construct (void);

215

257

258

/**

259

   * \brief Protocol handler entry.

260

   * This structure is used to demultiplex all the protocols.

261

*/

216

  struct ProtocolHandlerEntry {

262

  struct ProtocolHandlerEntry {

217

    ProtocolHandler handler;

263

    ProtocolHandler handler; //!< the protocol handler

218

    Ptr<NetDevice> device;

264

    Ptr<NetDevice> device;   //!< the NetDevice

219

    uint16_t protocol;

265

    uint16_t protocol;       //!< the protocol number

220

    bool promiscuous;

266

    bool promiscuous;        //!< true if it is a promiscuous handler

221

};

267

};

268

269

  /// Typedef for protocol handlers container

222

  typedef std::vector<struct Node::ProtocolHandlerEntry> ProtocolHandlerList;

270

  typedef std::vector<struct Node::ProtocolHandlerEntry> ProtocolHandlerList;

271

  /// Typedef for NetDevice addition listeners container

223

  typedef std::vector<DeviceAdditionListener> DeviceAdditionListenerList;

272

  typedef std::vector<DeviceAdditionListener> DeviceAdditionListenerList;

224

273

225

  uint32_t    m_id;         // Node id for this node

274

  uint32_t    m_id;         //!< Node id for this node

226

  uint32_t    m_sid;        // System id for this node

275

  uint32_t    m_sid;        //!< System id for this node

227

  std::vector<Ptr<NetDevice> > m_devices;

276

  std::vector<Ptr<NetDevice> > m_devices; //!< Devices associated to this node

228

  std::vector<Ptr<Application> > m_applications;

277

  std::vector<Ptr<Application> > m_applications; //!< Applications associated to this node

229

  ProtocolHandlerList m_handlers;

278

  ProtocolHandlerList m_handlers; //!< Protocol handlers in the node

230

  DeviceAdditionListenerList m_deviceAdditionListeners;

279

  DeviceAdditionListenerList m_deviceAdditionListeners; //!< Device addition listeners in the node

231

};

280

};

232

281

233

} // namespace ns3

282

} // namespace ns3




  return n;
}

/**
 * \param item the item data to write
 * \param extraItem the extra item data to write
 * \param available the number of bytes which can 
 *        be written without having to rewrite the buffer entirely.
 */
void
PacketMetadata::ReplaceTail (PacketMetadata::SmallItem *item, 
                             PacketMetadata::ExtraItem *extraItem,

  *this = h;
}


 * \param current the offset we should start reading the data from
 * \param item pointer to where we should store the data to return to the caller
 * \param extraItem pointer to where we should store the data to return to the caller
 * \returns the number of bytes read.
 */
uint32_t
PacketMetadata::ReadItems (uint16_t current, 
                           struct PacketMetadata::SmallItem *item,




class PacketMetadata 
{
public:

  /**
   * \brief structure describing a packet metadata item
   */
  struct Item 
  {
    enum {
      PAYLOAD,
      HEADER,
      TRAILER
    } type; //!< metadata type
    /**
     * true: this is a fragmented header, trailer, or, payload.
     * false: this is a whole header, trailer, or, payload.
     */
    bool isFragment;
    /**
     * TypeId of Header or Trailer. Valid only if type is
     * header or trailer.
     */
    TypeId tid;
    /**
     * size of item. If fragment, size of fragment. Otherwise,
     * size of original item. 
     */
    uint32_t currentSize;
    /**
     * how many bytes were trimed from the start of a fragment.
     * if isFragment is true, this field is zero.
     */
    uint32_t currentTrimedFromStart;
    /**
     * how many bytes were trimed from the end of a fragment.
     * if isFragment is true, this field is zero.
     */
    uint32_t currentTrimedFromEnd;
    /**
     * an iterator which can be fed to Deserialize. Valid only
     * if isFragment and isPayload are false.
     */
    Buffer::Iterator current;
  };

  /**
   * \brief Iterator class for metadata items.
   */
  class ItemIterator 
  {
public:
    /**
     * Constructor
     * \param metadata a pointer to the metadata
     * \param buffer the buffer the metadata refers to
     */
    ItemIterator (const PacketMetadata *metadata, Buffer buffer);
    /**
     * \brief Checks if there is another metadata item
     * \returns true if there is another item
     */
    bool HasNext (void) const;
    /**
     * \brief Retrieve the next metadata item
     * \returns the next metadata item
     */
    Item Next (void);
private:
    const PacketMetadata *m_metadata; //!< pointer to the metadata
    Buffer m_buffer; //!< buffer the metadata refers to
    uint16_t m_current; //!< current position
    uint32_t m_offset; //!< offset
    bool m_hasReadTail; //!< true if the metadata tail has been read
  };

  /**
   * \brief Enable the packet metadata
   */
  static void Enable (void);
  /**
   * \brief Enable the packet metadata checking
   */
  static void EnableChecking (void);

  /**
   * Constructor
   * \param uid packet uid
   * \param size size of the header
   */
  inline PacketMetadata (uint64_t uid, uint32_t size);
  /**
   * Copy constructor
   * \param o the object to copy
   */
  inline PacketMetadata (PacketMetadata const &o);
  /**
   * Basic assignment
   * \param o the object to copy
   * \return a copied object
   */
  inline PacketMetadata &operator = (PacketMetadata const& o);
  inline ~PacketMetadata ();

  /**
   * Add an header
   * \param header header to add
   * \param size header serialized size
   */
  void AddHeader (Header const &header, uint32_t size);
  /**
   * Remove an header
   * \param header header to remove
   * \param size header serialized size
   */
  void RemoveHeader (Header const &header, uint32_t size);

  /**
   * Add a trailer
   * \param trailer trailer to add
   * \param size trailer serialized size
   */
  void AddTrailer (Trailer const &trailer, uint32_t size);
  /**
   * Remove a trailer
   * \param trailer trailer to remove
   * \param size trailer serialized size
   */
  void RemoveTrailer (Trailer const &trailer, uint32_t size);

  /**
   * \param start the amount of stuff to remove from the start
   * \param end the amount of stuff to remove from the end
   * \return the fragment's metadata
   *
   * Calling this method is equivalent to calling RemoveAtStart (start)
   * and then, RemoveAtEnd (end).
   */
  PacketMetadata CreateFragment (uint32_t start, uint32_t end) const;

  /**
   * Add a metadata at the metadata start
   * \param o the metadata to add
   */
  void AddAtEnd (PacketMetadata const&o);
  /**
   * Add some padding at the end
   * \param end size of padding
   */
  void AddPaddingAtEnd (uint32_t end);
  /**
   * Remove a chunk of metadata at the metadata start
   * \param start the size of metadata to remove
   */
  void RemoveAtStart (uint32_t start);
  /**
   * Remove a chunk of metadata at the metadata end
   * \param end the size of metadata to remove
   */
  void RemoveAtEnd (uint32_t end);

  /**
   * Get the packet Uid
   * \return the packet Uid
   */
  uint64_t GetUid (void) const;

  /**
   * Get the metadata serialized size
   * \return the seralized size
   */
  uint32_t GetSerializedSize (void) const;

  /**
   * Initialize the item iterator to the buffer begin
   */
  ItemIterator BeginItem (Buffer buffer) const;

  /**
   *  Serialization to raw uint8_t*
   *  \param buffer the buffer to serialize to
   *  \param maxSize the maximum serialization size
   *  \return 1 on success, 0 on failure
   */
  uint32_t Serialize   (uint8_t* buffer, uint32_t maxSize) const;
  /**
   *  Deserialization from raw uint8_t*
   *  \param buffer the buffer to deserialize from
   *  \param size the size
   *  \return 1 on success, 0 on failure
   */
  uint32_t Deserialize (const uint8_t* buffer, uint32_t size);

private:
  /**
   * Helper for the raw serilization
   * \param data the buffer to write to
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* AddToRawU8 (const uint8_t& data,
                              uint8_t* start,
                              uint8_t* current,
                              uint32_t maxSize);

  /**
   * Helper for the raw serilization
   * \param data the buffer to write to
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* AddToRawU16 (const uint16_t& data,
                               uint8_t* start,
                               uint8_t* current,
                               uint32_t maxSize);

  /**
   * Helper for the raw serilization
   * \param data the buffer to write to
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* AddToRawU32 (const uint32_t& data,
                               uint8_t* start,
                               uint8_t* current,
                               uint32_t maxSize);

  /**
   * Helper for the raw serilization
   * \param data the buffer to write to
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* AddToRawU64 (const uint64_t& data,
                               uint8_t* start,
                               uint8_t* current,
                               uint32_t maxSize);

  /**
   * Helper for the raw serilization
   * \param data the buffer to write to
   * \param dataSize the data size to write to
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* AddToRaw (const uint8_t* data,
                            uint32_t dataSize,
                            uint8_t* start,
                            uint8_t* current,
                            uint32_t maxSize);

  /**
   * Helper for the raw deserilization
   * \param data the buffer to read from
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* ReadFromRawU8 (uint8_t& data,
                                 const uint8_t* start,
                                 const uint8_t* current,
                                 uint32_t maxSize);

  /**
   * Helper for the raw deserilization
   * \param data the buffer to read from
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* ReadFromRawU16 (uint16_t& data,
                                  const uint8_t* start,
                                  const uint8_t* current,
                                  uint32_t maxSize);

  /**
   * Helper for the raw deserilization
   * \param data the buffer to read from
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* ReadFromRawU32 (uint32_t& data,
                                  const uint8_t* start,
                                  const uint8_t* current,
                                  uint32_t maxSize);

  /**
   * Helper for the raw deserilization
   * \param data the buffer to read from
   * \param start start index
   * \param current current index
   * \param maxSize maximum size
   * \return updated current index
   */
  static uint8_t* ReadFromRawU64 (uint64_t& data,
                                  const uint8_t* start,
                                  const uint8_t* current,

   */ 
#define PACKET_METADATA_DATA_M_DATA_SIZE 8
  
  /**
   * Data structure
   */
  struct Data {
    /** number of references to this struct Data instance. */
    uint32_t m_count;
    /** size (in bytes) of m_data buffer below */
    uint16_t m_size;
    /** max of the m_used field over all objects which
     * reference this struct Data instance */
    uint16_t m_dirtyEnd;
    /** variable-sized buffer of bytes */
    uint8_t m_data[PACKET_METADATA_DATA_M_DATA_SIZE]; 
  };
  /* Note that since the next and prev fields are 16 bit integers

     only a limited number of elements can be stored in 
     a m_data byte buffer.
   */
  /**
   * SmallItem structure
   */
  struct SmallItem {
    /** offset (in bytes) from start of m_data buffer
       to next element in linked list. value is 0xffff 
       if next element does not exist.
       stored as a fixed-size 16 bit integer.
    */
    uint16_t next;
    /** offset (in bytes) from start of m_data buffer
       to previous element in linked list. value is 0xffff 
       if previous element does not exist.
       stored as a fixed-size 16 bit integer.
     */
    uint16_t prev;
    /** the high 31 bits of this field identify the
       type of the header or trailer represented by 
       this item: the value zero represents payload.
       If the low bit of this uid is one, an ExtraItem

       stored as a variable-size 32 bit integer.
     */
    uint32_t typeUid;
    /** the size (in bytes) of the header or trailer represented
       by this element.
       stored as a variable-size 32 bit integer.
     */
    uint32_t size;
    /** this field tries to uniquely identify each header or
       trailer _instance_ while the typeUid field uniquely
       identifies each header or trailer _type_. This field
       is used to test whether two items are equal in the sense 

     */
    uint16_t chunkUid;
  };

  /**
   * ExtraItem structure
   */
  struct ExtraItem {
    /** offset (in bytes) from start of original header to
       the start of the fragment still present.
       stored as a variable-size 32 bit integer.
     */
    uint32_t fragmentStart;
    /** offset (in bytes) from start of original header to
       the end of the fragment still present.
       stored as a variable-size 32 bit integer.
     */
    uint32_t fragmentEnd;
    /** the packetUid of the packet in which this header or trailer
       was first added. It could be different from the m_packetUid
       field if the user has aggregated multiple packets into one.
       stored as a fixed-size 64 bit integer.

    uint64_t packetUid;
  };

  /**
   * Class to hold all the metadata
   */
  class DataFreeList : public std::vector<struct Data *>
  {
public:


  PacketMetadata ();

  /**
   * Add a SmallItem
   * \param item the SmallItem to add
   * \return added size
   */
  inline uint16_t AddSmall (const PacketMetadata::SmallItem *item);
  /**
   * Add a "Big" Item (a SmallItem plus an ExtraItem)
   * \param head the head
   * \param tail the tail
   * \param item the SmallItem to add
   * \param extraItem the ExtraItem to add
   * \return added size
   */
  uint16_t AddBig (uint32_t head, uint32_t tail,
                   const PacketMetadata::SmallItem *item, 
                   const PacketMetadata::ExtraItem *extraItem);
  /**
   * Replace the tail
   * \param item the item data to write
   * \param extraItem the extra item data to write
   * \param available the number of bytes which can
   *        be written without having to rewrite the buffer entirely.
   */
  void ReplaceTail (PacketMetadata::SmallItem *item, 
                    PacketMetadata::ExtraItem *extraItem,
                    uint32_t available);
  /**
   * Update the head
   * \param written the used bytes
   */
  inline void UpdateHead (uint16_t written);
  /**
   * Update the tail
   * \param written the used bytes
   */
  inline void UpdateTail (uint16_t written);

  /**
   * Get the ULEB128 (Unsigned Little Endian Base 128) size
   * \param value the value
   * \returns the value's ULEB128 size
   */
  inline uint32_t GetUleb128Size (uint32_t value) const;
  /**
   * Read a ULEB128 (Unsigned Little Endian Base 128) coded number
   * \param pBuffer the buffer to read from
   * \returns the value
   */
  uint32_t ReadUleb128 (const uint8_t **pBuffer) const;
  /**
   * Append a 16-bit value to the buffer
   * \param value the value to add
   * \param buffer the buffer to write to
   */
  inline void Append16 (uint16_t value, uint8_t *buffer);
  /**
   * Append a 32-bit value to the buffer
   * \param value the value to add
   * \param buffer the buffer to write to
   */
  inline void Append32 (uint32_t value, uint8_t *buffer);
  /**
   * Append a value to the buffer
   * \param value the value to add
   * \param buffer the buffer to write to
   */
  inline void AppendValue (uint32_t value, uint8_t *buffer);
  /**
   * \brief Append a value to the buffer - extra
   *
   * This function is called by AppendValue
   *
   * \param value the value to add
   * \param buffer the buffer to write to
   */
  void AppendValueExtra (uint32_t value, uint8_t *buffer);

  /**
   * Reserve space
   * \param n space to reserve
   */
  inline void Reserve (uint32_t n);
  /**
   * Reserve space and make a metadata copy
   * \param n space to reserve
   */
  void ReserveCopy (uint32_t n);

  /**
   * Get the total size used by the metadata
   */
  uint32_t GetTotalSize (void) const;

  /**
   * Read items
   * \param current the offset we should start reading the data from
   * \param item pointer to where we should store the data to return to the caller
   * \param extraItem pointer to where we should store the data to return to the caller
   * \returns the number of bytes read.
   */
  uint32_t ReadItems (uint16_t current, 
                      struct PacketMetadata::SmallItem *item,
                      struct PacketMetadata::ExtraItem *extraItem) const;
  /**
   * Add an header
   * \param uid header's uid to add
   * \param size header serialized size
   */
  void DoAddHeader (uint32_t uid, uint32_t size);
  /**
   * Check if the metadata state is ok
   * \returns true if the internal state is ok
   */
  bool IsStateOk (void) const;
  /**
   * Check if the position is valid
   * \param pointer the position to check
   * \returns true if the position is valid
   */
  bool IsPointerOk (uint16_t pointer) const;
  /**
   * Check if the position is valid
   * \param pointer the position to check
   * \returns true if the position is valid
   */
  bool IsSharedPointerOk (uint16_t pointer) const;

  /**
   * \brief Recycle the buffer memory
   * \param data the buffer data storage
   */
  static void Recycle (struct PacketMetadata::Data *data);
  /**
   * \brief Create a buffer data storage
   * \param size the storage size to create
   * \returns a pointer to the created buffer storage
   */
  static struct PacketMetadata::Data *Create (uint32_t size);
  /**
   * \brief Allocate a buffer data storage
   * \param n the storage size to create
   * \returns a pointer to the allocated buffer storage
   */
  static struct PacketMetadata::Data *Allocate (uint32_t n);
  /**
   * \brief Deallocate the buffer memory
   * \param data the buffer data storage
   */
  static void Deallocate (struct PacketMetadata::Data *data);

  static DataFreeList m_freeList; //!< the metadata data storage
  static bool m_enable; //!< Enable the packet metadata
  static bool m_enableChecking; //!< Enable the packet metadata checking

  /**
   * Set to true when adding metadata to a packet is skipped because
   * m_enable is false; used to detect enabling of metadata in the
   * middle of a simulation, which isn't allowed.
   */
  static bool m_metadataSkipped;

  static uint32_t m_maxSize; //!< maximum metadata size
  static uint16_t m_chunkUid; //!< Chunk Uid

  struct Data *m_data; //!< Metadata storage
  /*
     head -(next)-> tail
       ^             |
        \---(prev)---|
   */
  uint16_t m_head; //!< list head
  uint16_t m_tail; //!< list tail
  uint16_t m_used; //!< used portion
  uint64_t m_packetUid; //!< packet Uid
};

} // namespace ns3

(-)a/src/network/model/packet-tag-list.h (+1 lines)

184

   * Assignment

184

   * Assignment

185

186

   * \param [in] o The PacketTagList to copy.

186

   * \param [in] o The PacketTagList to copy.

187

   * \returns the copied object

187

188

   * This makes a light-weight copy by #RemoveAll, then

189

   * This makes a light-weight copy by #RemoveAll, then

189

   * pointing to the same \ref TagData as \pname{o}.

190

   * pointing to the same \ref TagData as \pname{o}.

(-)a/src/network/model/packet.h (-14 / +61 lines)

Lines 84-94	Link Here

    void GetTag (Tag &tag) const;

    void GetTag (Tag &tag) const;

private:

private:

    friend class ByteTagIterator;

    friend class ByteTagIterator;

/**

     * Constructor

     * \param tid the ns3::TypeId associated to this tag.

     * \param start the index of the first byte tagged by this tag.

     * \param end the index of the last byte tagged by this tag.

     * \param buffer the buffer associated with this tag.

*/

    Item (TypeId tid, uint32_t start, uint32_t end, TagBuffer buffer);

    Item (TypeId tid, uint32_t start, uint32_t end, TagBuffer buffer);

    TypeId m_tid;

    uint32_t m_start;

    TypeId m_tid;       //!< the ns3::TypeId associated to this tag.

    uint32_t m_end;

    uint32_t m_start;   //!< the index of the first byte tagged by this tag.

    TagBuffer m_buffer;

    uint32_t m_end;     //!< the index of the last byte tagged by this tag.

    TagBuffer m_buffer; //!< the buffer associated with this tag.

};

100

};

/**

101

/**

   * \returns true if calling Next is safe, false otherwise.

102

   * \returns true if calling Next is safe, false otherwise.

Lines 100-107	Link Here

100

  Item Next (void);

108

  Item Next (void);

101

private:

109

private:

102

  friend class Packet;

110

  friend class Packet;

111

/**

112

   * Copy Constructor

113

   * \param i object to copy

114

*/

103

  ByteTagIterator (ByteTagList::Iterator i);

115

  ByteTagIterator (ByteTagList::Iterator i);

104

  ByteTagList::Iterator m_current;

116

  ByteTagList::Iterator m_current; //!< actual position over the set of byte tags in a packet

105

};

117

};

106

118

107

/**

119

/**

Lines 134-141	Link Here

134

    void GetTag (Tag &tag) const;

146

    void GetTag (Tag &tag) const;

135

private:

147

private:

136

    friend class PacketTagIterator;

148

    friend class PacketTagIterator;

149

/**

150

     * Constructor

151

     * \param data the data to copy.

152

*/

137

    Item (const struct PacketTagList::TagData *data);

153

    Item (const struct PacketTagList::TagData *data);

138

    const struct PacketTagList::TagData *m_data;

154

    const struct PacketTagList::TagData *m_data; //!< the tag data

139

};

155

};

140

/**

156

/**

141

   * \returns true if calling Next is safe, false otherwise.

157

   * \returns true if calling Next is safe, false otherwise.

Lines 147-154	Link Here

147

  Item Next (void);

163

  Item Next (void);

148

private:

164

private:

149

  friend class Packet;

165

  friend class Packet;

166

/**

167

   * Constructor

168

   * \param head head of the items

169

*/

150

  PacketTagIterator (const struct PacketTagList::TagData *head);

170

  PacketTagIterator (const struct PacketTagList::TagData *head);

151

  const struct PacketTagList::TagData *m_current;

171

  const struct PacketTagList::TagData *m_current;  //!< actual position over the set of tags in a packet

152

};

172

};

153

173

154

/**

174

/**

Lines 209-215	Link Here

209

   * by getUid).

229

   * by getUid).

210

*/

230

*/

211

  Packet ();

231

  Packet ();

232

/**

233

   * Copy constructor

234

   * \param o object to copy

235

*/

212

  Packet (const Packet &o);

236

  Packet (const Packet &o);

237

/**

238

   * Basic assignment

239

   * \param o object to copy

240

   * \return the copied object

241

*/

213

  Packet &operator = (const Packet &o);

242

  Packet &operator = (const Packet &o);

214

/**

243

/**

215

   * Create a packet with a zero-filled payload.

244

   * Create a packet with a zero-filled payload.

Lines 569-600	Link Here

569

   * with a packet.  This design methodology

598

   * with a packet.  This design methodology

570

   * should _not_ be followed, and is only here as an

599

   * should _not_ be followed, and is only here as an

571

   * impetus to fix this general issue.

600

   * impetus to fix this general issue.

601

602

   * \param nixVector the nix vector

572

*/

603

*/

573

  void SetNixVector (Ptr<NixVector>);

604

  void SetNixVector (Ptr<NixVector> nixVector);

574

/**

605

/**

575

   * Get the packet nix-vector.

606

   * Get the packet nix-vector.

576

607

577

   * See the comment on SetNixVector

608

   * See the comment on SetNixVector

609

610

   * \returns the Nix vector

578

*/

611

*/

579

  Ptr<NixVector> GetNixVector (void) const;

612

  Ptr<NixVector> GetNixVector (void) const;

580

613

581

private:

614

private:

615

/**

616

   * Constructor

617

   * \param buffer the packet buffer

618

   * \param byteTagList the ByteTag list

619

   * \param packetTagList the packet's Tag list

620

   * \param metadata the packet's metadata

621

*/

582

  Packet (const Buffer &buffer, const ByteTagList &byteTagList,

622

  Packet (const Buffer &buffer, const ByteTagList &byteTagList,

583

          const PacketTagList &packetTagList, const PacketMetadata &metadata);

623

          const PacketTagList &packetTagList, const PacketMetadata &metadata);

584

624

585

  uint32_t Deserialize (uint8_t const*buffer, uint32_t size);

625

  uint32_t Deserialize (uint8_t const*buffer, uint32_t size);

586

626

587

  Buffer m_buffer;

627

  Buffer m_buffer;                //!< the packet buffer (it's actual contents)

588

  ByteTagList m_byteTagList;

628

  ByteTagList m_byteTagList;      //!< the ByteTag list

589

  PacketTagList m_packetTagList;

629

  PacketTagList m_packetTagList;  //!< the packet's Tag list

590

  PacketMetadata m_metadata;

630

  PacketMetadata m_metadata;      //!< the packet's metadata

591

631

592

  /* Please see comments above about nix-vector */

632

  /* Please see comments above about nix-vector */

593

  Ptr<NixVector> m_nixVector;

633

  Ptr<NixVector> m_nixVector; //!< the packet's Nix vector

594

634

595

  static uint32_t m_globalUid;

635

  static uint32_t m_globalUid; //!< Global counter of packets Uid

596

};

636

};

597

637

638

/**

639

 * \brief Stream insertion operator.

640

641

 * \param os the stream

642

 * \param packet the packet

643

 * \returns a reference to the stream

644

*/

598

std::ostream& operator<< (std::ostream& os, const Packet &packet);

645

std::ostream& operator<< (std::ostream& os, const Packet &packet);

599

646

600

/**

647

/**

(-)a/src/network/model/socket-factory.h (+4 lines)

Lines 48-53	Link Here

class SocketFactory : public Object

class SocketFactory : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  SocketFactory ();

  SocketFactory ();

(-)a/src/network/model/tag-buffer.h (-2 / +18 lines)

Lines 51-58	Link Here

class TagBuffer

class TagBuffer

public:

public:

/**

   * \brief Constructor

   * \param start start position

   * \param end end position

*/

  TagBuffer (uint8_t *start, uint8_t *end);

  TagBuffer (uint8_t *start, uint8_t *end);

/**

   * \brief Trim some space from the end

   * \param trim space to remove

*/

  void TrimAtEnd (uint32_t trim);

  void TrimAtEnd (uint32_t trim);

/**

   * \brief Copy the nternal structure of another TagBuffer

   * \param o the TagBuffer to copy from

*/

  void CopyFrom (TagBuffer o);

  void CopyFrom (TagBuffer o);

/**

/**

Lines 140-147	Link Here

140

  void Read (uint8_t *buffer, uint32_t size);

156

  void Read (uint8_t *buffer, uint32_t size);

141

private:

157

private:

142

158

143

  uint8_t *m_current;

159

  uint8_t *m_current; //!< current TagBuffer position

144

  uint8_t *m_end;

160

  uint8_t *m_end;     //!< end TagBuffer position

145

};

161

};

146

162

147

} // namespace ns3

163

} // namespace ns3

(-)a/src/network/model/tag.h (+4 lines)

Lines 36-41	Link Here

class Tag : public ObjectBase

class Tag : public ObjectBase

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

(-)a/src/network/model/trailer.h (+11 lines)

Lines 40-45	Link Here

class Trailer : public Chunk

class Trailer : public Chunk

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual ~Trailer ();

  virtual ~Trailer ();

/**

/**

Lines 93-98	Link Here

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

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

};

};

100

/**

101

 * \brief Stream insertion operator.

102

103

 * \param os the stream

104

 * \param trailer the trailer

105

 * \returns a reference to the stream

106

*/

std::ostream & operator << (std::ostream &os, const Trailer &trailer);

107

std::ostream & operator << (std::ostream &os, const Trailer &trailer);

108

} // namespace ns3

109

} // namespace ns3

(-)a/src/network/utils/ascii-file.h (-2 / +2 lines)

Lines 85-92	Link Here

                    uint64_t & lineNumber);

                    uint64_t & lineNumber);

private:

private:

  std::string    m_filename;

  std::string    m_filename; //!< output file name

  std::fstream   m_file;

  std::fstream   m_file;     //!< output file

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/network/utils/crc32.cc (+3 lines)

Lines 29-34	Link Here

namespace ns3 {

namespace ns3 {

/**

 * Table of CRC-32 values.

*/

static uint32_t crc32table[256] = {

static uint32_t crc32table[256] = {

0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,0x9E6495A3,

0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,0x9E6495A3,

0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,0xE7B82D07,0x90BF1D91,

0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,0xE7B82D07,0x90BF1D91,

(-)a/src/network/utils/crc32.h (-1 / +3 lines)

Lines 24-32	Link Here

namespace ns3 {

namespace ns3 {

/**

/**

 * Calculates the CRC-32 for a given input

 * \param data buffer to calculate the checksum for

 * \param data buffer to calculate the checksum for

 * \param length the length of the buffer (bytes)

 * \param length the length of the buffer (bytes)

 * \returns the computed crc.

 * \returns the computed crc-32.

*/

*/

uint32_t CRC32Calculate (const uint8_t *data, int length);

uint32_t CRC32Calculate (const uint8_t *data, int length);





namespace ns3 {

ATTRIBUTE_HELPER_CPP (DataRate);  //!< Macro to make help make data-rate an ns-3 attribute

DataRate::DataRate ()
  : m_bps (0)

  return is;
}

/**
  * \brief Multiply datarate by a time value
  *
  * Calculates the number of bits that have been transmitted over a period of time
  * \param lhs rate
  * \param rhs time
  * \return the number of bits over the period of time
  */
double operator* (const DataRate& lhs, const Time& rhs)
{
  return rhs.GetSeconds ()*lhs.GetBitRate ();
}

  * \brief Multiply time value by a data rate
  *
  * Calculates the number of bits that have been transmitted over a period of time
  * \param lhs time
  * \param rhs rate
  * \return the number of bits over the period of time
  */
double operator* (const Time& lhs, const DataRate& rhs)
{
  return lhs.GetSeconds ()*rhs.GetBitRate ();




  uint64_t GetBitRate () const;

private:
  uint64_t m_bps; //!< data rate [bps]
  static uint64_t Parse (const std::string);
};

/**
 * \brief Stream insertion operator.
 *
 * \param os the stream
 * \param rate the data rate
 * \returns a reference to the stream
 */
std::ostream &operator << (std::ostream &os, const DataRate &rate);

/**
 * \brief Stream extraction operator.
 *
 * \param is the stream
 * \param rate the data rate
 * \returns a reference to the stream
 */
std::istream &operator >> (std::istream &is, DataRate &rate);

/**

 */


ATTRIBUTE_HELPER_HEADER (DataRate);   //!< Macro to make help make data-rate an ns-3 attribute


/**
 * \brief Multiply datarate by a time value
 *
 * Calculates the number of bits that have been transmitted over a period of time
 * \param lhs rate
 * \param rhs time
 * \return the number of bits over the period of time
 */
double operator* (const DataRate& lhs, const Time& rhs);
/**
 * \brief Multiply time value by a data rate
 *
 * Calculates the number of bits that have been transmitted over a period of time
 * \param lhs time
 * \param rhs rate
 * \return the number of bits over the period of time
 */
double operator* (const Time& lhs, const DataRate& rhs);


} // namespace ns3

#endif /* DATA_RATE_H */




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

  virtual Ptr<Packet> DoDequeue (void);
  virtual Ptr<const Packet> DoPeek (void) const;

  std::queue<Ptr<Packet> > m_packets; //!< the packets in the queue
  uint32_t m_maxPackets;              //!< max packets in the queue
  uint32_t m_maxBytes;                //!< max bytes in the queue
  uint32_t m_bytesInQueue;            //!< actual bytes in the queue
  QueueMode m_mode;                   //!< queue mode (packets or bytes limited)
};

} // namespace ns3

(-)a/src/network/utils/error-model.h (-19 / +66 lines)

Lines 115-120	Link Here

115

class ErrorModel : public Object

115

class ErrorModel : public Object

116

117

public:

117

public:

118

/**

119

   * \brief Get the type ID.

120

   * \return the object TypeId

121

*/

118

  static TypeId GetTypeId (void);

122

  static TypeId GetTypeId (void);

119

123

120

  ErrorModel ();

124

  ErrorModel ();

Lines 146-158	Link Here

146

  bool IsEnabled (void) const;

150

  bool IsEnabled (void) const;

147

151

148

private:

152

private:

149

/*

153

/**

150

   * These methods must be implemented by subclasses

154

   * Corrupt a packet according to the specified model.

155

   * \param p the packet to corrupt

156

   * \returns true if the packet is corrupted

151

*/

157

*/

152

  virtual bool DoCorrupt (Ptr<Packet>) = 0;

158

  virtual bool DoCorrupt (Ptr<Packet> p) = 0;

159

/**

160

   * Re-initialize any state

161

*/

153

  virtual void DoReset (void) = 0;

162

  virtual void DoReset (void) = 0;

154

163

155

  bool m_enable;

164

  bool m_enable; //!< True if the error model is enabled

156

};

165

};

157

166

158

/**

167

/**

Lines 173-183	Link Here

173

class RateErrorModel : public ErrorModel

182

class RateErrorModel : public ErrorModel

174

183

175

public:

184

public:

185

/**

186

   * \brief Get the type ID.

187

   * \return the object TypeId

188

*/

176

  static TypeId GetTypeId (void);

189

  static TypeId GetTypeId (void);

177

190

178

  RateErrorModel ();

191

  RateErrorModel ();

179

  virtual ~RateErrorModel ();

192

  virtual ~RateErrorModel ();

180

193

194

/**

195

   * Error unit. The error model can be packet, Byte or bit based.

196

*/

181

  enum ErrorUnit

197

  enum ErrorUnit

182

198

183

    ERROR_UNIT_BIT,

199

    ERROR_UNIT_BIT,

Lines 220-234	Link Here

220

236

221

private:

237

private:

222

  virtual bool DoCorrupt (Ptr<Packet> p);

238

  virtual bool DoCorrupt (Ptr<Packet> p);

239

/**

240

   * Corrupt a packet (packet unit).

241

   * \param p the packet to corrupt

242

   * \returns true if the packet is corrupted

243

*/

223

  virtual bool DoCorruptPkt (Ptr<Packet> p);

244

  virtual bool DoCorruptPkt (Ptr<Packet> p);

245

/**

246

   * Corrupt a packet (Byte unit).

247

   * \param p the packet to corrupt

248

   * \returns true if the packet is corrupted

249

*/

224

  virtual bool DoCorruptByte (Ptr<Packet> p);

250

  virtual bool DoCorruptByte (Ptr<Packet> p);

251

/**

252

   * Corrupt a packet (bit unit).

253

   * \param p the packet to corrupt

254

   * \returns true if the packet is corrupted

255

*/

225

  virtual bool DoCorruptBit (Ptr<Packet> p);

256

  virtual bool DoCorruptBit (Ptr<Packet> p);

226

  virtual void DoReset (void);

257

  virtual void DoReset (void);

227

258

228

  enum ErrorUnit m_unit;

259

  enum ErrorUnit m_unit; //!< Error rate unit

229

  double m_rate;

260

  double m_rate; //!< Error rate

230

261

231

  Ptr<RandomVariableStream> m_ranvar;

262

  Ptr<RandomVariableStream> m_ranvar; //!< rng stream

232

};

263

};

233

264

234

265

Lines 267-272	Link Here

267

class BurstErrorModel : public ErrorModel

298

class BurstErrorModel : public ErrorModel

268

299

269

public:

300

public:

301

/**

302

   * \brief Get the type ID.

303

   * \return the object TypeId

304

*/

270

  static TypeId GetTypeId (void);

305

  static TypeId GetTypeId (void);

271

306

272

  BurstErrorModel ();

307

  BurstErrorModel ();

Lines 305-320	Link Here

305

  virtual bool DoCorrupt (Ptr<Packet> p);

340

  virtual bool DoCorrupt (Ptr<Packet> p);

306

  virtual void DoReset (void);

341

  virtual void DoReset (void);

307

342

308

  double m_burstRate;                         //the burst error event

343

  double m_burstRate;                         //!< the burst error event

344

  Ptr<RandomVariableStream> m_burstStart;     //!< the error decision variable

345

  Ptr<RandomVariableStream> m_burstSize;      //!< the number of packets being flagged as errored

309

346

310

  Ptr<RandomVariableStream> m_burstStart;     //the error decision variable

347

/**

311

348

   * keep track of the number of packets being errored

312

  Ptr<RandomVariableStream> m_burstSize;      //the number of packets being flagged as errored

349

   * until it reaches m_burstSize

313

350

*/

314

  uint32_t m_counter;                         //keep track of the number of packets being errored

351

  uint32_t m_counter;

315

                                              //until it reaches m_burstSize

352

  uint32_t m_currentBurstSz;                  //!< the current burst size

316

317

  uint32_t m_currentBurstSz;                  //the current burst size

318

353

319

};

354

};

320

355

Lines 344-349	Link Here

344

class ListErrorModel : public ErrorModel

379

class ListErrorModel : public ErrorModel

345

380

346

public:

381

public:

382

/**

383

   * \brief Get the type ID.

384

   * \return the object TypeId

385

*/

347

  static TypeId GetTypeId (void);

386

  static TypeId GetTypeId (void);

348

  ListErrorModel ();

387

  ListErrorModel ();

349

  virtual ~ListErrorModel ();

388

  virtual ~ListErrorModel ();

Lines 363-372	Link Here

363

  virtual bool DoCorrupt (Ptr<Packet> p);

402

  virtual bool DoCorrupt (Ptr<Packet> p);

364

  virtual void DoReset (void);

403

  virtual void DoReset (void);

365

404

405

  /// Typedef: packet Uid list

366

  typedef std::list<uint32_t> PacketList;

406

  typedef std::list<uint32_t> PacketList;

407

  /// Typedef: packet Uid list const iterator

367

  typedef std::list<uint32_t>::const_iterator PacketListCI;

408

  typedef std::list<uint32_t>::const_iterator PacketListCI;

368

409

369

  PacketList m_packetList;

410

  PacketList m_packetList; //!< container of Uid of packets to corrupt

370

411

371

};

412

};

372

413

Lines 385-390	Link Here

385

class ReceiveListErrorModel : public ErrorModel

426

class ReceiveListErrorModel : public ErrorModel

386

427

387

public:

428

public:

429

/**

430

   * \brief Get the type ID.

431

   * \return the object TypeId

432

*/

388

  static TypeId GetTypeId (void);

433

  static TypeId GetTypeId (void);

389

  ReceiveListErrorModel ();

434

  ReceiveListErrorModel ();

390

  virtual ~ReceiveListErrorModel ();

435

  virtual ~ReceiveListErrorModel ();

Lines 404-414	Link Here

404

  virtual bool DoCorrupt (Ptr<Packet> p);

449

  virtual bool DoCorrupt (Ptr<Packet> p);

405

  virtual void DoReset (void);

450

  virtual void DoReset (void);

406

451

452

  /// Typedef: packet sequence number list

407

  typedef std::list<uint32_t> PacketList;

453

  typedef std::list<uint32_t> PacketList;

454

  /// Typedef: packet sequence number list const iterator

408

  typedef std::list<uint32_t>::const_iterator PacketListCI;

455

  typedef std::list<uint32_t>::const_iterator PacketListCI;

409

456

410

  PacketList m_packetList;

457

  PacketList m_packetList; //!< container of sequence number of packets to corrupt

411

  uint32_t m_timesInvoked;

458

  uint32_t m_timesInvoked; //!< number of times the error model has been invoked

412

459

413

};

460

};

414

461




   */
  uint32_t GetHeaderSize () const;

  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
  virtual void Print (std::ostream &os) const;

  virtual void Serialize (Buffer::Iterator start) const;
  virtual uint32_t Deserialize (Buffer::Iterator start);
private:
  static const int PREAMBLE_SIZE = 8; //!< size of the preamble_sfd header field
  static const int LENGTH_SIZE = 2;   //!< size of the length_type header field
  static const int MAC_ADDR_SIZE = 6; //!< size of src/dest addr header fields

  /**
   * If false, the preamble/sfd are not serialised/deserialised.
   */
  bool m_enPreambleSfd;
  uint64_t m_preambleSfd;     //!< Value of the Preamble/SFD fields
  uint16_t m_lengthType;      //!< Length or type of the packet
  Mac48Address m_source;        //!< Source address
  Mac48Address m_destination;   //!< Destination address
};

} // namespace ns3

(-)a/src/network/utils/ethernet-trailer.h (-1 / +5 lines)

Lines 90-95	Link Here

*/

*/

  uint32_t GetTrailerSize () const;

  uint32_t GetTrailerSize () const;

/**

   * \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;

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

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

Lines 102-108	Link Here

102

   * returns true.

106

   * returns true.

103

*/

107

*/

104

  bool m_calcFcs;

108

  bool m_calcFcs;

105

  uint32_t m_fcs; /// Value of the fcs contained in the trailer

109

  uint32_t m_fcs; //!< Value of the fcs contained in the trailer

106

110

107

};

111

};

108

112

(-)a/src/network/utils/flow-id-tag.h (-1 / +5 lines)

Lines 27-32	Link Here

class FlowIdTag : public Tag

class FlowIdTag : public Tag

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;

  virtual uint32_t GetSerializedSize (void) const;

  virtual uint32_t GetSerializedSize (void) const;

Lines 57-63	Link Here

*/

*/

  static uint32_t AllocateFlowId (void);

  static uint32_t AllocateFlowId (void);

private:

private:

  uint32_t m_flowId;

  uint32_t m_flowId; //!< Flow ID

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/network/utils/inet-socket-address.h (-5 / +14 lines)

Lines 99-116	Link Here

  operator Address () const;

  operator Address () const;

100

101

/**

101

/**

102

   * \brief Returns an InetSocketAddress which corresponds to the input

103

   * Address.

104

102

   * \param address the Address instance to convert from.

105

   * \param address the Address instance to convert from.

103

106

   * \returns an InetSocketAddress

104

   * Returns an InetSocketAddress which corresponds to the input

105

   * Address

106

*/

107

*/

107

  static InetSocketAddress ConvertFrom (const Address &address);

108

  static InetSocketAddress ConvertFrom (const Address &address);

108

private:

109

private:

110

/**

111

   * \brief Convert to an Address type

112

*/

109

  Address ConvertTo (void) const;

113

  Address ConvertTo (void) const;

110

114

115

/**

116

   * \brief Get the underlying address type (automatically assigned).

117

118

   * \returns the address type

119

*/

111

  static uint8_t GetType (void);

120

  static uint8_t GetType (void);

112

  Ipv4Address m_ipv4;

121

  Ipv4Address m_ipv4; //!< the IPv4 address

113

  uint16_t m_port;

122

  uint16_t m_port;    //!< the port

114

};

123

};

115

124

116

} // namespace ns3

125

} // namespace ns3

(-)a/src/network/utils/ipv4-address.cc (-2 / +7 lines)

Lines 31-36	Link Here

#define ASCII_ZERO (0x30)

#define ASCII_ZERO (0x30)

#define ASCII_SLASH (0x2f)

#define ASCII_SLASH (0x2f)

/**

 * \brief Converts a string representing an IP address into the address

 * \param address the address string

 * \returns the address

*/

static uint32_t

static uint32_t

AsciiToIpv4Host (char const *address)

AsciiToIpv4Host (char const *address)

Lines 417-423	Link Here

417

  return !a.IsEqual (b);

422

  return !a.IsEqual (b);

418

423

419

424

420

ATTRIBUTE_HELPER_CPP (Ipv4Address); /// Macro to make help make class an ns-3 attribute

425

ATTRIBUTE_HELPER_CPP (Ipv4Address); //!< Macro to make help make class an ns-3 attribute

421

ATTRIBUTE_HELPER_CPP (Ipv4Mask);    /// Macro to make help make class an ns-3 attribute

426

ATTRIBUTE_HELPER_CPP (Ipv4Mask);    //!< Macro to make help make class an ns-3 attribute

422

427

423

} // namespace ns3

428

} // namespace ns3

(-)a/src/network/utils/ipv4-address.h (-6 / +90 lines)

Lines 123-128	Link Here

123

   * address.

123

   * address.

124

125

   * \param mask a network mask

125

   * \param mask a network mask

126

   * \returns the address combined with the mask

126

*/

127

*/

127

  Ipv4Address CombineMask (Ipv4Mask const &mask) const;

128

  Ipv4Address CombineMask (Ipv4Mask const &mask) const;

128

/**

129

/**

Lines 134-139	Link Here

134

   * there is no subnet associated with a /32 address.

135

   * there is no subnet associated with a /32 address.

135

136

   * \param mask a network mask

137

   * \param mask a network mask

138

   * \returns a broadcast address for the subnet.

137

*/

139

*/

138

  Ipv4Address GetSubnetDirectedBroadcast (Ipv4Mask const &mask) const;

140

  Ipv4Address GetSubnetDirectedBroadcast (Ipv4Mask const &mask) const;

139

/**

141

/**

Lines 189-201	Link Here

189

  static Ipv4Address GetLoopback (void);

191

  static Ipv4Address GetLoopback (void);

190

192

191

private:

193

private:

194

195

/**

196

   * \brief Convert to an Address type

197

*/

192

  Address ConvertTo (void) const;

198

  Address ConvertTo (void) const;

199

200

/**

201

   * \brief Get the underlying address type (automatically assigned).

202

203

   * \returns the address type

204

*/

193

  static uint8_t GetType (void);

205

  static uint8_t GetType (void);

194

  uint32_t m_address;

206

  uint32_t m_address; //!< IPv4 address

195

207

196

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

208

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

197

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

209

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

198

  friend bool operator < (Ipv4Address const &addrA, Ipv4Address const &addrB);

210

  friend bool operator < (Ipv4Address const &a, Ipv4Address const &b);

199

};

211

};

200

212

201

/**

213

/**

Lines 274-280	Link Here

274

  static Ipv4Mask GetOnes (void);

286

  static Ipv4Mask GetOnes (void);

275

287

276

private:

288

private:

277

  uint32_t m_mask;

289

  uint32_t m_mask; //!< IP mask

278

};

290

};

279

291

280

/**

292

/**

Lines 286-319	Link Here

286

 * \brief hold objects of type ns3::Ipv4Mask

298

 * \brief hold objects of type ns3::Ipv4Mask

287

*/

299

*/

288

300

289

ATTRIBUTE_HELPER_HEADER (Ipv4Address);  /// Macro to make help make class an ns-3 attribute

301

ATTRIBUTE_HELPER_HEADER (Ipv4Address);  //!< Macro to make help make class an ns-3 attribute

290

ATTRIBUTE_HELPER_HEADER (Ipv4Mask);     /// Macro to make help make class an ns-3 attribute

302

ATTRIBUTE_HELPER_HEADER (Ipv4Mask);     //!< Macro to make help make class an ns-3 attribute

291

303

304

/**

305

 * \brief Stream insertion operator.

306

307

 * \param os the stream

308

 * \param address the address

309

 * \returns a reference to the stream

310

*/

292

std::ostream& operator<< (std::ostream& os, Ipv4Address const& address);

311

std::ostream& operator<< (std::ostream& os, Ipv4Address const& address);

312

/**

313

 * \brief Stream insertion operator.

314

315

 * \param os the stream

316

 * \param mask the mask

317

 * \returns a reference to the stream

318

*/

293

std::ostream& operator<< (std::ostream& os, Ipv4Mask const& mask);

319

std::ostream& operator<< (std::ostream& os, Ipv4Mask const& mask);

320

/**

321

 * \brief Stream extraction operator.

322

323

 * \param is the stream

324

 * \param address the address

325

 * \returns a reference to the stream

326

*/

294

std::istream & operator >> (std::istream &is, Ipv4Address &address);

327

std::istream & operator >> (std::istream &is, Ipv4Address &address);

328

/**

329

 * \brief Stream extraction operator.

330

331

 * \param is the stream

332

 * \param mask the mask

333

 * \returns a reference to the stream

334

*/

295

std::istream & operator >> (std::istream &is, Ipv4Mask &mask);

335

std::istream & operator >> (std::istream &is, Ipv4Mask &mask);

296

336

337

/**

338

 * \brief Equal to operator.

339

340

 * \param a the first operand

341

 * \param b the first operand

342

 * \returns true if the operands are equal

343

*/

297

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

344

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

298

345

299

  return (a.m_address == b.m_address);

346

  return (a.m_address == b.m_address);

300

347

348

/**

349

 * \brief Not equal to operator.

350

351

 * \param a the first operand

352

 * \param b the first operand

353

 * \returns true if the operands are not equal

354

*/

301

inline bool operator != (const Ipv4Address &a, const Ipv4Address &b)

355

inline bool operator != (const Ipv4Address &a, const Ipv4Address &b)

302

356

303

  return (a.m_address != b.m_address);

357

  return (a.m_address != b.m_address);

304

358

359

/**

360

 * \brief Less than operator.

361

362

 * \param a the first operand

363

 * \param b the first operand

364

 * \returns true if the operand a is less than operand b

365

*/

305

inline bool operator < (const Ipv4Address &a, const Ipv4Address &b)

366

inline bool operator < (const Ipv4Address &a, const Ipv4Address &b)

306

367

307

  return (a.m_address < b.m_address);

368

  return (a.m_address < b.m_address);

308

369

309

370

310

371

/**

372

 * \ingroup address

373

374

 * \brief Class providing an hash for IPv4 addresses

375

*/

311

class Ipv4AddressHash : public std::unary_function<Ipv4Address, size_t> {

376

class Ipv4AddressHash : public std::unary_function<Ipv4Address, size_t> {

312

public:

377

public:

378

/**

379

   * Returns the hash of the address

380

   * \param x the address

381

   * \return the hash

382

*/

313

  size_t operator() (Ipv4Address const &x) const;

383

  size_t operator() (Ipv4Address const &x) const;

314

};

384

};

315

385

386

/**

387

 * \brief Equal to operator.

388

389

 * \param a the first operand

390

 * \param b the first operand

391

 * \returns true if the operands are equal

392

*/

316

bool operator == (Ipv4Mask const &a, Ipv4Mask const &b);

393

bool operator == (Ipv4Mask const &a, Ipv4Mask const &b);

394

/**

395

 * \brief Not equal to operator.

396

397

 * \param a the first operand

398

 * \param b the first operand

399

 * \returns true if the operands are not equal

400

*/

317

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

401

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

318

402

319

} // namespace ns3

403

} // namespace ns3

(-)a/src/network/utils/ipv6-address.cc (-2 / +2 lines)

Lines 1011-1018	Link Here

1011

  return lookuphash (buf, sizeof (buf), 0);

1011

  return lookuphash (buf, sizeof (buf), 0);

1012

1013

1014

ATTRIBUTE_HELPER_CPP (Ipv6Address); /// Macro to make help make class an ns-3 attribute

1014

ATTRIBUTE_HELPER_CPP (Ipv6Address); //!< Macro to make help make class an ns-3 attribute

1015

ATTRIBUTE_HELPER_CPP (Ipv6Prefix);  /// Macro to make help make class an ns-3 attribute

1015

ATTRIBUTE_HELPER_CPP (Ipv6Prefix);  //!< Macro to make help make class an ns-3 attribute

1016

1017

} /* namespace ns3 */

1017

} /* namespace ns3 */

1018




 * \class ns3::Ipv6AddressValue
 * \brief Hold objects of type ns3::Ipv6Address
 */
ATTRIBUTE_HELPER_HEADER (Ipv6Address);  //!< Macro to make help make class an ns-3 attribute

/**
 * \class ns3::Ipv6PrefixValue
 * \brief Hold objects of type ns3::Ipv6Prefix
 */
ATTRIBUTE_HELPER_HEADER (Ipv6Prefix);   //!< Macro to make help make class an ns-3 attribute

/**
 * \brief Stream insertion operator.

(-)a/src/network/utils/llc-snap-header.h (-1 / +15 lines)

Lines 36-50	Link Here

 * \ingroup network

 * \ingroup network

 * \brief Header for the LLC/SNAP encapsulation

 * \brief Header for the LLC/SNAP encapsulation

 * For a list of EtherTypes, see http://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers.xhtml

*/

*/

class LlcSnapHeader : public Header

class LlcSnapHeader : public Header

public:

public:

  LlcSnapHeader ();

  LlcSnapHeader ();

/**

   * \brief Set the Ethertype.

   * \param type the Ethertype

*/

  void SetType (uint16_t type);

  void SetType (uint16_t type);

/**

   * \brief Return the Ethertype.

   * \return Ethertype

*/

  uint16_t GetType (void);

  uint16_t GetType (void);

/**

   * \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;

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

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

Lines 52-58	Link Here

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

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

  virtual uint32_t Deserialize (Buffer::Iterator start);

  virtual uint32_t Deserialize (Buffer::Iterator start);

private:

private:

  uint16_t m_etherType;

  uint16_t m_etherType; //!< the Ethertype

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/network/utils/mac16-address.cc (-1 / +12 lines)

Lines 30-36	Link Here

namespace ns3 {

namespace ns3 {

ATTRIBUTE_HELPER_CPP (Mac16Address);  /// Macro to make help make class an ns-3 attribute

ATTRIBUTE_HELPER_CPP (Mac16Address);  //!< Macro to make help make class an ns-3 attribute

#define ASCII_a (0x41)

#define ASCII_a (0x41)

#define ASCII_z (0x5a)

#define ASCII_z (0x5a)

Lines 39-44	Link Here

#define ASCII_COLON (0x3a)

#define ASCII_COLON (0x3a)

#define ASCII_ZERO (0x30)

#define ASCII_ZERO (0x30)

/**

 * Converts a char to lower case.

 * \param c the char

 * \returns the lower case

*/

static char

static char

AsciiToLowCase (char c)

AsciiToLowCase (char c)

Lines 169-174	Link Here

169

  return os;

174

  return os;

170

175

171

176

177

/**

178

 * \brief Converts a string representing an hex number [0x0, 0xFF] into its value.

179

180

 * \param v a string

181

 * \returns the value

182

*/

172

static uint8_t

183

static uint8_t

173

AsInt (std::string v)

184

AsInt (std::string v)

174

185




   * Convert an instance of this class to a polymorphic Address instance.
   */
  Address ConvertTo (void) const;

  /**
   * \brief Return the Type of address.
   * \return type of address
   */
  static uint8_t GetType (void);

  /**
   * \brief Equal to operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operands are equal
   */
  friend bool operator == (const Mac16Address &a, const Mac16Address &b);

  /**
   * \brief Not equal to operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operands are not equal
   */
  friend bool operator != (const Mac16Address &a, const Mac16Address &b);

  /**
   * \brief Less than operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operand a is less than operand b
   */
  friend bool operator < (const Mac16Address &a, const Mac16Address &b);

  /**
   * \brief Stream insertion operator.
   *
   * \param os the stream
   * \param address the address
   * \returns a reference to the stream
   */
  friend std::ostream& operator<< (std::ostream& os, const Mac16Address & address);

  /**
   * \brief Stream extraction operator.
   *
   * \param is the stream
   * \param address the address
   * \returns a reference to the stream
   */
  friend std::istream& operator>> (std::istream& is, Mac16Address & address);

  uint8_t m_address[2]; //!< address value
};

/**

 * \brief hold objects of type ns3::Mac16Address
 */

ATTRIBUTE_HELPER_HEADER (Mac16Address); //!< Macro to make help make class an ns-3 attribute

inline bool operator == (const Mac16Address &a, const Mac16Address &b)
{

(-)a/src/network/utils/mac48-address.cc (-1 / +12 lines)

Lines 29-35	Link Here

namespace ns3 {

namespace ns3 {

ATTRIBUTE_HELPER_CPP (Mac48Address);  /// Macro to make help make class an ns-3 attribute

ATTRIBUTE_HELPER_CPP (Mac48Address);  //!< Macro to make help make class an ns-3 attribute

#define ASCII_a (0x41)

#define ASCII_a (0x41)

#define ASCII_z (0x5a)

#define ASCII_z (0x5a)

Lines 38-43	Link Here

#define ASCII_COLON (0x3a)

#define ASCII_COLON (0x3a)

#define ASCII_ZERO (0x30)

#define ASCII_ZERO (0x30)

/**

 * Converts a char to lower case.

 * \param c the char

 * \returns the lower case

*/

static char

static char

AsciiToLowCase (char c)

AsciiToLowCase (char c)

Lines 259-264	Link Here

259

  return os;

264

  return os;

260

265

261

266

267

/**

268

 * \brief Converts a string representing an hex number [0x0, 0xFF] into its value.

269

270

 * \param v a string

271

 * \returns the value

272

*/

262

static uint8_t

273

static uint8_t

263

AsInt (std::string v)

274

AsInt (std::string v)

264

275




   * Convert an instance of this class to a polymorphic Address instance.
   */
  Address ConvertTo (void) const;

  /**
   * \brief Return the Type of address.
   * \return type of address
   */
  static uint8_t GetType (void);

  /**
   * \brief Equal to operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operands are equal
   */
  friend bool operator == (const Mac48Address &a, const Mac48Address &b);

  /**
   * \brief Not equal to operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operands are not equal
   */
  friend bool operator != (const Mac48Address &a, const Mac48Address &b);

  /**
   * \brief Less than operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operand a is less than operand b
   */
  friend bool operator < (const Mac48Address &a, const Mac48Address &b);

  /**
   * \brief Stream insertion operator.
   *
   * \param os the stream
   * \param address the address
   * \returns a reference to the stream
   */
  friend std::ostream& operator<< (std::ostream& os, const Mac48Address & address);

  /**
   * \brief Stream extraction operator.
   *
   * \param is the stream
   * \param address the address
   * \returns a reference to the stream
   */
  friend std::istream& operator>> (std::istream& is, Mac48Address & address);

  uint8_t m_address[6]; //!< address value
};

/**

 * \brief hold objects of type ns3::Mac48Address
 */

ATTRIBUTE_HELPER_HEADER (Mac48Address); //!< Macro to make help make class an ns-3 attribute

inline bool operator == (const Mac48Address &a, const Mac48Address &b)
{

(-)a/src/network/utils/mac64-address.cc (-1 / +12 lines)

Lines 29-35	Link Here

namespace ns3 {

namespace ns3 {

ATTRIBUTE_HELPER_CPP (Mac64Address);  /// Macro to make help make class an ns-3 attribute

ATTRIBUTE_HELPER_CPP (Mac64Address);  //!< Macro to make help make class an ns-3 attribute

#define ASCII_a (0x41)

#define ASCII_a (0x41)

#define ASCII_z (0x5a)

#define ASCII_z (0x5a)

Lines 38-43	Link Here

#define ASCII_COLON (0x3a)

#define ASCII_COLON (0x3a)

#define ASCII_ZERO (0x30)

#define ASCII_ZERO (0x30)

/**

 * Converts a char to lower case.

 * \param c the char

 * \returns the lower case

*/

static char

static char

AsciiToLowCase (char c)

AsciiToLowCase (char c)

Lines 171-176	Link Here

171

  return os;

176

  return os;

172

177

173

178

179

/**

180

 * \brief Converts a string representing an hex number [0x0, 0xFF] into its value.

181

182

 * \param v a string

183

 * \returns the value

184

*/

174

static uint8_t

185

static uint8_t

175

AsInt (std::string v)

186

AsInt (std::string v)

176

187




   * Convert an instance of this class to a polymorphic Address instance.
   */
  Address ConvertTo (void) const;

  /**
   * \brief Return the Type of address.
   * \return type of address
   */
  static uint8_t GetType (void);

  /**
   * \brief Equal to operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operands are equal
   */
  friend bool operator == (const Mac64Address &a, const Mac64Address &b);

  /**
   * \brief Not equal to operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operands are not equal
   */
  friend bool operator != (const Mac64Address &a, const Mac64Address &b);

  /**
   * \brief Less than operator.
   *
   * \param a the first operand
   * \param b the first operand
   * \returns true if the operand a is less than operand b
   */
  friend bool operator < (const Mac64Address &a, const Mac64Address &b);

  /**
   * \brief Stream insertion operator.
   *
   * \param os the stream
   * \param address the address
   * \returns a reference to the stream
   */
  friend std::ostream& operator<< (std::ostream& os, const Mac64Address & address);

  /**
   * \brief Stream extraction operator.
   *
   * \param is the stream
   * \param address the address
   * \returns a reference to the stream
   */
  friend std::istream& operator>> (std::istream& is, Mac64Address & address);

  uint8_t m_address[8]; //!< address value
};

/**

 * \brief hold objects of type ns3::Mac64Address
 */

ATTRIBUTE_HELPER_HEADER (Mac64Address); //!< Macro to make help make class an ns-3 attribute

inline bool operator == (const Mac64Address &a, const Mac64Address &b)
{

(-)a/src/network/utils/output-stream-wrapper.h (-4 / +13 lines)

Lines 26-33	Link Here

namespace ns3 {

namespace ns3 {

/*

/**

 * @brief A class encapsulating an STL output stream.

 * @brief A class encapsulating an output stream.

 * This class wraps a pointer to a C++ std::ostream and provides

 * This class wraps a pointer to a C++ std::ostream and provides

 * reference counting of the object.  This class is recommended for users

 * reference counting of the object.  This class is recommended for users

Lines 70-76	Link Here

class OutputStreamWrapper : public SimpleRefCount<OutputStreamWrapper>

class OutputStreamWrapper : public SimpleRefCount<OutputStreamWrapper>

public:

public:

/**

   * Constructor

   * \param filename file name

   * \param filemode std::ios::openmode flags

*/

  OutputStreamWrapper (std::string filename, std::ios::openmode filemode);

  OutputStreamWrapper (std::string filename, std::ios::openmode filemode);

/**

   * Constructor

   * \param os output stream

*/

  OutputStreamWrapper (std::ostream* os);

  OutputStreamWrapper (std::ostream* os);

  ~OutputStreamWrapper ();

  ~OutputStreamWrapper ();

Lines 84-91	Link Here

  std::ostream *GetStream (void);

  std::ostream *GetStream (void);

private:

private:

  std::ostream *m_ostream;

  std::ostream *m_ostream; //!< The output stream

  bool m_destroyable;

  bool m_destroyable; //!< Can be destroyed

};

};

} // namespace ns3

100

} // namespace ns3

(-)a/src/network/utils/packet-burst.h (-3 / +15 lines)

Lines 29-40	Link Here

class Packet;

class Packet;

/**

 * \brief this class implement a burst as a list of packets

*/

class PacketBurst : public Object

class PacketBurst : public Object

public:

/**

/**

   * \brief this class implement a burst as a list of packets

   * \brief Get the type ID.

   * \return the object TypeId

*/

*/

public:

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  PacketBurst (void);

  PacketBurst (void);

  virtual ~PacketBurst (void);

  virtual ~PacketBurst (void);

Lines 60-70	Link Here

*/

*/

  uint32_t GetSize (void) const;

  uint32_t GetSize (void) const;

/**

   * \brief Returns an iterator to the begin of the burst

   * \return iterator to the burst list start

*/

  std::list<Ptr<Packet> >::const_iterator Begin (void) const;

  std::list<Ptr<Packet> >::const_iterator Begin (void) const;

/**

   * \brief Returns an iterator to the end of the burst

   * \return iterator to the burst list end

*/

  std::list<Ptr<Packet> >::const_iterator End (void) const;

  std::list<Ptr<Packet> >::const_iterator End (void) const;

private:

private:

  void DoDispose (void);

  void DoDispose (void);

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

  std::list<Ptr<Packet> > m_packets; //!< the list of packets in the burst

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/network/utils/packet-probe.h (+6 lines)

Lines 47-52	Link Here

class PacketProbe : public Probe

class PacketProbe : public Probe

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId ();

  static TypeId GetTypeId ();

  PacketProbe ();

  PacketProbe ();

  virtual ~PacketProbe ();

  virtual ~PacketProbe ();

Lines 96-102	Link Here

*/

100

*/

  void TraceSink (Ptr<const Packet> packet);

101

  void TraceSink (Ptr<const Packet> packet);

102

103

  /// Traced callback: packet received

  TracedCallback<Ptr<const Packet> > m_output;

104

  TracedCallback<Ptr<const Packet> > m_output;

105

  /// Traced callback: size of previous packet receive, size of actual packet received

100

  TracedCallback<uint32_t, uint32_t> m_outputBytes;

106

  TracedCallback<uint32_t, uint32_t> m_outputBytes;

101

107

102

  /// The traced packet.

108

  /// The traced packet.

(-)a/src/network/utils/packet-socket-address.h (-5 / +55 lines)

Lines 39-53	Link Here

public:

public:

  PacketSocketAddress ();

  PacketSocketAddress ();

/**

   * \brief Set the protocol

   * \param protocol the protocol

*/

  void SetProtocol (uint16_t protocol);

  void SetProtocol (uint16_t protocol);

/**

   * \brief Set the address to match all the outgoing NetDevice

*/

  void SetAllDevices (void);

  void SetAllDevices (void);

/**

   * \brief Set the address to match only a specified NetDevice

   * \param device the NetDevice index

*/

  void SetSingleDevice (uint32_t device);

  void SetSingleDevice (uint32_t device);

/**

   * \brief Set the destination address

   * \param address the destination address

*/

  void SetPhysicalAddress (const Address address);

  void SetPhysicalAddress (const Address address);

/**

   * \brief Get the protocol

   * \return the protocol

*/

  uint16_t GetProtocol (void) const;

  uint16_t GetProtocol (void) const;

/**

   * \brief Get the device this address is bound to

   * \return the device index

*/

  uint32_t GetSingleDevice (void) const;

  uint32_t GetSingleDevice (void) const;

/**

   * \brief Checks if the address is bound to a specified NetDevice

   * \return true if the address is bound to a NetDevice

*/

  bool IsSingleDevice (void) const;

  bool IsSingleDevice (void) const;

/**

   * \brief Get the destination address

   * \returns The destination address

*/

  Address GetPhysicalAddress (void) const;

  Address GetPhysicalAddress (void) const;

/**

/**

Lines 56-80	Link Here

   * Convert an instance of this class to a polymorphic Address instance.

   * Convert an instance of this class to a polymorphic Address instance.

*/

*/

  operator Address () const;

  operator Address () const;

/**

/**

   * \param address a polymorphic address

   * \param address a polymorphic address

   * \returns an Address

   * Convert a polymorphic address to an Mac48Address instance.

100

   * Convert a polymorphic address to an Mac48Address instance.

   * The conversion performs a type check.

101

   * The conversion performs a type check.

*/

102

*/

  static PacketSocketAddress ConvertFrom (const Address &address);

103

  static PacketSocketAddress ConvertFrom (const Address &address);

104

/**

105

/**

   * \param address address to test

106

   * \param address address to test

   * \returns true if the address matches, false otherwise.

107

   * \returns true if the address matches, false otherwise.

*/

108

*/

  static bool IsMatchingType (const Address &address);

109

  static bool IsMatchingType (const Address &address);

private:

110

private:

111

112

/**

113

   * \brief Return the Type of address.

114

   * \return type of address

115

*/

  static uint8_t GetType (void);

116

  static uint8_t GetType (void);

117

118

/**

119

   * \brief Convert an instance of this class to a polymorphic Address instance.

120

   * \returns a new Address instance

121

*/

  Address ConvertTo (void) const;

122

  Address ConvertTo (void) const;

  uint16_t m_protocol;

123

  bool m_isSingleDevice;

124

  uint16_t m_protocol;    //!< Protocol

  uint32_t m_device;

125

  bool m_isSingleDevice;  //!< True if directed to a specific outgoing NetDevice

  Address m_address;

126

  uint32_t m_device;      //!< Outgoing NetDevice index

127

  Address m_address;      //!< Destination address

};

128

};

129

130

(-)a/src/network/utils/packet-socket-factory.h (+4 lines)

Lines 35-40	Link Here

class PacketSocketFactory : public SocketFactory

class PacketSocketFactory : public SocketFactory

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  PacketSocketFactory ();

  PacketSocketFactory ();

(-)a/src/network/utils/packet-socket.h (-19 / +80 lines)

Lines 43-49	Link Here

 * A PacketSocket can be used to connect an application to a net

 * A PacketSocket can be used to connect an application to a net

 * device. The application provides the buffers of data, the socket

 * device. The application provides the buffers of data, the socket

 * conserts them to a raw packet and the net device then adds the

 * converts them to a raw packet and the net device then adds the

 * protocol specific headers and trailers. This socket type

 * protocol specific headers and trailers. This socket type

 * is very similar to the linux and BSD "packet" sockets.

 * is very similar to the linux and BSD "packet" sockets.

Lines 78-95	Link Here

class PacketSocket : public Socket

class PacketSocket : public Socket

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  PacketSocket ();

  PacketSocket ();

  virtual ~PacketSocket ();

  virtual ~PacketSocket ();

/**

   * \brief Set the associated node.

   * \param node the node

*/

  void SetNode (Ptr<Node> node);

  void SetNode (Ptr<Node> node);

  virtual enum SocketErrno GetErrno (void) const;

  virtual enum SocketErrno GetErrno (void) const;

  virtual enum SocketType GetSocketType (void) const;

  virtual enum SocketType GetSocketType (void) const;

  virtual Ptr<Node> GetNode (void) const;

  virtual Ptr<Node> GetNode (void) const;

/**

100

   * \brief Bind the socket to the NetDevice and register the protocol handler.

101

102

   * \warning this will actually bind protocol "0".

103

104

   * \returns 0 on success, -1 on failure.

105

*/

  virtual int Bind (void);

106

  virtual int Bind (void);

107

/**

108

   * \brief Bind the socket to the NetDevice and register the protocol handler.

109

110

   * \warning this will actually bind protocol "0".

111

112

   * \returns 0 on success, -1 on failure.

113

*/

  virtual int Bind6 (void);

114

  virtual int Bind6 (void);

115

/**

116

   * \brief Bind the socket to the NetDevice and register the

117

   *        protocol handler specified in the address.

118

119

   * \param address the packet socket address

120

   * \returns 0 on success, -1 on failure.

121

*/

  virtual int Bind (const Address & address);

122

  virtual int Bind (const Address & address);

  virtual int Close (void);

123

  virtual int Close (void);

  virtual int ShutdownSend (void);

124

  virtual int ShutdownSend (void);

Lines 108-149	Link Here

108

  virtual bool GetAllowBroadcast () const;

137

  virtual bool GetAllowBroadcast () const;

109

138

110

private:

139

private:

140

/**

141

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

142

143

   * \param device the incoming NetDevice

144

   * \param packet the incoming packet

145

   * \param protocol the protocol

146

   * \param from sender address

147

   * \param to destination address

148

   * \param packetType packet type

149

*/

111

  void ForwardUp (Ptr<NetDevice> device, Ptr<const Packet> packet,

150

  void ForwardUp (Ptr<NetDevice> device, Ptr<const Packet> packet,

112

                  uint16_t protocol, const Address &from, const Address &to,

151

                  uint16_t protocol, const Address &from, const Address &to,

113

                  NetDevice::PacketType packetType);

152

                  NetDevice::PacketType packetType);

153

/**

154

   * \brief Bind the socket to the NetDevice and register the

155

   *        protocol handler specified in the address.

156

   * \param address the packet socket address

157

   * \returns 0 on success, -1 on failure.

158

*/

114

  int DoBind (const PacketSocketAddress &address);

159

  int DoBind (const PacketSocketAddress &address);

160

161

/**

162

   * \brief Get the minimum MTU supported by the NetDevices bound to a specific address

163

   * \param ad the socket address to check for

164

   * \returns The minimum MTU

165

*/

115

  uint32_t GetMinMtu (PacketSocketAddress ad) const;

166

  uint32_t GetMinMtu (PacketSocketAddress ad) const;

116

  virtual void DoDispose (void);

167

  virtual void DoDispose (void);

117

168

169

/**

170

   * \brief States of the socket

171

*/

118

  enum State {

172

  enum State {

119

    STATE_OPEN,

173

    STATE_OPEN,

120

    STATE_BOUND,     // open and bound

174

    STATE_BOUND,     // open and bound

121

    STATE_CONNECTED, // open, bound and connected

175

    STATE_CONNECTED, // open, bound and connected

122

    STATE_CLOSED

176

    STATE_CLOSED

123

};

177

};

124

  Ptr<Node> m_node;

125

  enum SocketErrno m_errno;

126

  bool m_shutdownSend;

127

  bool m_shutdownRecv;

128

  enum State m_state;

129

  uint16_t m_protocol;

130

  bool m_isSingleDevice;

131

  uint32_t m_device;

132

  Address m_destAddr; /// Default destination address

133

178

134

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

179

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

135

  uint32_t m_rxAvailable;

180

  enum SocketErrno m_errno; //!< Socket error code

181

  bool m_shutdownSend;      //!< Send no longer allowed

182

  bool m_shutdownRecv;      //!< Receive no longer allowed

183

  enum State m_state;       //!< Socket state

184

  uint16_t m_protocol;      //!< Socket protocol

185

  bool m_isSingleDevice;    //!< Is bound to a single netDevice

186

  uint32_t m_device;        //!< index of the bound NetDevice

187

  Address m_destAddr;       //!< Default destination address

136

188

189

  std::queue<Ptr<Packet> > m_deliveryQueue; //!< Rx queue

190

  uint32_t m_rxAvailable; //!< Rx queue size [Bytes]

191

192

  /// Traced callback: dropped packets

137

  TracedCallback<Ptr<const Packet> > m_dropTrace;

193

  TracedCallback<Ptr<const Packet> > m_dropTrace;

138

194

139

  // Socket options (attributes)

195

  // Socket options (attributes)

140

  uint32_t m_rcvBufSize;

196

  uint32_t m_rcvBufSize; //!< Rx buffer size [Bytes]

141

197

142

};

198

};

143

199

144

/**

200

/**

145

 * \brief  This class implements a tag that carries the dest address of a packet and the packet type.

201

 * \brief  This class implements a tag that carries the dest address of a packet and the packet type.

146

147

*/

202

*/

148

class PacketSocketTag : public Tag

203

class PacketSocketTag : public Tag

149

204

Lines 173-178	Link Here

173

*/

228

*/

174

  Address GetDestAddress (void) const;

229

  Address GetDestAddress (void) const;

175

230

231

/**

232

   * \brief Get the type ID.

233

   * \return the object TypeId

234

*/

176

  static TypeId GetTypeId (void);

235

  static TypeId GetTypeId (void);

177

  virtual TypeId GetInstanceTypeId (void) const;

236

  virtual TypeId GetInstanceTypeId (void) const;

178

  virtual uint32_t GetSerializedSize (void) const;

237

  virtual uint32_t GetSerializedSize (void) const;

Lines 181-193	Link Here

181

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

240

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

182

241

183

private:

242

private:

184

  std::string m_deviceName;

243

  NetDevice::PacketType m_packetType; //!< Packet type

185

  NetDevice::PacketType m_packetType;

244

  Address m_destAddr; //!< Destination address

186

  Address m_destAddr;

187

};

245

};

188

/**

246

/**

189

 * \brief  This class implements a tag that carries the ns3 device name from where a packet is coming.

247

 * \brief  This class implements a tag that carries the ns3 device name from where a packet is coming.

190

191

*/

248

*/

192

class DeviceNameTag : public Tag

249

class DeviceNameTag : public Tag

193

250

Lines 206-211	Link Here

206

   * @return the device name from where the corresponding packet is coming.

263

   * @return the device name from where the corresponding packet is coming.

207

*/

264

*/

208

  std::string GetDeviceName (void) const;

265

  std::string GetDeviceName (void) const;

266

/**

267

   * \brief Get the type ID.

268

   * \return the object TypeId

269

*/

209

  static TypeId GetTypeId (void);

270

  static TypeId GetTypeId (void);

210

  virtual TypeId GetInstanceTypeId (void) const;

271

  virtual TypeId GetInstanceTypeId (void) const;

211

  virtual uint32_t GetSerializedSize (void) const;

272

  virtual uint32_t GetSerializedSize (void) const;

Lines 214-220	Link Here

214

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

275

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

215

276

216

private:

277

private:

217

  std::string m_deviceName;

278

  std::string m_deviceName; //!< Device name

218

};

279

};

219

280

220

} // namespace ns3

281

} // namespace ns3

(-)a/src/network/utils/packetbb.h (-51 / +155 lines)

Lines 55-62	Link Here

class PbbTlvBlock

class PbbTlvBlock

public:

public:

  typedef std::list< Ptr<PbbTlv> >::iterator Iterator;              /// this is an iterator

  /// PbbTlv container iterator

  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstIterator;   /// this is a const iterator

  typedef std::list< Ptr<PbbTlv> >::iterator Iterator;

  /// PbbTlv container const iterator

  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstIterator;

  PbbTlvBlock (void);

  PbbTlvBlock (void);

  ~PbbTlvBlock (void);

  ~PbbTlvBlock (void);

Lines 206-212	Link Here

206

  bool operator!= (const PbbTlvBlock &other) const;

208

  bool operator!= (const PbbTlvBlock &other) const;

207

209

208

private:

210

private:

209

  std::list< Ptr<PbbTlv> > m_tlvList;

211

  std::list< Ptr<PbbTlv> > m_tlvList; //!< PbbTlv container

210

};

212

};

211

213

212

/**

214

/**

Lines 217-224	Link Here

217

class PbbAddressTlvBlock

219

class PbbAddressTlvBlock

218

220

219

public:

221

public:

220

  typedef std::list< Ptr<PbbAddressTlv> >::iterator Iterator;               /// This is a PbbAddressTlv iterator for PbbAddressTlvBlock

222

  /// PbbAddressTlv iterator for PbbAddressTlvBlock

221

  typedef std::list< Ptr<PbbAddressTlv> >::const_iterator ConstIterator;    /// This is a const PbbAddressTlv iterator for PbbAddressTlvBlock

223

  typedef std::list< Ptr<PbbAddressTlv> >::iterator Iterator;

224

  /// PbbAddressTlv const iterator for PbbAddressTlvBlock

225

  typedef std::list< Ptr<PbbAddressTlv> >::const_iterator ConstIterator;

222

226

223

  PbbAddressTlvBlock (void);

227

  PbbAddressTlvBlock (void);

224

  ~PbbAddressTlvBlock (void);

228

  ~PbbAddressTlvBlock (void);

Lines 371-377	Link Here

371

  bool operator!= (const PbbAddressTlvBlock &other) const;

375

  bool operator!= (const PbbAddressTlvBlock &other) const;

372

376

373

private:

377

private:

374

  std::list< Ptr<PbbAddressTlv> > m_tlvList;

378

  std::list< Ptr<PbbAddressTlv> > m_tlvList; //!< PbbAddressTlv container

375

};

379

};

376

380

377

/**

381

/**

Lines 385-394	Link Here

385

class PbbPacket : public SimpleRefCount<PbbPacket,Header>

389

class PbbPacket : public SimpleRefCount<PbbPacket,Header>

386

390

387

public:

391

public:

388

  typedef std::list< Ptr<PbbTlv> >::iterator TlvIterator;                       /// This is a PbbTlv iterator for PbbPacket

392

  /// PbbTlv iterator for PbbPacket

389

  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstTlvIterator;            /// This is a const PbbTlv iterator for PbbPacket

393

  typedef std::list< Ptr<PbbTlv> >::iterator TlvIterator;

390

  typedef std::list< Ptr<PbbMessage> >::iterator MessageIterator;               /// This is a PbbMessageIterator for PbbPacket

394

  /// PbbTlv const iterator for PbbPacket

391

  typedef std::list< Ptr<PbbMessage> >::const_iterator ConstMessageIterator;    /// This is a const PbbMessageIterator for PbbPacket

395

  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstTlvIterator;

396

  /// PbbMessage Iterator for PbbPacket

397

  typedef std::list< Ptr<PbbMessage> >::iterator MessageIterator;

398

  /// PbbMessage Const Iterator for PbbPacket

399

  typedef std::list< Ptr<PbbMessage> >::const_iterator ConstMessageIterator;

392

400

393

  PbbPacket (void);

401

  PbbPacket (void);

394

  ~PbbPacket (void);

402

  ~PbbPacket (void);

Lines 617-623	Link Here

617

*/

625

*/

618

  void MessageClear (void);

626

  void MessageClear (void);

619

627

620

  /* Methods implemented by all headers */

628

/**

629

   * \brief Get the type ID.

630

   * \return the object TypeId

631

*/

621

  static TypeId GetTypeId (void);

632

  static TypeId GetTypeId (void);

622

  virtual TypeId GetInstanceTypeId (void) const;

633

  virtual TypeId GetInstanceTypeId (void) const;

623

634

Lines 665-677	Link Here

665

protected:

676

protected:

666

677

667

private:

678

private:

668

  PbbTlvBlock m_tlvList;

679

  PbbTlvBlock m_tlvList; //!< PbbTlv container

669

  std::list< Ptr<PbbMessage> > m_messageList;

680

  std::list< Ptr<PbbMessage> > m_messageList; //!< PbbTlvBlock container

670

681

671

  uint8_t m_version;

682

  uint8_t m_version; //!< version

672

683

673

  bool m_hasseqnum;

684

  bool m_hasseqnum; //!< Sequence number present

674

  uint16_t m_seqnum;

685

  uint16_t m_seqnum; //!< Sequence number

675

};

686

};

676

687

677

/**

688

/**

Lines 684-693	Link Here

684

class PbbMessage : public SimpleRefCount<PbbMessage>

695

class PbbMessage : public SimpleRefCount<PbbMessage>

685

696

686

public:

697

public:

687

  typedef std::list< Ptr<PbbTlv> >::iterator TlvIterator;                                 /// This is a PbbTlv iterator for PbbMessage

698

  /// PbbTlv iterator

688

  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstTlvIterator;                      /// This is a const PbbTlv iterator for PbbMessage

699

  typedef std::list< Ptr<PbbTlv> >::iterator TlvIterator;

689

  typedef std::list< Ptr<PbbAddressBlock> >::iterator AddressBlockIterator;               /// This is a PbbAddressBlock iterator for PbbMessage

700

  /// PbbTlv const iterator

690

  typedef std::list< Ptr<PbbAddressBlock> >::const_iterator ConstAddressBlockIterator;    /// This is a const PbbAddressBlock iterator for PbbMessage

701

  typedef std::list< Ptr<PbbTlv> >::const_iterator ConstTlvIterator;

702

  /// PbbAddressBlock iterator

703

  typedef std::list< Ptr<PbbAddressBlock> >::iterator AddressBlockIterator;

704

  /// PbbAddressBlock const iterator

705

  typedef std::list< Ptr<PbbAddressBlock> >::const_iterator ConstAddressBlockIterator;

691

706

692

  PbbMessage ();

707

  PbbMessage ();

693

  virtual ~PbbMessage ();

708

  virtual ~PbbMessage ();

Lines 1060-1089	Link Here

1060

*/

1075

*/

1061

  virtual PbbAddressLength GetAddressLength (void) const = 0;

1076

  virtual PbbAddressLength GetAddressLength (void) const = 0;

1062

1077

1078

/**

1079

   * \brief Serialize the originator address

1080

   * \param start the buffer iterator start

1081

*/

1063

  virtual void SerializeOriginatorAddress (Buffer::Iterator &start) const = 0;

1082

  virtual void SerializeOriginatorAddress (Buffer::Iterator &start) const = 0;

1083

/**

1084

   * \brief Deserialize the originator address

1085

   * \param start the buffer iterator start

1086

   * \returns the deserialized address

1087

*/

1064

  virtual Address DeserializeOriginatorAddress (Buffer::Iterator &start) const = 0;

1088

  virtual Address DeserializeOriginatorAddress (Buffer::Iterator &start) const = 0;

1089

/**

1090

   * \brief Print the originator address

1091

   * \param os the output stream

1092

*/

1065

  virtual void PrintOriginatorAddress (std::ostream &os) const = 0;

1093

  virtual void PrintOriginatorAddress (std::ostream &os) const = 0;

1066

1094

1095

/**

1096

   * \brief Deserialize an address block

1097

   * \param start the buffer iterator start

1098

   * \returns the deserialized address block

1099

*/

1067

  virtual Ptr<PbbAddressBlock> AddressBlockDeserialize (Buffer::Iterator &start) const = 0;

1100

  virtual Ptr<PbbAddressBlock> AddressBlockDeserialize (Buffer::Iterator &start) const = 0;

1068

1101

1069

private:

1102

private:

1070

  PbbTlvBlock m_tlvList;

1103

  PbbTlvBlock m_tlvList; //!< PbbTlvBlock

1071

  std::list< Ptr<PbbAddressBlock> > m_addressBlockList;

1104

  std::list< Ptr<PbbAddressBlock> > m_addressBlockList; //!< PbbAddressBlock container

1072

1105

1073

  uint8_t m_type;

1106

  uint8_t m_type; //!< the type for this message

1074

  PbbAddressLength m_addrSize;

1107

  PbbAddressLength m_addrSize; //!< the address size

1075

1108

1076

  bool m_hasOriginatorAddress;

1109

  bool m_hasOriginatorAddress; //!< Originator address present

1077

  Address m_originatorAddress;

1110

  Address m_originatorAddress; //!< originator address

1078

1111

1079

  bool m_hasHopLimit;

1112

  bool m_hasHopLimit; //!< Hop limit present

1080

  uint8_t m_hopLimit;

1113

  uint8_t m_hopLimit; //!< Hop limit

1081

1114

1082

  bool m_hasHopCount;

1115

  bool m_hasHopCount; //!< Hop count present

1083

  uint8_t m_hopCount;

1116

  uint8_t m_hopCount; //!< Hop count

1084

1117

1085

  bool m_hasSequenceNumber;

1118

  bool m_hasSequenceNumber;  //!< Sequence number present

1086

  uint16_t m_sequenceNumber;

1119

  uint16_t m_sequenceNumber; //!< Sequence number

1087

};

1120

};

1088

1121

1089

/**

1122

/**

Lines 1151-1164	Link Here

1151

class PbbAddressBlock : public SimpleRefCount<PbbAddressBlock>

1184

class PbbAddressBlock : public SimpleRefCount<PbbAddressBlock>

1152

1185

1153

public:

1186

public:

1154

  typedef std::list< Address >::iterator AddressIterator;             /// this is an address iterator for PbbAddressBlock

1187

  /// Address iterator

1155

  typedef std::list< Address >::const_iterator ConstAddressIterator;  /// this is an const address iterator for PbbAddressBlock

1188

  typedef std::list< Address >::iterator AddressIterator;

1189

  /// Address const iterator

1190

  typedef std::list< Address >::const_iterator ConstAddressIterator;

1156

1191

1157

  typedef std::list<uint8_t>::iterator PrefixIterator;                /// this is a prefix iterator for PbbAddressBlock

1192

  /// Prefix iterator

1158

  typedef std::list<uint8_t>::const_iterator ConstPrefixIterator;     /// this is a const prefix iterator for PbbAddressBlock

1193

  typedef std::list<uint8_t>::iterator PrefixIterator;

1194

  /// Prefix const iterator

1195

  typedef std::list<uint8_t>::const_iterator ConstPrefixIterator;

1159

1196

1160

  typedef PbbAddressTlvBlock::Iterator TlvIterator;                   /// this is a tlvblock iterator for PbbAddressBlock

1197

  /// tlvblock iterator

1161

  typedef PbbAddressTlvBlock::ConstIterator ConstTlvIterator;         /// this is a const tlvblock iterator for PbbAddressBlock

1198

  typedef PbbAddressTlvBlock::Iterator TlvIterator;

1199

  /// tlvblock const iterator

1200

  typedef PbbAddressTlvBlock::ConstIterator ConstTlvIterator;

1162

1201

1163

  PbbAddressBlock ();

1202

  PbbAddressBlock ();

1164

  virtual ~PbbAddressBlock ();

1203

  virtual ~PbbAddressBlock ();

Lines 1522-1540	Link Here

1522

   * \returns Address length

1561

   * \returns Address length

1523

*/

1562

*/

1524

  virtual uint8_t GetAddressLength (void) const = 0;

1563

  virtual uint8_t GetAddressLength (void) const = 0;

1564

/**

1565

   * \brief Serialize one or more addresses

1566

   * \param buffer the buffer to serialize to

1567

   * \param iter the iterator to the addresses

1568

*/

1525

  virtual void SerializeAddress (uint8_t *buffer, ConstAddressIterator iter) const = 0;

1569

  virtual void SerializeAddress (uint8_t *buffer, ConstAddressIterator iter) const = 0;

1570

/**

1571

   * \brief Deserialize one address

1572

   * \param buffer the buffer to deserialize from

1573

   * \returns the address

1574

*/

1526

  virtual Address DeserializeAddress (uint8_t *buffer) const = 0;

1575

  virtual Address DeserializeAddress (uint8_t *buffer) const = 0;

1576

/**

1577

   * \brief Print one or more addresses

1578

   * \param os the output stream

1579

   * \param iter the iterator to the addresses

1580

*/

1527

  virtual void PrintAddress (std::ostream &os, ConstAddressIterator iter) const = 0;

1581

  virtual void PrintAddress (std::ostream &os, ConstAddressIterator iter) const = 0;

1528

1582

1529

private:

1583

private:

1584

/**

1585

   * \brief Get the prefix flags

1586

   * \return the prefix flags

1587

*/

1530

  uint8_t GetPrefixFlags (void) const;

1588

  uint8_t GetPrefixFlags (void) const;

1589

/**

1590

   * \brief Get head and tail

1591

   * \param head the head

1592

   * \param headlen the head length

1593

   * \param tail the tail

1594

   * \param taillen the tail length

1595

*/

1531

  void GetHeadTail (uint8_t *head, uint8_t &headlen,

1596

  void GetHeadTail (uint8_t *head, uint8_t &headlen,

1532

                    uint8_t *tail, uint8_t &taillen) const;

1597

                    uint8_t *tail, uint8_t &taillen) const;

1598

1599

/**

1600

   * \brief Check if the tail is empty

1601

   * \param tail the tail

1602

   * \param taillen the tail length

1603

   * \returns true if the tail is empty

1604

*/

1533

  bool HasZeroTail (const uint8_t *tail, uint8_t taillen) const;

1605

  bool HasZeroTail (const uint8_t *tail, uint8_t taillen) const;

1534

1606

1535

  std::list<Address> m_addressList;

1607

  std::list<Address> m_addressList; //!< Addreses container

1536

  std::list<uint8_t> m_prefixList;

1608

  std::list<uint8_t> m_prefixList; //!< Prefixes container

1537

  PbbAddressTlvBlock m_addressTlvList;

1609

  PbbAddressTlvBlock m_addressTlvList; //!< PbbAddressTlv container

1538

};

1610

};

1539

1611

1540

/**

1612

/**

Lines 1717-1748	Link Here

1717

  bool operator!= (const PbbTlv &other) const;

1789

  bool operator!= (const PbbTlv &other) const;

1718

1790

1719

protected:

1791

protected:

1792

/**

1793

   * \brief Set an index as starting point

1794

   * \param index the starting index

1795

*/

1720

  void SetIndexStart (uint8_t index);

1796

  void SetIndexStart (uint8_t index);

1797

/**

1798

   * \brief Get the starting point index

1799

   * \returns the starting index

1800

*/

1721

  uint8_t GetIndexStart (void) const;

1801

  uint8_t GetIndexStart (void) const;

1802

/**

1803

   * \brief Checks if there is a starting index

1804

   * \returns true if the start index has been set

1805

*/

1722

  bool HasIndexStart (void) const;

1806

  bool HasIndexStart (void) const;

1723

1807

1808

/**

1809

   * \brief Set an index as stop point

1810

   * \param index the stop index

1811

*/

1724

  void SetIndexStop (uint8_t index);

1812

  void SetIndexStop (uint8_t index);

1813

/**

1814

   * \brief Get the stop point index

1815

   * \returns the stop index

1816

*/

1725

  uint8_t GetIndexStop (void) const;

1817

  uint8_t GetIndexStop (void) const;

1818

/**

1819

   * \brief Checks if there is a stop index

1820

   * \returns true if the stop index has been set

1821

*/

1726

  bool HasIndexStop (void) const;

1822

  bool HasIndexStop (void) const;

1727

1823

1824

/**

1825

   * \brief Set the multivalue parameter

1826

   * \param isMultivalue the multivalue status

1827

*/

1728

  void SetMultivalue (bool isMultivalue);

1828

  void SetMultivalue (bool isMultivalue);

1829

/**

1830

   * \brief Check the multivalue parameter

1831

   * \returns the multivalue status

1832

*/

1729

  bool IsMultivalue (void) const;

1833

  bool IsMultivalue (void) const;

1730

1834

1731

private:

1835

private:

1732

  uint8_t m_type;

1836

  uint8_t m_type; //!< Type of this TLV.

1733

1837

1734

  bool m_hasTypeExt;

1838

  bool m_hasTypeExt; //!< Extended type present.

1735

  uint8_t m_typeExt;

1839

  uint8_t m_typeExt; //!< Extended type.

1736

1840

1737

  bool m_hasIndexStart;

1841

  bool m_hasIndexStart; //!< Start index present.

1738

  uint8_t m_indexStart;

1842

  uint8_t m_indexStart; //!< Start index.

1739

1843

1740

  bool m_hasIndexStop;

1844

  bool m_hasIndexStop; //!< Stop index present.

1741

  uint8_t m_indexStop;

1845

  uint8_t m_indexStop; //!< Stop index.

1742

1846

1743

  bool m_isMultivalue;

1847

  bool m_isMultivalue; //!< Is multivalue.

1744

  bool m_hasValue;

1848

  bool m_hasValue;     //!< Has value.

1745

  Buffer m_value;

1849

  Buffer m_value;      //!< Value.

1746

};

1850

};

1747

1851

1748

/**

1852

/**

(-)a/src/network/utils/pcap-file-wrapper.h (-10 / +28 lines)

Lines 30-36	Link Here

namespace ns3 {

namespace ns3 {

/*

/**

 * A class that wraps a PcapFile as an ns3::Object and provides a higher-layer

 * A class that wraps a PcapFile as an ns3::Object and provides a higher-layer

 * ns-3 interface to the low-level public methods of PcapFile.  Users are

 * ns-3 interface to the low-level public methods of PcapFile.  Users are

 * encouraged to use this object instead of class ns3::PcapFile in ns-3

 * encouraged to use this object instead of class ns3::PcapFile in ns-3

Lines 39-44	Link Here

class PcapFileWrapper : public Object

class PcapFileWrapper : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  PcapFileWrapper ();

  PcapFileWrapper ();

Lines 138-202	Link Here

138

*/

142

*/

139

  void Write (Time t, uint8_t const *buffer, uint32_t length);

143

  void Write (Time t, uint8_t const *buffer, uint32_t length);

140

144

141

/*

145

/**

142

   * \brief Returns the magic number of the pcap file as defined by the magic_number

146

   * \brief Returns the magic number of the pcap file as defined by the magic_number

143

   * field in the pcap global header.

147

   * field in the pcap global header.

144

148

145

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

149

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

150

151

   * \returns magic number

146

*/

152

*/

147

  uint32_t GetMagic (void);

153

  uint32_t GetMagic (void);

148

154

149

/*

155

/**

150

   * \brief Returns the major version of the pcap file as defined by the version_major

156

   * \brief Returns the major version of the pcap file as defined by the version_major

151

   * field in the pcap global header.

157

   * field in the pcap global header.

152

158

153

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

159

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

160

161

   * \returns major version

154

*/

162

*/

155

  uint16_t GetVersionMajor (void);

163

  uint16_t GetVersionMajor (void);

156

164

157

/*

165

/**

158

   * \brief Returns the minor version of the pcap file as defined by the version_minor

166

   * \brief Returns the minor version of the pcap file as defined by the version_minor

159

   * field in the pcap global header.

167

   * field in the pcap global header.

160

168

161

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

169

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

170

171

   * \returns minor version

162

*/

172

*/

163

  uint16_t GetVersionMinor (void);

173

  uint16_t GetVersionMinor (void);

164

174

165

/*

175

/**

166

   * \brief Returns the time zone offset of the pcap file as defined by the thiszone

176

   * \brief Returns the time zone offset of the pcap file as defined by the thiszone

167

   * field in the pcap global header.

177

   * field in the pcap global header.

168

178

169

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

179

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

180

181

   * \returns time zone offset

170

*/

182

*/

171

  int32_t GetTimeZoneOffset (void);

183

  int32_t GetTimeZoneOffset (void);

172

184

173

/*

185

/**

174

   * \brief Returns the accuracy of timestamps field of the pcap file as defined

186

   * \brief Returns the accuracy of timestamps field of the pcap file as defined

175

   * by the sigfigs field in the pcap global header.

187

   * by the sigfigs field in the pcap global header.

176

188

177

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

189

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

190

191

   * \returns accuracy of timestamps

178

*/

192

*/

179

  uint32_t GetSigFigs (void);

193

  uint32_t GetSigFigs (void);

180

194

181

/*

195

/**

182

   * \brief Returns the max length of saved packets field of the pcap file as

196

   * \brief Returns the max length of saved packets field of the pcap file as

183

   * defined by the snaplen field in the pcap global header.

197

   * defined by the snaplen field in the pcap global header.

184

198

185

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

199

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

200

201

   * \returns max length of saved packets field

186

*/

202

*/

187

  uint32_t GetSnapLen (void);

203

  uint32_t GetSnapLen (void);

188

204

189

/*

205

/**

190

   * \brief Returns the data link type field of the pcap file as defined by the

206

   * \brief Returns the data link type field of the pcap file as defined by the

191

   * network field in the pcap global header.

207

   * network field in the pcap global header.

192

208

193

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

209

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

210

211

   * \returns data link type field

194

*/

212

*/

195

  uint32_t GetDataLinkType (void);

213

  uint32_t GetDataLinkType (void);

196

214

197

private:

215

private:

198

  PcapFile m_file;

216

  PcapFile m_file; //!< Pcap file

199

  uint32_t m_snapLen;

217

  uint32_t m_snapLen; //!< max length of saved packets

200

};

218

};

201

219

202

} // namespace ns3

220

} // namespace ns3

(-)a/src/network/utils/pcap-file.h (-11 / +72 lines)

Lines 186-247	Link Here

186

   * byteswapped.  Used primarily for testing the class itself, but may be

186

   * byteswapped.  Used primarily for testing the class itself, but may be

187

   * useful as a flag indicating a difference in endianness of the writing

187

   * useful as a flag indicating a difference in endianness of the writing

188

   * system.

188

   * system.

189

190

   * \returns swap mode of the file

189

*/

191

*/

190

  bool GetSwapMode (void);

192

  bool GetSwapMode (void);

191

193

192

/*

194

/**

193

   * \brief Returns the magic number of the pcap file as defined by the magic_number

195

   * \brief Returns the magic number of the pcap file as defined by the magic_number

194

   * field in the pcap global header.

196

   * field in the pcap global header.

195

197

196

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

198

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

199

200

   * \returns magic number

197

*/

201

*/

198

  uint32_t GetMagic (void);

202

  uint32_t GetMagic (void);

199

203

200

/*

204

/**

201

   * \brief Returns the major version of the pcap file as defined by the version_major

205

   * \brief Returns the major version of the pcap file as defined by the version_major

202

   * field in the pcap global header.

206

   * field in the pcap global header.

203

207

204

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

208

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

209

210

   * \returns major version

205

*/

211

*/

206

  uint16_t GetVersionMajor (void);

212

  uint16_t GetVersionMajor (void);

207

213

208

/*

214

/**

209

   * \brief Returns the minor version of the pcap file as defined by the version_minor

215

   * \brief Returns the minor version of the pcap file as defined by the version_minor

210

   * field in the pcap global header.

216

   * field in the pcap global header.

211

217

212

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

218

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

219

220

   * \returns minor version

213

*/

221

*/

214

  uint16_t GetVersionMinor (void);

222

  uint16_t GetVersionMinor (void);

215

223

216

/*

224

/**

217

   * \brief Returns the time zone offset of the pcap file as defined by the thiszone

225

   * \brief Returns the time zone offset of the pcap file as defined by the thiszone

218

   * field in the pcap global header.

226

   * field in the pcap global header.

219

227

220

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

228

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

229

230

   * \returns time zone offset

221

*/

231

*/

222

  int32_t GetTimeZoneOffset (void);

232

  int32_t GetTimeZoneOffset (void);

223

233

224

/*

234

/**

225

   * \brief Returns the accuracy of timestamps field of the pcap file as defined

235

   * \brief Returns the accuracy of timestamps field of the pcap file as defined

226

   * by the sigfigs field in the pcap global header.

236

   * by the sigfigs field in the pcap global header.

227

237

228

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

238

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

239

240

   * \returns accuracy of timestamps

229

*/

241

*/

230

  uint32_t GetSigFigs (void);

242

  uint32_t GetSigFigs (void);

231

243

232

/*

244

/**

233

   * \brief Returns the max length of saved packets field of the pcap file as

245

   * \brief Returns the max length of saved packets field of the pcap file as

234

   * defined by the snaplen field in the pcap global header.

246

   * defined by the snaplen field in the pcap global header.

235

247

236

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

248

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

249

250

   * \returns max length of saved packets field

237

*/

251

*/

238

  uint32_t GetSnapLen (void);

252

  uint32_t GetSnapLen (void);

239

253

240

/*

254

/**

241

   * \brief Returns the data link type field of the pcap file as defined by the

255

   * \brief Returns the data link type field of the pcap file as defined by the

242

   * network field in the pcap global header.

256

   * network field in the pcap global header.

243

257

244

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

258

   * See http://wiki.wireshark.org/Development/LibpcapFileFormat

259

260

   * \returns data link type field

245

*/

261

*/

246

  uint32_t GetDataLinkType (void);

262

  uint32_t GetDataLinkType (void);

247

263

Lines 261-266	Link Here

261

                    uint32_t snapLen = SNAPLEN_DEFAULT);

277

                    uint32_t snapLen = SNAPLEN_DEFAULT);

262

278

263

private:

279

private:

280

/**

281

   * \brief Pcap file header

282

*/

264

  typedef struct {

283

  typedef struct {

265

    uint32_t m_magicNumber;   /**< Magic number identifying this as a pcap file */

284

    uint32_t m_magicNumber;   /**< Magic number identifying this as a pcap file */

266

    uint16_t m_versionMajor;  /**< Major version identifying the version of pcap used in this file */

285

    uint16_t m_versionMajor;  /**< Major version identifying the version of pcap used in this file */

Lines 271-276	Link Here

271

    uint32_t m_type;          /**< Data link type of packet data */

290

    uint32_t m_type;          /**< Data link type of packet data */

272

  } PcapFileHeader;

291

  } PcapFileHeader;

273

292

293

/**

294

   * \brief Pcap record header

295

*/

274

  typedef struct {

296

  typedef struct {

275

    uint32_t m_tsSec;         /**< seconds part of timestamp */

297

    uint32_t m_tsSec;         /**< seconds part of timestamp */

276

    uint32_t m_tsUsec;        /**< microseconds part of timestamp (nsecs for PCAP_NSEC_MAGIC) */

298

    uint32_t m_tsUsec;        /**< microseconds part of timestamp (nsecs for PCAP_NSEC_MAGIC) */

Lines 278-297	Link Here

278

    uint32_t m_origLen;       /**< actual length of original packet */

300

    uint32_t m_origLen;       /**< actual length of original packet */

279

  } PcapRecordHeader;

301

  } PcapRecordHeader;

280

302

303

/**

304

   * \brief Swap a value byte order

305

   * \param val the value

306

   * \returns the value with byte order swapped

307

*/

281

  uint8_t Swap (uint8_t val);

308

  uint8_t Swap (uint8_t val);

309

/**

310

   * \brief Swap a value byte order

311

   * \param val the value

312

   * \returns the value with byte order swapped

313

*/

282

  uint16_t Swap (uint16_t val);

314

  uint16_t Swap (uint16_t val);

315

/**

316

   * \brief Swap a value byte order

317

   * \param val the value

318

   * \returns the value with byte order swapped

319

*/

283

  uint32_t Swap (uint32_t val);

320

  uint32_t Swap (uint32_t val);

321

/**

322

   * \brief Swap the byte order of a Pcap file header

323

   * \param from original file header

324

   * \param to swapped file header

325

*/

284

  void Swap (PcapFileHeader *from, PcapFileHeader *to);

326

  void Swap (PcapFileHeader *from, PcapFileHeader *to);

327

/**

328

   * \brief Swap the byte order of a Pcap record header

329

   * \param from original record header

330

   * \param to swapped record header

331

*/

285

  void Swap (PcapRecordHeader *from, PcapRecordHeader *to);

332

  void Swap (PcapRecordHeader *from, PcapRecordHeader *to);

286

333

334

/**

335

   * \brief Write a Pcap file header

336

*/

287

  void WriteFileHeader (void);

337

  void WriteFileHeader (void);

338

/**

339

   * \brief Write a Pcap packet header

340

   * \param tsSec Time stamp (seconds part)

341

   * \param tsUsec Time stamp (microseconds part)

342

   * \param totalLen total packet length

343

   * \returns the length of the packet to write in the Pcap file

344

*/

288

  uint32_t WritePacketHeader (uint32_t tsSec, uint32_t tsUsec, uint32_t totalLen);

345

  uint32_t WritePacketHeader (uint32_t tsSec, uint32_t tsUsec, uint32_t totalLen);

346

347

/**

348

   * \brief Read and verify a Pcap file header

349

*/

289

  void ReadAndVerifyFileHeader (void);

350

  void ReadAndVerifyFileHeader (void);

290

351

291

  std::string    m_filename;

352

  std::string    m_filename;    //!< file name

292

  std::fstream   m_file;

353

  std::fstream   m_file;        //!< file stream

293

  PcapFileHeader m_fileHeader;

354

  PcapFileHeader m_fileHeader;  //!< file header

294

  bool m_swapMode;

355

  bool m_swapMode;              //!< swap mode

295

};

356

};

296

357

297

} // namespace ns3

358

} // namespace ns3

(-)a/src/network/utils/queue.h (-6 / +26 lines)

Lines 45-50	Link Here

class Queue : public Object

class Queue : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Queue ();

  Queue ();

Lines 151-158	Link Here

151

155

152

private:

156

private:

153

157

158

/**

159

   * Push a packet in the queue

160

   * \param p the packet to enqueue

161

   * \return true if success, false if the packet has been dropped.

162

*/

154

  virtual bool DoEnqueue (Ptr<Packet> p) = 0;

163

  virtual bool DoEnqueue (Ptr<Packet> p) = 0;

164

/**

165

   * Pull a packet from the queue

166

   * \return the packet.

167

*/

155

  virtual Ptr<Packet> DoDequeue (void) = 0;

168

  virtual Ptr<Packet> DoDequeue (void) = 0;

169

/**

170

   * Peek the front packet in the queue

171

   * \return the packet.

172

*/

156

  virtual Ptr<const Packet> DoPeek (void) const = 0;

173

  virtual Ptr<const Packet> DoPeek (void) const = 0;

157

174

158

protected:

175

protected:

Lines 164-179	Link Here

164

  void Drop (Ptr<Packet> packet);

181

  void Drop (Ptr<Packet> packet);

165

182

166

private:

183

private:

184

  /// Traced callback: fired when a packet is enqueued

167

  TracedCallback<Ptr<const Packet> > m_traceEnqueue;

185

  TracedCallback<Ptr<const Packet> > m_traceEnqueue;

186

  /// Traced callback: fired when a packet is dequeued

168

  TracedCallback<Ptr<const Packet> > m_traceDequeue;

187

  TracedCallback<Ptr<const Packet> > m_traceDequeue;

188

  /// Traced callback: fired when a packet is dropped

169

  TracedCallback<Ptr<const Packet> > m_traceDrop;

189

  TracedCallback<Ptr<const Packet> > m_traceDrop;

170

190

171

  uint32_t m_nBytes;

191

  uint32_t m_nBytes;                //!< Number of bytes in the queue

172

  uint32_t m_nTotalReceivedBytes;

192

  uint32_t m_nTotalReceivedBytes;   //!< Total received bytes

173

  uint32_t m_nPackets;

193

  uint32_t m_nPackets;              //!< Number of packets in the queue

174

  uint32_t m_nTotalReceivedPackets;

194

  uint32_t m_nTotalReceivedPackets; //!< Total received packets

175

  uint32_t m_nTotalDroppedBytes;

195

  uint32_t m_nTotalDroppedBytes;    //!< Total dropped bytes

176

  uint32_t m_nTotalDroppedPackets;

196

  uint32_t m_nTotalDroppedPackets;  //!< Total dropped packets

177

};

197

};

178

198

179

} // namespace ns3

199

} // namespace ns3

(-)a/src/network/utils/radiotap-header.h (-12 / +14 lines)

Lines 35-41	Link Here

 * from a userspace application to the driver for transmission.

 * from a userspace application to the driver for transmission.

 * @warning the radiotap header specification says that the fields included in

 * @warning the radiotap header specification says that the fields included in

 * the header should be aligned to their natural ize (e.g., 16-bit fields

 * the header should be aligned to their natural size (e.g., 16-bit fields

 * aligned to 16-bit boundaries, 32-bit fields aligned to 32-bit boundaries,

 * aligned to 16-bit boundaries, 32-bit fields aligned to 32-bit boundaries,

 * and so on.  This implementation does not enforce this.  However, the radiotap

 * and so on.  This implementation does not enforce this.  However, the radiotap

 * specification enforces an order in which fields have to appear (if they

 * specification enforces an order in which fields have to appear (if they

Lines 49-54	Link Here

public:

public:

  RadiotapHeader();

  RadiotapHeader();

/**

   * \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;

Lines 242-259	Link Here

242

    RADIOTAP_EXT               = 0x10000000

246

    RADIOTAP_EXT               = 0x10000000

243

};

247

};

244

248

245

  void CheckAddChannelField ();

249

  uint16_t m_length;        //!< entire length of radiotap data + header

250

  uint32_t m_present;       //!< bits describing which fields follow header

246

251

247

  uint16_t m_length;

252

  uint64_t m_tsft;          //!< Time Synchronization Function Timer (when the first bit of the MPDU arrived at the MAC)

248

  uint32_t m_present;

253

  uint8_t m_flags;          //!< Properties of transmitted and received frames.

249

254

  uint8_t m_rate;           //!< TX/RX data rate in units of 500 kbps

250

  uint64_t m_tsft;

255

  uint16_t m_channelFreq;   //!< Tx/Rx frequency in MHz.

251

  uint8_t m_flags;

256

  uint16_t m_channelFlags;  //!< Tx/Rx channel flags.

252

  uint8_t m_rate;

257

  int8_t m_antennaSignal;   //!< RF signal power at the antenna, dB difference from an arbitrary, fixed reference.

253

  uint16_t m_channelFreq;

258

  int8_t m_antennaNoise;    //!< RF noise power at the antenna, dB difference from an arbitrary, fixed reference.

254

  uint16_t m_channelFlags;

255

  int8_t m_antennaSignal;

256

  int8_t m_antennaNoise;

257

};

259

};

258

260

259

} // namespace ns3

261

} // namespace ns3

(-)a/src/network/utils/red-queue.h (-74 / +89 lines)

Lines 74-80	Link Here

class TraceContainer;

class TraceContainer;

class UniformRandomVariable;

class UniformRandomVariable;

/*

/**

 * \ingroup queue

 * \ingroup queue

 * \brief A RED packet queue

 * \brief A RED packet queue

Lines 82-87	Link Here

class RedQueue : public Queue

class RedQueue : public Queue

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * \brief RedQueue Constructor

   * \brief RedQueue Constructor

Lines 99-122	Link Here

103

100

/**

104

/**

101

   * \brief Stats

105

   * \brief Stats

102

103

*/

106

*/

104

  typedef struct

107

  typedef struct

105

108

106

    uint32_t unforcedDrop;  /// Early probability drops

109

    uint32_t unforcedDrop;  //!< Early probability drops

107

    uint32_t forcedDrop;    /// Forced drops, qavg > max threshold

110

    uint32_t forcedDrop;    //!< Forced drops, qavg > max threshold

108

    uint32_t qLimDrop;      /// Drops due to queue limits

111

    uint32_t qLimDrop;      //!< Drops due to queue limits

109

  } Stats;

112

  } Stats;

110

113

111

/**

114

/**

112

   * \brief Drop types

115

   * \brief Drop types

113

114

*/

116

*/

115

  enum

117

  enum

116

118

117

    DTYPE_NONE,        /// Ok, no drop

119

    DTYPE_NONE,        //!< Ok, no drop

118

    DTYPE_FORCED,      /// A "forced" drop

120

    DTYPE_FORCED,      //!< A "forced" drop

119

    DTYPE_UNFORCED,    /// An "unforced" (random) drop

121

    DTYPE_UNFORCED,    //!< An "unforced" (random) drop

120

};

122

};

121

123

122

/**

124

/**

Lines 179-268	Link Here

179

  virtual Ptr<Packet> DoDequeue (void);

181

  virtual Ptr<Packet> DoDequeue (void);

180

  virtual Ptr<const Packet> DoPeek (void) const;

182

  virtual Ptr<const Packet> DoPeek (void) const;

181

183

182

  // ...

184

/**

185

   * \brief Initialize the queue parameters.

186

187

   * Note: if the link bandwidth changes in the course of the

188

   * simulation, the bandwidth-dependent RED parameters do not change.

189

   * This should be fixed, but it would require some extra parameters,

190

   * and didn't seem worth the trouble...

191

*/

183

  void InitializeParams (void);

192

  void InitializeParams (void);

184

  // Compute the average queue size

193

/**

194

   * \brief Compute the average queue size

195

   * \param nQueued number of queued packets

196

   * \param m simulated number of packets arrival during idle period

197

   * \param qAvg average queue size

198

   * \param qW queue weight given to cur q size sample

199

   * \returns new average queue size

200

*/

185

  double Estimator (uint32_t nQueued, uint32_t m, double qAvg, double qW);

201

  double Estimator (uint32_t nQueued, uint32_t m, double qAvg, double qW);

186

  // Check if packet p needs to be dropped due to probability mark

202

/**

203

   * \brief Check if packet p needs to be dropped due to probability mark

204

   * \param p packet

205

   * \param qSize queue size

206

   * \returns 0 for no drop/mark, 1 for drop

207

*/

187

  uint32_t DropEarly (Ptr<Packet> p, uint32_t qSize);

208

  uint32_t DropEarly (Ptr<Packet> p, uint32_t qSize);

188

  // Returns a probability using these function parameters for the DropEarly funtion

209

/**

189

  double CalculatePNew (double qAvg, double maxTh, bool gentle, double vA,

210

   * \brief Returns a probability using these function parameters for the DropEarly function

211

   * \param qAvg Average queue length

212

   * \param maxTh Max avg length threshold

213

   * \param gentle "gentle" algorithm

214

   * \param vA vA

215

   * \param vB vB

216

   * \param vC vC

217

   * \param vD vD

218

   * \param maxP max_p

219

   * \returns Prob. of packet drop before "count"

220

*/

221

  double CalculatePNew (double qAvg, double , bool gentle, double vA,

190

                        double vB, double vC, double vD, double maxP);

222

                        double vB, double vC, double vD, double maxP);

191

  // Returns a probability using these function parameters for the DropEarly funtion

223

/**

224

   * \brief Returns a probability using these function parameters for the DropEarly function

225

   * \param p Prob. of packet drop before "count"

226

   * \param count number of packets since last random number generation

227

   * \param countBytes number of bytes since last drop

228

   * \param meanPktSize Avg pkt size

229

   * \param wait True for waiting between dropped packets

230

   * \param size packet size

231

   * \returns Prob. of packet drop

232

*/

192

  double ModifyP (double p, uint32_t count, uint32_t countBytes,

233

  double ModifyP (double p, uint32_t count, uint32_t countBytes,

193

                  uint32_t meanPktSize, bool wait, uint32_t size);

234

                  uint32_t meanPktSize, bool wait, uint32_t size);

194

235

195

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

236

  std::list<Ptr<Packet> > m_packets; //!< packets in the queue

196

237

197

  uint32_t m_bytesInQueue;

238

  uint32_t m_bytesInQueue; //!< bytes in the queue

198

  bool m_hasRedStarted;

239

  bool m_hasRedStarted; //!< True if RED has started

199

  Stats m_stats;

240

  Stats m_stats; //!< RED statistics

200

241

201

  // ** Variables supplied by user

242

  // ** Variables supplied by user

202

  // Bytes or packets?

243

  QueueMode m_mode;         //!< Mode (Bytes or packets)

203

  QueueMode m_mode;

244

  uint32_t m_meanPktSize;   //!< Avg pkt size

204

  // Avg pkt size

245

  uint32_t m_idlePktSize;   //!< Avg pkt size used during idle times

205

  uint32_t m_meanPktSize;

246

  bool m_isWait;            //!< True for waiting between dropped packets

206

  // Avg pkt size used during idle times

247

  bool m_isGentle;          //!< True to increases dropping prob. slowly when ave queue exceeds maxthresh

207

  uint32_t m_idlePktSize;

248

  double m_minTh;           //!< Min avg length threshold (bytes)

208

  // True for waiting between dropped packets

249

  double m_maxTh;           //!< Max avg length threshold (bytes), should be >= 2*minTh

209

  bool m_isWait;

250

  uint32_t m_queueLimit;    //!< Queue limit in bytes / packets

210

  // True to increases dropping prob. slowly when ave queue exceeds maxthresh

251

  double m_qW;              //!< Queue weight given to cur queue size sample

211

  bool m_isGentle;

252

  double m_lInterm;         //!< The max probability of dropping a packet

212

  // Min avg length threshold (bytes)

253

  bool m_isNs1Compat;       //!< Ns-1 compatibility

213

  double m_minTh;

254

  DataRate m_linkBandwidth; //!< Link bandwidth

214

  // Max avg length threshold (bytes), should be >= 2*minTh

255

  Time m_linkDelay;         //!< Link delay

215

  double m_maxTh;

216

  // Queue limit in bytes / packets

217

  uint32_t m_queueLimit;

218

  // Queue weight given to cur q size sample

219

  double m_qW;

220

  // The max probability of dropping a packet

221

  double m_lInterm;

222

  // Ns-1 compatibility

223

  bool m_isNs1Compat;

224

  // Link bandwidth

225

  DataRate m_linkBandwidth;

226

  // Link delay

227

  Time m_linkDelay;

228

256

229

  // ** Variables maintained by RED

257

  // ** Variables maintained by RED

230

  // Prob. of packet drop before "count"

258

  double m_vProb1;          //!< Prob. of packet drop before "count"

231

  double m_vProb1;

259

  double m_vA;              //!< 1.0 / (m_maxTh - m_minTh)

232

  // v_prob = v_a * v_ave + v_b

260

  double m_vB;              //!< -m_minTh / (m_maxTh - m_minTh)

233

  double m_vA;

261

  double m_vC;              //!< (1.0 - m_curMaxP) / m_maxTh - used in "gentle" mode

234

  double m_vB;

262

  double m_vD;              //!< 2.0 * m_curMaxP - 1.0 - used in "gentle" mode

235

  // Used for "gentle" mode

263

  double m_curMaxP;         //!< Current max_p

236

  double m_vC;

264

  double m_vProb;           //!< Prob. of packet drop

237

  // Used for "gentle" mode

265

  uint32_t m_countBytes;    //!< Number of bytes since last drop

238

  double m_vD;

266

  uint32_t m_old;           //!< 0 when average queue first exceeds threshold

239

  // Current max_p

267

  uint32_t m_idle;          //!< 0/1 idle status

240

  double m_curMaxP;

268

  double m_ptc;             //!< packet time constant in packets/second

241

  // Prob. of packet drop

269

  double m_qAvg;            //!< Average queue length

242

  double m_vProb;

270

  uint32_t m_count;         //!< Number of packets since last random number generation

243

  // # of bytes since last drop

271

/**

244

  uint32_t m_countBytes;

245

  // 0 when average queue first exceeds thresh

246

  uint32_t m_old;

247

  // 0/1 idle status

248

  uint32_t m_idle;

249

  // packet time constant in packets/second

250

  double m_ptc;

251

  // Average queue length

252

  double m_qAvg;

253

  // number of packets since last random number generation

254

  uint32_t m_count;

255

/*

256

   * 0 for default RED

272

   * 0 for default RED

257

   * 1 experimental (see red-queue.cc)

273

   * 1 experimental (see red-queue.cc)

258

   * 2 experimental (see red-queue.cc)

274

   * 2 experimental (see red-queue.cc)

259

   * 3 use Idle packet size in the ptc

275

   * 3 use Idle packet size in the ptc

260

*/

276

*/

261

  uint32_t m_cautious;

277

  uint32_t m_cautious;

262

  // Start of current idle period

278

  Time m_idleTime;          //!< Start of current idle period

263

  Time m_idleTime;

264

279

265

  Ptr<UniformRandomVariable> m_uv;

280

  Ptr<UniformRandomVariable> m_uv;  //!< rng stream

266

};

281

};

267

282

268

}; // namespace ns3

283

}; // namespace ns3

(-)a/src/network/utils/sequence-number.h (-2 / +91 lines)

Lines 341-367	Link Here

341

  friend std::istream & operator >> (std::istream &is, const SequenceNumber<NUMERIC_TYPE2, SIGNED_TYPE2> &val);

341

  friend std::istream & operator >> (std::istream &is, const SequenceNumber<NUMERIC_TYPE2, SIGNED_TYPE2> &val);

342

343

private: // unimplemented operators

343

private: // unimplemented operators

344

/**

345

   * \brief Plus equals operator - unimplemented

346

   * \param value value

347

   * \returns sequence number

348

*/

344

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& operator+= (SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> const &value);

349

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& operator+= (SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> const &value);

350

/**

351

   * \brief Minus equals operator - unimplemented

352

   * \param value value

353

   * \returns sequence number

354

*/

345

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& operator-= (SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> const &value);

355

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& operator-= (SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> const &value);

356

/**

357

   * \brief Multiplication operator - unimplemented

358

   * \param b value

359

   * \returns sequence number

360

*/

346

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator* (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

361

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator* (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

362

/**

363

   * \brief Division operator - unimplemented

364

   * \param b value

365

   * \returns sequence number

366

*/

347

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator/ (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

367

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator/ (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

368

/**

369

   * \brief Modulo operator - unimplemented

370

   * \param b value

371

   * \returns sequence number

372

*/

348

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator% (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

373

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator% (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

374

/**

375

   * \brief Logical NOT operator - unimplemented

376

   * \returns condition

377

*/

349

  bool operator ! () const;

378

  bool operator ! () const;

379

/**

380

   * \brief Logical AND operator - unimplemented

381

   * \param b value

382

   * \returns condition

383

*/

350

  bool operator && (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

384

  bool operator && (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

385

/**

386

   * \brief Logical OR operator - unimplemented

387

   * \param b value

388

   * \returns condition

389

*/

351

  bool operator || (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

390

  bool operator || (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

391

/**

392

   * \brief Bitwise NOT operator - unimplemented

393

   * \returns sequence number

394

*/

352

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator~ () const;

395

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator~ () const;

396

/**

397

   * \brief Bitwise AND operator - unimplemented

398

   * \param b value

399

   * \returns sequence number

400

*/

353

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator& (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

401

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator& (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

402

/**

403

   * \brief Bitwise OR operator - unimplemented

404

   * \param b value

405

   * \returns sequence number

406

*/

354

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator| (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

407

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator| (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

408

/**

409

   * \brief Bitwise XOR operator - unimplemented

410

   * \param b value

411

   * \returns sequence number

412

*/

355

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator^ (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

413

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator^ (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

414

/**

415

   * \brief Bitwise left shift operator - unimplemented

416

   * \param b value

417

   * \returns sequence number

418

*/

356

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator<< (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

419

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator<< (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

420

/**

421

   * \brief Bitwise right shift operator - unimplemented

422

   * \param b value

423

   * \returns sequence number

424

*/

357

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator>> (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

425

  SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> operator>> (const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>& b) const;

426

/**

427

   * \brief Indirection operator - unimplemented

428

   * \returns integer

429

*/

358

  int operator* ();

430

  int operator* ();

359

  //SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>* operator& ();

431

  //SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE>* operator& ();

360

432

361

private:

433

private:

362

  NUMERIC_TYPE m_value;

434

  NUMERIC_TYPE m_value; //!< Sequence number value

363

};

435

};

364

436

437

438

/**

439

 * \brief Stream insertion operator.

440

441

 * \param os the stream

442

 * \param val the value

443

 * \returns a reference to the stream

444

*/

365

template<typename NUMERIC_TYPE, typename SIGNED_TYPE>

445

template<typename NUMERIC_TYPE, typename SIGNED_TYPE>

366

std::ostream &

446

std::ostream &

367

operator<< (std::ostream& os, const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> &val)

447

operator<< (std::ostream& os, const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> &val)

Lines 370-375	Link Here

370

  return os;

450

  return os;

371

451

372

452

453

454

/**

455

 * \brief Stream extraction operator.

456

457

 * \param is the stream

458

 * \param val the value

459

 * \returns a reference to the stream

460

*/

373

template<typename NUMERIC_TYPE, typename SIGNED_TYPE>

461

template<typename NUMERIC_TYPE, typename SIGNED_TYPE>

374

std::istream & operator >> (std::istream &is, const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> &val)

462

std::istream & operator >> (std::istream &is, const SequenceNumber<NUMERIC_TYPE, SIGNED_TYPE> &val)

375

463

Lines 377-384	Link Here

377

  return is;

465

  return is;

378

466

379

467

380

468

/// 32 bit Sequence number

381

typedef SequenceNumber<uint32_t, int32_t> SequenceNumber32;

469

typedef SequenceNumber<uint32_t, int32_t> SequenceNumber32;

470

/// 16 bit Sequence number

382

typedef SequenceNumber<uint16_t, int16_t> SequenceNumber16;

471

typedef SequenceNumber<uint16_t, int16_t> SequenceNumber16;

383

472

384

} // namespace ns3

473

} // namespace ns3

(-)a/src/network/utils/simple-channel.h (-1 / +5 lines)

Lines 36-41	Link Here

class SimpleChannel : public Channel

class SimpleChannel : public Channel

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  SimpleChannel ();

  SimpleChannel ();

Lines 66-72	Link Here

  virtual Ptr<NetDevice> GetDevice (uint32_t i) const;

  virtual Ptr<NetDevice> GetDevice (uint32_t i) const;

private:

private:

  std::vector<Ptr<SimpleNetDevice> > m_devices;

  std::vector<Ptr<SimpleNetDevice> > m_devices; //!< devices connected by the channel

};

};

} // namespace ns3

} // namespace ns3




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


protected:
  virtual void DoDispose (void);
private:
  Ptr<SimpleChannel> m_channel; //!< the channel the device is connected to
  NetDevice::ReceiveCallback m_rxCallback; //!< Receive callback
  NetDevice::PromiscReceiveCallback m_promiscCallback; //!< Promiscuous receive callback
  Ptr<Node> m_node; //!< Node this netDevice is associated to
  uint16_t m_mtu;   //!< MTU
  uint32_t m_ifIndex; //!< Interface index
  Mac48Address m_address; //!< MAC address
  Ptr<ErrorModel> m_receiveErrorModel; //!< Receive error model.
  /**
   * The trace source fired when the phy layer drops a packet it has received
   * due to the error model being active.  Although SimpleNetDevice doesn't 

Return to bug 938