packet_format.tex

柯老师网站上找到的

%
% personal commentary:
%        DRAFT DRAFT DRAFT
%        - KFALL
%
\section{\shdr{Packet Headers and Formats}{packet.h}{sec:pformat}}

Objects of the class \code{Packet} are the fundamental unit of
exchange between objects in the simulation.
The \code{Packet} class provides enough information to
link a packet on to a list (i.e. in a \code{PacketQueue} or on a free
list of packets), refer to a buffer containing packet headers
which are defined on a per-protocol basis, and to refer to a buffer
of packet data.
New protocols may define their own packet headers or may extend
existing headers with additional fields.

New packet headers are introduced into the simulator
by defining a C++ structure with the needed
fields, defining a static class to provide
OTcl linkage, and then modifying some of the simulator initialization
code to assign a byte offset in each packet where the new header
is to be located relative to others.

When the simulator is initialized through OTcl,
a user may choose to enable
only a subset of the compiled-in packet formats, resulting in
a modest savings of memory during the execution of the simulation.
Presently, all configured-in packet formats are enabled.
The management of which packet formats are currently enabled
in a simulation is handled by a special packet header manager
object described below.
This object supports an OTcl method used to specify
which packet headers will be used in a simulation.
If an object in the simulator makes use of a field in a header
which has not been enabled, a run-time fatal program abort occurs.

\subsection{\shdr{A Protocol-Specific Packet Header}{rtp.h}{sec:ppackethdr}}

Protocol developers
will often wish to provide a specific header type to be used in packets.
Doing so allows a new protocol implementation
to avoid overloading already-existing header fields.
We consider a simplified version of RTP as an example.
The RTP header will require a sequence number fields and a source
identifier field.
The following classes create the needed header
(see \code{rtp.h} and \code{rtp.cc}):
\begin{small}
\begin{verbatim}
From rtp.h:
	/* rtp packet.  For now, just have srcid + seqno. */
	struct hdr_rtp { 
		u_int32_t srcid_;
		int seqno_;
		/* per-field member functions */
		u_int32_t& srcid() { return (srcid_); }
		int& seqno() { return (seqno_); }
	};   


From rtp.cc:
	class RTPAgent: public CBR_Agent {
	...
		int off_rtp_;
	};

	class RTPHeaderClass : public PacketHeaderClass {
	public: 
		RTPHeaderClass() : PacketHeaderClass("PacketHeader/RTP",
						     sizeof(hdr_rtp)) {}
	} class_rtphdr;

	void RTPAgent::sendpkt()
	{
		Packet* p = allocpkt();
		hdr_rtp *rh = (hdr_rtp*)p->access(off_rtp_);
		lastpkttime_ = Scheduler::instance().clock();

		/* Fill in srcid_ and seqno */
		rh->seqno() = seqno_++;
		rh->srcid() = session_->srcid();
		target_->recv(p, 0);
	}

	RTPAgent::RTPAgent()
		: session_(0), lastpkttime_(-1e6)
	{
		type_ = PT_RTP;
		bind("seqno_", &seqno_);
		bind("off_rtp_", &off_rtp_);
	}


\end{verbatim}
\end{small}
The first structure defines the layout (in terms of words and their
placement): which fields are needed and how big they are.
This structure definition is only used by the
compiler to compute byte offsets of fields;
no objects of this structure type are ever directly allocated.
The structure also provides member functions
which in turn
provide a layer of data hiding for objects wishing to read
or modify header fields of packets.
Note that the variable \code{off_rtp_} is used
to find the byte offset at which the rtp header is located
in an arbitrary packet.
To access any packet header other than the ``common'' header
(see below, section\ref{sec:commonhdr}), the accessing code
must obtain the appropriate header offset.
This is accomplished by declaring and binding
the integer variable \code{off_<hdrname>_}
where \code{<hdrname>} refers to a shorthand name
of the header of interest which must match the
name assigned in \code{tcl/lib/ns-packet.tcl}.
This is performed above by the RTPAgent's constructor.
Generally, one header object for each type of header
in the simulation is instantiated at simulator run-time.
A particular header is enabled via OTcl in the simulation during
simulator configuration time (see \ref{sec:configpacket}).

The static object \code{class_rtphdr} of class \code{RTPHeaderClass}
is used to provide linkage to OTcl when the RTP header is
enabled at configuration time.
When the simulator executes, this static object calls
the \code{PacketHeaderClass} constructor with arguments
\code{"PacketHeader/RTP"} and \code{sizeof(hdr_rtp}.
This causes the size of the RTP header to be stored
and made available to the packet header manager
at configuration time (see below, section\ref{sec:packethdrmgr}).

The sample member function \code{sendpkt()}
of \code{RTPAgent} creates a new packet
to send by calling \code{allocpkt()}, which handles assignment
of all the network-layer packet header fields (in this case, IP).
Headers other than IP are handled separately.
In this case, the agent uses the \code{RTPHeader} defined above.
The \code{Packet::access()} member function returns the address
of the first byte in a buffer used to hold header information (see below).
Its return value is cast as a pointer to the header of interest,
after which member functions of the \code{RTPHeader}
object are used to access individual fields.

\subsubsection{adding a new packet header type}

Assuming we wish to create a new header called \code{newhdr}
the following steps are performed:
\begin{enumerate}
        \item create a new structure defining the raw fields (called \code{hdr_newhdr})
        \item define member functions for needed fields
	\item create a static class to perform OTcl linkage (defines \code{PacketHeader/Newhdr})
        \item edit \code{tcl/lib/ns-packet.tcl} to enable new packet format (see \ref{sec:configpacket})
\end{enumerate}

\subsection{\shdr{Packet Classes}{packet.h}{sec:packetclasses}}

There are three C++ classes relevant to the handling of packets
and packet headers in general: \code{Packet},
\code{PacketHeader}, and \code{PacketHeaderManager}.
The \code{Packet} class defines the type for all packets in the
simulation; it is a subclass of \code{Event} so that packets may
be scheduled (e.g.~for later arrival at some queue).
The \code{PacketHeader} class provides a base class for
any packet header configured into the simulation.
It essentially provides 
enough internal state to locate any particular packet
header in the collection of packet headers present in any given packet.
The \code{PacketHeaderManager} defines a class used to collect
and manage currently-configured headers.
It is invoked by a method available to OTcl at simulation configuration
time to enable some subset of the compiled-in packet headers.

\begin{figure}[h]
\centerline{\psfig{figure=packet.eps,width=4in}}
\caption{\label{pic:packet}A Packet Object}
\end{figure}

\subsubsection{\shdr{the Packet class}{packet.h}{sec:packetclass}}

The \code{Packet} class defines the structure of a
packet and provides member functions to handle a
free list for objects of this type.
It is illustrated in Figure~\ref{pic:packet} and
defined as follows in \code{packet.h}:
\begin{small}
\begin{verbatim}
	class Packet : public Event {
	private:
		friend class PacketQueue;
		u_char* bits_;  
		u_char* data_;  // variable size buffer for 'data'
		u_int datalen_; // length of variable size buffer
	protected:
		static Packet* free_;
	public: 
		Packet* next_;  // for queues and the free list
		static int hdrlen_;
		Packet() : bits_(0), datalen_(0), next_(0) { }
		u_char* const bits() { return (bits_); }
		Packet* copy() const;
		static Packet* alloc();
		static Packet* alloc(int);
		inline void allocdata(int);
		static void free(Packet*);
		inline u_char* access(int off) { if (off < 0) abort(); return (&bits_[of
	f]); }  
		inline u_char* accessdata() {return data_;}
	};

\end{verbatim}
\end{small}
This class holds a pointer to a generic array of unsigned
characters (commonly called the ``bag of bits'' or BOB for short)
where packet header fields are stored.
It also holds a pointer to packet ``data'' (which is often not used in
simulations).
The \code{bits_} variable contains the address of
the first byte of the BOB.
Effectively BOB is (currently implemented as) a concatenation
of all the structures defined for each packet header (by convention,
the structures with names beginning \code{hdr_<something>}) that have
been configured in.
BOB generally remains a fixed size throughout a simulation, and
the size is recorded in the \code{Packet::hdrlen_} member
variable.
This size is updated during simulator configuration by
OTcl.\footnote{It is not intended to be updated after configuration
time.  Doing so {\em should} be possible, but is currently untested.}

The other methods of the \code{Packet} class are for creating new
packets and storing old (unused) ones on a private free list.
Such allocation and deallocation is performed by the
following code (in \code{packet.h}):
\begin{small}