开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
packet.h
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：22k
源码类别：

通讯编程

开发平台：

Visual C++

packet.h：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  * This product includes software developed by the Computer Systems
  17.  * Engineering Group at Lawrence Berkeley Laboratory.
  18.  * 4. Neither the name of the University nor of the Laboratory may be used
  19.  *    to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  *
  34.  * @(#) $Header: /cvsroot/nsnam/ns-2/common/packet.h,v 1.102 2008/02/18 03:39:02 tom_henderson Exp $ (LBL)
  35.  */
  37. #ifndef ns_packet_h
  38. #define ns_packet_h
  40. #include <string.h>
  41. #include <assert.h>
  43. #include "config.h"
  44. #include "scheduler.h"
  45. #include "object.h"
  46. #include "lib/bsd-list.h"
  47. #include "packet-stamp.h"
  48. #include "ns-process.h"
  50. // Used by wireless routing code to attach routing agent
  51. #define RT_PORT 255 /* port that all route msgs are sent to */
  53. #define HDR_CMN(p)      (hdr_cmn::access(p))
  54. #define HDR_ARP(p)      (hdr_arp::access(p))
  55. #define HDR_MAC(p)      (hdr_mac::access(p))
  56. #define HDR_MAC802_11(p) ((hdr_mac802_11 *)hdr_mac::access(p))
  57. #define HDR_MAC_TDMA(p) ((hdr_mac_tdma *)hdr_mac::access(p))
  58. #define HDR_SMAC(p)     ((hdr_smac *)hdr_mac::access(p))
  59. #define HDR_LL(p)       (hdr_ll::access(p))
  60. #define HDR_HDLC(p)     ((hdr_hdlc *)hdr_ll::access(p))
  61. #define HDR_IP(p)       (hdr_ip::access(p))
  62. #define HDR_RTP(p)      (hdr_rtp::access(p))
  63. #define HDR_TCP(p)      (hdr_tcp::access(p))
  64. #define HDR_SCTP(p)     (hdr_sctp::access(p))
  65. #define HDR_SR(p)       (hdr_sr::access(p))
  66. #define HDR_TFRC(p)     (hdr_tfrc::access(p))
  67. #define HDR_TORA(p)     (hdr_tora::access(p))
  68. #define HDR_IMEP(p)     (hdr_imep::access(p))
  69. #define HDR_CDIFF(p)    (hdr_cdiff::access(p))  /* chalermak's diffusion*/
  70. //#define HDR_DIFF(p)     (hdr_diff::access(p))  /* SCADD's diffusion ported into ns */
  71. #define HDR_LMS(p) (hdr_lms::access(p))
  73. /* --------------------------------------------------------------------*/
  75. /*
  76.  * modified ns-2.33, adding support for dynamic libraries
  77.  * 
  78.  * packet_t is changed from enum to unsigned int in order to allow
  79.  * dynamic definition of  new packet types within dynamic libraries.
  80.  * Pre-defined packet types are implemented as static const.
  81.  * 
  82.  */
  84. typedef unsigned int packet_t;
  86. static const packet_t PT_TCP = 0;
  87. static const packet_t PT_UDP = 1;
  88. static const packet_t PT_CBR = 2;
  89. static const packet_t PT_AUDIO = 3;
  90. static const packet_t PT_VIDEO = 4;
  91. static const packet_t PT_ACK = 5;
  92. static const packet_t PT_START = 6;
  93. static const packet_t PT_STOP = 7;
  94. static const packet_t PT_PRUNE = 8;
  95. static const packet_t PT_GRAFT = 9;
  96. static const packet_t PT_GRAFTACK = 10;
  97. static const packet_t PT_JOIN = 11;
  98. static const packet_t PT_ASSERT = 12;
  99. static const packet_t PT_MESSAGE = 13;
  100. static const packet_t PT_RTCP = 14;
  101. static const packet_t PT_RTP = 15;
  102. static const packet_t PT_RTPROTO_DV = 16;
  103. static const packet_t PT_CtrMcast_Encap = 17;
  104. static const packet_t PT_CtrMcast_Decap = 18;
  105. static const packet_t PT_SRM = 19;
  106.         /* simple signalling messages */
  107. static const packet_t PT_REQUEST = 20;
  108. static const packet_t PT_ACCEPT = 21;
  109. static const packet_t PT_CONFIRM = 22;
  110. static const packet_t PT_TEARDOWN = 23;
  111. static const packet_t PT_LIVE = 24;   // packet from live network
  112. static const packet_t PT_REJECT = 25;
  114. static const packet_t PT_TELNET = 26; // not needed: telnet use TCP
  115. static const packet_t PT_FTP = 27;
  116. static const packet_t PT_PARETO = 28;
  117. static const packet_t PT_EXP = 29;
  118. static const packet_t PT_INVAL = 30;
  119. static const packet_t PT_HTTP = 31;
  121.         /* new encapsulator */
  122. static const packet_t PT_ENCAPSULATED = 32;
  123. static const packet_t PT_MFTP = 33;
  125.         /* CMU/Monarch's extnsions */
  126. static const packet_t PT_ARP = 34;
  127. static const packet_t PT_MAC = 35;
  128. static const packet_t PT_TORA = 36;
  129. static const packet_t PT_DSR = 37;
  130. static const packet_t PT_AODV = 38;
  131. static const packet_t PT_IMEP = 39;
  132.         
  133.         // RAP packets
  134. static const packet_t PT_RAP_DATA = 40;
  135. static const packet_t PT_RAP_ACK = 41;
  136.   
  137. static const packet_t PT_TFRC = 42;
  138. static const packet_t PT_TFRC_ACK = 43;
  139. static const packet_t PT_PING = 44;
  140.         
  141. static const packet_t PT_PBC = 45;
  142.         // Diffusion packets - Chalermek
  143. static const packet_t PT_DIFF = 46;
  144.         
  145.         // LinkState routing update packets
  146. static const packet_t PT_RTPROTO_LS = 47;
  147.         
  148.         // MPLS LDP header
  149. static const packet_t PT_LDP = 48;
  150.         
  151.         // GAF packet
  152. static const packet_t PT_GAF = 49;
  153.         
  154.         // ReadAudio traffic
  155. static const packet_t PT_REALAUDIO = 50;
  156.         
  157.         // Pushback Messages
  158. static const packet_t PT_PUSHBACK = 51;
  159.   
  160.   #ifdef HAVE_STL
  161.         // Pragmatic General Multicast
  162. static const packet_t PT_PGM = 52;
  163.   #endif //STL
  164.         // LMS packets
  165. static const packet_t PT_LMS = 53;
  166. static const packet_t PT_LMS_SETUP = 54;
  168. static const packet_t PT_SCTP = 55;
  169. static const packet_t PT_SCTP_APP1 = 56;
  171.         // SMAC packet
  172. static const packet_t PT_SMAC = 57;
  173.         // XCP packet
  174. static const packet_t PT_XCP = 58;
  176.         // HDLC packet
  177. static const packet_t PT_HDLC = 59;
  179.         // Bell Labs Traffic Trace Type (PackMime OL)
  180. static const packet_t PT_BLTRACE = 60;
  182.         // insert new packet types here
  183. static packet_t       PT_NTYPE = 61; // This MUST be the LAST one
  185. enum packetClass
  186. {
  187. UNCLASSIFIED,
  188. ROUTING,
  189. DATApkt
  190.   };
  193. /*
  194.  * ns-2.33 adding support for dynamic libraries
  195.  * 
  196.  * The PacketClassifier class is needed to make
  197.  * p_info::data_packet(packet_t) work also with dynamically defined
  198.  * packet types.
  199.  * 
  200.  */
  201. class PacketClassifier
  202. {
  203. public:
  204. PacketClassifier(): next_(0){}
  205. virtual ~PacketClassifier() {}
  206. void setNext(PacketClassifier *next){next_ = next;}
  207. PacketClassifier *getNext(){return next_;}
  208. packetClass classify(packet_t type) 
  209. {
  210.         packetClass c = getClass(type);
  211.         if(c == UNCLASSIFIED && next_)
  212.                 c = next_->classify(type);
  213.         return c;
  214. }
  216. protected:
  217. //return 0 if the packet is unknown
  218. virtual packetClass getClass(packet_t type) = 0;        
  219. PacketClassifier *next_;
  220. };
  222. class p_info {
  223. public:
  224. p_info()
  225. {
  226. initName();
  227. }
  228. const char* name(packet_t p) const { 
  229. if ( p <= p_info::nPkt_ ) return name_[p];
  230. return 0;
  231. }
  232. static bool data_packet(packet_t type) {
  233. return ( (type) == PT_TCP || 
  234.          (type) == PT_TELNET || 
  235.          (type) == PT_CBR || 
  236.          (type) == PT_AUDIO || 
  237.          (type) == PT_VIDEO || 
  238.          (type) == PT_ACK || 
  239.          (type) == PT_SCTP || 
  240.          (type) == PT_SCTP_APP1 || 
  241.          (type) == PT_HDLC 
  242.         );
  243. }
  244. static packetClass classify(packet_t type) {
  245. if (type == PT_DSR || 
  246.     type == PT_MESSAGE || 
  247.     type == PT_TORA || 
  248.     type == PT_AODV)
  249. return ROUTING;
  250. if (type == PT_TCP || 
  251.     type == PT_TELNET || 
  252.     type == PT_CBR || 
  253.     type == PT_AUDIO || 
  254.     type == PT_VIDEO || 
  255.     type == PT_ACK || 
  256.     type == PT_SCTP || 
  257.     type == PT_SCTP_APP1 || 
  258.     type == PT_HDLC)
  259. return DATApkt;
  260. if (pc_)
  261. return pc_->classify(type);
  262. return UNCLASSIFIED;
  263. }
  264. static void addPacketClassifier(PacketClassifier *pc)
  265. {
  266. if(!pc)
  267.         return;
  268. pc->setNext(pc_);
  269. pc_ = pc;
  270. }       
  271. static void initName()
  272. {
  273. if(nPkt_ >= PT_NTYPE+1)
  274.         return;
  275. char **nameNew = new char*[PT_NTYPE+1];
  276. for(unsigned int i = (unsigned int)PT_SMAC+1; i < nPkt_; i++)
  277. {
  278.         nameNew[i] = name_[i];
  279. }
  280. if(!nPkt_)
  281.         delete [] name_;
  282. name_ = nameNew;
  283. nPkt_ = PT_NTYPE+1;
  286. name_[PT_TCP]= "tcp";
  287. name_[PT_UDP]= "udp";
  288. name_[PT_CBR]= "cbr";
  289. name_[PT_AUDIO]= "audio";
  290. name_[PT_VIDEO]= "video";
  291. name_[PT_ACK]= "ack";
  292. name_[PT_START]= "start";
  293. name_[PT_STOP]= "stop";
  294. name_[PT_PRUNE]= "prune";
  295. name_[PT_GRAFT]= "graft";
  296. name_[PT_GRAFTACK]= "graftAck";
  297. name_[PT_JOIN]= "join";
  298. name_[PT_ASSERT]= "assert";
  299. name_[PT_MESSAGE]= "message";
  300. name_[PT_RTCP]= "rtcp";
  301. name_[PT_RTP]= "rtp";
  302. name_[PT_RTPROTO_DV]= "rtProtoDV";
  303. name_[PT_CtrMcast_Encap]= "CtrMcast_Encap";
  304. name_[PT_CtrMcast_Decap]= "CtrMcast_Decap";
  305. name_[PT_SRM]= "SRM";
  307. name_[PT_REQUEST]= "sa_req";
  308. name_[PT_ACCEPT]= "sa_accept";
  309. name_[PT_CONFIRM]= "sa_conf";
  310. name_[PT_TEARDOWN]= "sa_teardown";
  311. name_[PT_LIVE]= "live"; 
  312. name_[PT_REJECT]= "sa_reject";
  314. name_[PT_TELNET]= "telnet";
  315. name_[PT_FTP]= "ftp";
  316. name_[PT_PARETO]= "pareto";
  317. name_[PT_EXP]= "exp";
  318. name_[PT_INVAL]= "httpInval";
  319. name_[PT_HTTP]= "http";
  320. name_[PT_ENCAPSULATED]= "encap";
  321. name_[PT_MFTP]= "mftp";
  322. name_[PT_ARP]= "ARP";
  323. name_[PT_MAC]= "MAC";
  324. name_[PT_TORA]= "TORA";
  325. name_[PT_DSR]= "DSR";
  326. name_[PT_AODV]= "AODV";
  327. name_[PT_IMEP]= "IMEP";
  329. name_[PT_RAP_DATA] = "rap_data";
  330. name_[PT_RAP_ACK] = "rap_ack";
  332.   name_[PT_TFRC]= "tcpFriend";
  333. name_[PT_TFRC_ACK]= "tcpFriendCtl";
  334. name_[PT_PING]="ping";
  336. name_[PT_PBC] = "PBC";
  338.   /* For diffusion : Chalermek */
  339.   name_[PT_DIFF] = "diffusion";
  341. // Link state routing updates
  342. name_[PT_RTPROTO_LS] = "rtProtoLS";
  344. // MPLS LDP packets
  345. name_[PT_LDP] = "LDP";
  347. // for GAF
  348.                 name_[PT_GAF] = "gaf";      
  350. // RealAudio packets
  351. name_[PT_REALAUDIO] = "ra";
  353. //pushback 
  354. name_[PT_PUSHBACK] = "pushback";
  356. #ifdef HAVE_STL
  357. // for PGM
  358. name_[PT_PGM] = "PGM";
  359. #endif //STL
  361. // LMS entries
  362. name_[PT_LMS]="LMS";
  363. name_[PT_LMS_SETUP]="LMS_SETUP";
  365. name_[PT_SCTP]= "sctp";
  366.   name_[PT_SCTP_APP1] = "sctp_app1";
  368. // smac
  369. name_[PT_SMAC]="smac";
  371. // HDLC
  372. name_[PT_HDLC]="HDLC";
  374. // XCP
  375. name_[PT_XCP]="xcp";
  377. // Bell Labs (PackMime OL)
  378. name_[PT_BLTRACE]="BellLabsTrace";
  380. name_[PT_NTYPE]= "undefined";
  381. }
  382. static int addPacket(char *name);
  383. static packet_t getType(const char *name)
  384. {
  385. for(unsigned int i = 0; i < nPkt_; i++)
  386. {
  387.         if(strcmp(name, name_[i]) == 0)
  388.                 return i;
  389. }
  390. return PT_NTYPE;
  392. }
  393. private:
  394. static char** name_;
  395. static unsigned int nPkt_;
  396. static PacketClassifier *pc_;
  397. };
  398. extern p_info packet_info; /* map PT_* to string name */
  399. //extern char* p_info::name_[];
  401. #define DATA_PACKET(type) ( (type) == PT_TCP || 
  402.                             (type) == PT_TELNET || 
  403.                             (type) == PT_CBR || 
  404.                             (type) == PT_AUDIO || 
  405.                             (type) == PT_VIDEO || 
  406.                             (type) == PT_ACK || 
  407.                             (type) == PT_SCTP || 
  408.                             (type) == PT_SCTP_APP1 
  409.                             )
  411. //#define OFFSET(type, field) ((long) &((type *)0)->field)
  412. #define OFFSET(type, field) ( (char *)&( ((type *)256)->field )  - (char *)256)
  414. class PacketData : public AppData {
  415. public:
  416. PacketData(int sz) : AppData(PACKET_DATA) {
  417. datalen_ = sz;
  418. if (datalen_ > 0)
  419. data_ = new unsigned char[datalen_];
  420. else
  421. data_ = NULL;
  422. }
  423. PacketData(PacketData& d) : AppData(d) {
  424. datalen_ = d.datalen_;
  425. if (datalen_ > 0) {
  426. data_ = new unsigned char[datalen_];
  427. memcpy(data_, d.data_, datalen_);
  428. } else
  429. data_ = NULL;
  430. }
  431. virtual ~PacketData() { 
  432. if (data_ != NULL) 
  433. delete []data_; 
  434. }
  435. unsigned char* data() { return data_; }
  437. virtual int size() const { return datalen_; }
  438. virtual AppData* copy() { return new PacketData(*this); }
  439. private:
  440. unsigned char* data_;
  441. int datalen_;
  442. };
  444. //Monarch ext
  445. typedef void (*FailureCallback)(Packet *,void *);
  447. class Packet : public Event {
  448. private:
  449. unsigned char* bits_; // header bits
  450. // unsigned char* data_; // variable size buffer for 'data'
  451. //   unsigned int datalen_; // length of variable size buffer
  452. AppData* data_; // variable size buffer for 'data'
  453. static void init(Packet*);     // initialize pkt hdr 
  454. bool fflag_;
  455. protected:
  456. static Packet* free_; // packet free list
  457. int ref_count_; // free the pkt until count to 0
  458. public:
  459. Packet* next_; // for queues and the free list
  460. static int hdrlen_;
  462. Packet() : bits_(0), data_(0), ref_count_(0), next_(0) { }
  463. inline unsigned char* const bits() { return (bits_); }
  464. inline Packet* copy() const;
  465. inline Packet* refcopy() { ++ref_count_; return this; }
  466. inline int& ref_count() { return (ref_count_); }
  467. static inline Packet* alloc();
  468. static inline Packet* alloc(int);
  469. inline void allocdata(int);
  470. // dirty hack for diffusion data
  471. inline void initdata() { data_  = 0;}
  472. static inline void free(Packet*);
  473. inline unsigned char* access(int off) const {
  474. if (off < 0)
  475. abort();
  476. return (&bits_[off]);
  477. }
  478. // This is used for backward compatibility, i.e., assuming user data
  479. // is PacketData and return its pointer.
  480. inline unsigned char* accessdata() const { 
  481. if (data_ == 0)
  482. return 0;
  483. assert(data_->type() == PACKET_DATA);
  484. return (((PacketData*)data_)->data()); 
  485. }
  486. // This is used to access application-specific data, not limited 
  487. // to PacketData.
  488. inline AppData* userdata() const {
  489. return data_;
  490. }
  491. inline void setdata(AppData* d) { 
  492. if (data_ != NULL)
  493. delete data_;
  494. data_ = d; 
  495. }
  496. inline int datalen() const { return data_ ? data_->size() : 0; }
  498. // Monarch extn
  500. static void dump_header(Packet *p, int offset, int length);
  502. // the pkt stamp carries all info about how/where the pkt
  503.         // was sent needed for a receiver to determine if it correctly
  504.         // receives the pkt
  505.         PacketStamp txinfo_;  
  507. /*
  508.          * According to cmu code:
  509.  * This flag is set by the MAC layer on an incoming packet
  510.          * and is cleared by the link layer.  It is an ugly hack, but
  511.          * there's really no other way because NS always calls
  512.          * the recv() function of an object.
  513.  * 
  514.          */
  515.         u_int8_t        incoming;
  517. //monarch extns end;
  518. };
  520. /* 
  521.  * static constant associations between interface special (negative) 
  522.  * values and their c-string representations that are used from tcl
  523.  */
  524. class iface_literal {
  525. public:
  526. enum iface_constant { 
  527. UNKN_IFACE= -1, /* 
  528.  * iface value for locally originated packets 
  529.  */
  530. ANY_IFACE= -2   /* 
  531.  * hashnode with iif == ANY_IFACE_   
  532.  * matches any pkt iface (imported from TCL);
  533.  * this value should be different from 
  534.  * hdr_cmn::UNKN_IFACE (packet.h)
  535.  */ 
  536. };
  537. iface_literal(const iface_constant i, const char * const n) : 
  538. value_(i), name_(n) {}
  539. inline int value() const { return value_; }
  540. inline const char * const name() const { return name_; }
  541. private:
  542. const iface_constant value_;
  543. /* strings used in TCL to access those special values */
  544. const char * const name_; 
  545. };
  547. static const iface_literal UNKN_IFACE(iface_literal::UNKN_IFACE, "?");
  548. static const iface_literal ANY_IFACE(iface_literal::ANY_IFACE, "*");
  550. /*
  551.  * Note that NS_AF_* doesn't necessarily correspond with
  552.  * the constants used in your system (because many
  553.  * systems don't have NONE or ILINK).
  554.  */
  555. enum ns_af_enum { NS_AF_NONE, NS_AF_ILINK, NS_AF_INET };
  557. enum ModulationScheme {BPSK = 0, QPSK = 1, QAM16 = 2, QAM64 = 3};
  559. struct hdr_cmn {
  560. enum dir_t { DOWN= -1, NONE= 0, UP= 1 };
  561. packet_t ptype_; // packet type (see above)
  562. int size_; // simulated packet size
  563. int uid_; // unique id
  564. int error_; // error flag
  565. int     errbitcnt_;     // # of corrupted bits jahn
  566. int     fecsize_;
  567. double ts_; // timestamp: for q-delay measurement
  568. int iface_; // receiving interface (label)
  569. dir_t direction_; // direction: 0=none, 1=up, -1=down
  570. // source routing 
  571.         char src_rt_valid;
  572. double ts_arr_; // Required by Marker of JOBS 
  574. //Monarch extn begins
  575. nsaddr_t prev_hop_;     // IP addr of forwarding hop
  576. nsaddr_t next_hop_; // next hop for this packet
  577. int      addr_type_;    // type of next_hop_ addr
  578. nsaddr_t last_hop_;     // for tracing on multi-user channels
  580.         // called if pkt can't obtain media or isn't ack'd. not called if
  581.         // droped by a queue
  582.         FailureCallback xmit_failure_; 
  583.         void *xmit_failure_data_;
  585.         /*
  586.          * MONARCH wants to know if the MAC layer is passing this back because
  587.          * it could not get the RTS through or because it did not receive
  588.          * an ACK.
  589.          */
  590.         int     xmit_reason_;
  591. #define XMIT_REASON_RTS 0x01
  592. #define XMIT_REASON_ACK 0x02
  594.         // filled in by GOD on first transmission, used for trace analysis
  595.         int num_forwards_; // how many times this pkt was forwarded
  596.         int opt_num_forwards_;   // optimal #forwards
  597. // Monarch extn ends;
  599. // tx time for this packet in sec
  600. double txtime_;
  601. inline double& txtime() { return(txtime_); }
  603. static int offset_; // offset for this header
  604. inline static int& offset() { return offset_; }
  605. inline static hdr_cmn* access(const Packet* p) {
  606. return (hdr_cmn*) p->access(offset_);
  607. }
  609.         /* per-field member functions */
  610. inline packet_t& ptype() { return (ptype_); }
  611. inline int& size() { return (size_); }
  612. inline int& uid() { return (uid_); }
  613. inline int& error() { return error_; }
  614. inline int& errbitcnt() {return errbitcnt_; }
  615. inline int& fecsize() {return fecsize_; }
  616. inline double& timestamp() { return (ts_); }
  617. inline int& iface() { return (iface_); }
  618. inline dir_t& direction() { return (direction_); }
  619. // monarch_begin
  620. inline nsaddr_t& next_hop() { return (next_hop_); }
  621. inline int& addr_type() { return (addr_type_); }
  622. inline int& num_forwards() { return (num_forwards_); }
  623. inline int& opt_num_forwards() { return (opt_num_forwards_); }
  624.         //monarch_end
  626. ModulationScheme mod_scheme_;
  627. inline ModulationScheme& mod_scheme() { return (mod_scheme_); }
  628. };
  631. class PacketHeaderClass : public TclClass {
  632. protected:
  633. PacketHeaderClass(const char* classname, int hdrsize);
  634. virtual int method(int argc, const char*const* argv);
  635. void field_offset(const char* fieldname, int offset);
  636. inline void bind_offset(int* off) { offset_ = off; }
  637. inline void offset(int* off) {offset_= off;}
  638. int hdrlen_; // # of bytes for this header
  639. int* offset_; // offset for this header
  640. public:
  641. virtual void bind();
  642. virtual void export_offsets();
  643. TclObject* create(int argc, const char*const* argv);
  644. };
  647. inline void Packet::init(Packet* p)
  648. {
  649. bzero(p->bits_, hdrlen_);
  650. }
  652. inline Packet* Packet::alloc()
  653. {
  654. Packet* p = free_;
  655. if (p != 0) {
  656. assert(p->fflag_ == FALSE);
  657. free_ = p->next_;
  658. assert(p->data_ == 0);
  659. p->uid_ = 0;
  660. p->time_ = 0;
  661. } else {
  662. p = new Packet;
  663. p->bits_ = new unsigned char[hdrlen_];
  664. if (p == 0 || p->bits_ == 0)
  665. abort();
  666. }
  667. init(p); // Initialize bits_[]
  668. (HDR_CMN(p))->next_hop_ = -2; // -1 reserved for IP_BROADCAST
  669. (HDR_CMN(p))->last_hop_ = -2; // -1 reserved for IP_BROADCAST
  670. p->fflag_ = TRUE;
  671. (HDR_CMN(p))->direction() = hdr_cmn::DOWN;
  672. /* setting all direction of pkts to be downward as default; 
  673.    until channel changes it to +1 (upward) */
  674. p->next_ = 0;
  675. return (p);
  676. }
  678. /* 
  679.  * Allocate an n byte data buffer to an existing packet 
  680.  * 
  681.  * To set application-specific AppData, use Packet::setdata()
  682.  */
  683. inline void Packet::allocdata(int n)
  684. {
  685. assert(data_ == 0);
  686. data_ = new PacketData(n);
  687. if (data_ == 0)
  688. abort();
  689. }
  691. /* allocate a packet with an n byte data buffer */
  692. inline Packet* Packet::alloc(int n)
  693. {
  694. Packet* p = alloc();
  695. if (n > 0) 
  696. p->allocdata(n);
  697. return (p);
  698. }
  701. inline void Packet::free(Packet* p)
  702. {
  703. if (p->fflag_) {
  704. if (p->ref_count_ == 0) {
  705. /*
  706.  * A packet's uid may be < 0 (out of a event queue), or
  707.  * == 0 (newed but never gets into the event queue.
  708.  */
  709. assert(p->uid_ <= 0);
  710. // Delete user data because we won't need it any more.
  711. if (p->data_ != 0) {
  712. delete p->data_;
  713. p->data_ = 0;
  714. }
  715. init(p);
  716. p->next_ = free_;
  717. free_ = p;
  718. p->fflag_ = FALSE;
  719. } else {
  720. --p->ref_count_;
  721. }
  722. }
  723. }
  725. inline Packet* Packet::copy() const
  726. {
  728. Packet* p = alloc();
  729. memcpy(p->bits(), bits_, hdrlen_);
  730. if (data_) 
  731. p->data_ = data_->copy();
  732. p->txinfo_.init(&txinfo_);
  733.  
  734. return (p);
  735. }
  737. inline void
  738. Packet::dump_header(Packet *p, int offset, int length)
  739. {
  740.         assert(offset + length <= p->hdrlen_);
  741.         struct hdr_cmn *ch = HDR_CMN(p);
  743.         fprintf(stderr, "nPacket ID: %dn", ch->uid());
  745.         for(int i = 0; i < length ; i+=16) {
  746.                 fprintf(stderr, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02xn",
  747.                         p->bits_[offset + i],     p->bits_[offset + i + 1],
  748.                         p->bits_[offset + i + 2], p->bits_[offset + i + 3],
  749.                         p->bits_[offset + i + 4], p->bits_[offset + i + 5],
  750.                         p->bits_[offset + i + 6], p->bits_[offset + i + 7],
  751.                         p->bits_[offset + i + 8], p->bits_[offset + i + 9],
  752.                         p->bits_[offset + i + 10], p->bits_[offset + i + 11],
  753.                         p->bits_[offset + i + 12], p->bits_[offset + i + 13],
  754.                         p->bits_[offset + i + 14], p->bits_[offset + i + 15]);
  755.         }
  756. }
  758. #endif