root / otg / trunk / src / cpp / packet.h

#include <string.h>
#ifndef OTG_PACKET_H
#define OTG_PACKET_H

/**An auxillary class for binding some measurements with the packet.
 * Currently, we list all possible TX parameters here
 */
class SendParam
{
 public:
   SendParam();
 private:
     
   int txpower_; ///< dbm, rounded to integer      
   short channel_; ///< wireless channel number in 802.11 a/b/g (optional) (for wireless use)
   short streamid_;  ///<the stream id
   long seqnum_;     ///< sequence number attached by the stream
   double txtime_;  ///<transmit timing in milliseconds      
   long mactxtime_; ///<this parameter is set by the driver to show when the packet is delivered, in microseconds
   long tcp_seqno_;  /// the Sequence number in TCP header TCP port's sequence number if TCP Port is used to sent.
   short txport_;
   short txrate_;    ///The channel rate used by the sender (optional) (for wireless use)
   char *senderaddr_; ///IP address of the sender
   char *sendermac_;  /// MAC address of the sender
 
 public:
   inline short getStreamId(){return streamid_;}
   inline void setStreamId(short i){streamid_ = i;}
   inline unsigned long getStreamSequenceNum(){return seqnum_;}
   inline void setStreamSequenceNum(unsigned long i){seqnum_ = i;}
   inline void setTxTime(double ms){ txtime_ = ms; }
   inline double getTxTime(){return txtime_;}
   inline void setSenderName(char *str){ strcpy(senderaddr_,str); }
   inline char* getSenderName() {return senderaddr_; } 
   inline void setSenderMAC(char *str){ strcpy(sendermac_,str); }
   inline char* getSenderMAC() {return sendermac_; } 
   inline void setSenderPort(short port) { txport_ = port;}
   inline short getSenderPort(){ return txport_;}
   inline void  setPHYXmitRate(short rate){txrate_ = rate;}
   inline short getPHYXmitRate(){return txrate_;}

};

/**An auxillary class for binding some receiver-specified 
 * measurements with the packet.
 * Currently, we list all possible RX parameters here
 */

class ReceiveParam
{
 public:
      ReceiveParam();
 private:     
      short rssi_;   ///< RSSI value from Wireless PHY of received pacekt 
      short noise_;  ///< Noise value from Wireless PHY of received packet
      int mac_timestamp_; ///<MAC timestamp from the driver
      int flowid_;   ///<Id of The flow which recived the packet.
      long seqno_;   ///<The sequence number attached by the flow. This value will implicitly tell the flow throughput. 
      long macrxtime_; ///<The timestampe when MAC_RX catches the packet
      double rxtime_;    /// < The time when the paket is received by the Gate, in milliseconds
      int rx_size_;   /// The actual size of received packet.
      char *receiveraddr_;  ///IP address of the receiver
      short rxport_;   ///<Port number, if applicable.
  
 public:
   inline short getFlowId(){return flowid_;}
   inline void setFlowId(short i){flowid_ = i;}
   inline unsigned long getFlowSequenceNum(){return seqno_;}
   inline void setFlowSequenceNum(unsigned long i){seqno_ = i;}
   inline void setRxTime(double ms){ rxtime_ = ms; }
   inline double getRxTime(){return rxtime_;}
   inline int getReceivedLength() {return rx_size_;}
   inline void setReceivedLength(int le){rx_size_ = le;}
   inline void setRSSI(short rssi){rssi_=rssi; }
   inline void setMacTimestamp(int ts) {mac_timestamp_ = ts;}
   inline int getMacTimestamp() {return mac_timestamp_;}
   inline short getRSSI() {return rssi_;}
};


/**
 * Packet is an entity given by generator.
 * This packet class only carries
 * payload information and a sending timestamp, not any socket address information. Also, the packet would carry all measuremnts related to this packet with it.
 */
class Packet {
 
public:
  /**
   *  Default payload size is 512 Bytes
   */
  static const int DEFAULT_PAYLOAD_SIZE = 512;
  Packet();
  Packet(int buffer_length);
  int fillPayload(int size, char *inputstream);  
   /** get a pointer to the payload
    * @return  a char pointer
    */
  inline char* getPayload(){ return payload_;} 
  void setPayloadSize(int size);
  /**get the size of packet buffer where payload is stored.
   *
   */
  inline int getBufferSize(){return length_;}
 /** get the size of the packet 
  *  
  */
      inline int getPayloadSize(){ return size_;}
 /** Fucntion to set the expected sending time of this packet
  */
      inline void setTimeStamp(double stamp) {time_ = stamp;}
 /** Function to get the sending timestamp of this packet.
  */
      inline double getTimeStamp()  {return time_; }  

  SendParam *txMeasure_;
  ReceiveParam *rxMeasure_;

  bool stampLongVal(int offset, unsigned long val); 
  unsigned long extractLongVal(int offset);
  bool stampShortVal(int offset, unsigned short val); 
  unsigned short extractShortVal(int offset);
  bool stampPktID();
  void extractPktID();


private:      
      /** Expected Deliver Timestamp.
       * Expected time to send this paket.absolute time in seconds.
       * the actual sending  time canot as precise as this double-precision variable. 
       * this is a relevant time, refer to the time when TG is started
       */
      double time_;  
      int size_;  ///< Packet length in Bytes
      int length_; ///< Maximum allocated Size of Payload buffer. it is no less than the size_
      char* payload_; ///< Payload Pointer.

     //void StampPayload(sendParam);  //put some libmac info to identify this packet, optional      
};


#endif