Search  

---

C:/temp/src/j2k/Net/TFTP/TFTP_Packet.cpp

Go to the documentation of this file.

#ifndef __J2K__TFTP_Packet_CPP__
#define __J2K__TFTP_Packet_CPP__

#include <j2k/Net/TFTP/TFTP_Packet.hpp>


TFTP_Packet::TFTP_Packet()
 : pkt( NULL ), pktLength( 0 ) {  }

  // Set the opcode value
  inline void TFTP_Packet::setOpCode( enum OpCode_t op ) {
     opCode = (short)op;
  }

  // Return the opcode value
  inline short TFTP_Packet::getOpCode() {
     return opCode; 
  }

  void TFTP_Packet::create_RRQ_WRQ()
  {
     option.rwlock3_templates.read();

     long opt = option.Option_templateLength - 2;
     size_t sz  = option.RRQ_WRQ_templateLength;

     if ( opt <= 0 ) opt = 0;
     pktLength  = sz + opt;
     pkt        = new char[ pktLength ];

     memcpy( pkt, option.RRQ_WRQ_template, sz );    // Copy the RRQ Template
     memcpy( pkt, (char*)&opCode, 2 );              // Overwrite the opcode part
   

     // Copy the option, if they exist.
     if ( opt > 0 ) {
       memcpy( pkt + sz, option.Option_template + 2, opt );
     }
     
     option.rwlock3_templates.releaseRead(); 
  }

  inline void TFTP_Packet::sendRRQ()
  {
     opCode = 1;
     create_RRQ_WRQ();
     option.sender->send( pkt, pktLength );
  }

  inline void TFTP_Packet::sendWRQ()
  {
     opCode = 2;
     create_RRQ_WRQ();
     option.sender->send( pkt, pktLength );
  }

   // data IS NOT NULL TERMINATED !
   void TFTP_Packet::createData( short blockNo, char* data, size_t sz )
   {
      opCode = 3;
      block  = blockNo;

      pktLength = 2 + 2 + sz;     
      pkt       = new char[ pktLength ];

      memcpy( pkt,     (char*)&opCode,  2 );
      memcpy( pkt + 2, (char*)&block,   2 );
      if ( sz > 0 ) {
         memcpy( pkt + 4, data,        sz );
      }
   }

   inline void TFTP_Packet::createData( const char* rawData, size_t sz )
   {
      if ( pkt == NULL ) pkt = new char[ sz + 1 ];
      pktLength = sz;
      memcpy( pkt, rawData, sz );
   }
   
   inline void TFTP_Packet::sendData( short blockNo, char* data, size_t sz )
   {
      if ( sz > 0 ) {
        createData( blockNo, data, sz );
        pktLength = 4 + sz;
      } else {
        pktLength = 4;
      }
      option.sender->send( pkt, pktLength );  
   }

   inline void TFTP_Packet::send() {
     printf( "Sending Data: %d, %u", pkt, pktLength );
     option.sender->send( pkt, pktLength );
   }
    
   void TFTP_Packet::createAck( short blockNo )
   {
      opCode = 4;
      block  = blockNo;

      pktLength = 2 + 2;     
      pkt       = new char[ pktLength ];

      memcpy( pkt,     (char*)&opCode,  2 );
      memcpy( pkt + 2, (char*)&block,   2 );
   }

   inline void TFTP_Packet::sendAck( short blockNo )
   {
      createAck( blockNo );
      option.sender->send( pkt, pktLength );   
   }

   void TFTP_Packet::createError( enum TFTP_errcode_t e, const char* errmsg = "" )
   {
      opCode = 5;
      err    = (short)e;

      if ( errorMsg != NULL ) delete [] errorMsg;
      errorMsg = new char[ 200 ];
     
      memset( errorMsg, 0, 200 );

      const char* s = TFTP_errmsg[ opCode ];
      size_t len2 = strlen( s );

      size_t len = strlen( errmsg );
      memcpy( errorMsg, errmsg, len );
      errorMsg[ len ] = '\n';
      memcpy( errorMsg+len+1, s, len2 );

      size_t sz = len + len2 + 1;
      errorMsg[ sz ] = '\0';
      
      pktLength = 2 + 2 + sz;     
      pkt = new char[ pktLength ];

      memcpy( pkt,     (char*)&opCode,   2 );
      memcpy( pkt + 2, (char*)&err,      2 );
      memcpy( pkt + 4, (char*)errorMsg, sz );
   }     

   inline void TFTP_Packet::sendError( enum TFTP_errcode_t e, const char* errmsg = "" )
   {
      createError( e, errmsg );
      option.sender->send( pkt, pktLength );
   }

   inline char* TFTP_Packet::getErrorMsg()
   {
      return errorMsg;
   }

   void TFTP_Packet::createOAck()
   {
      opCode = 6;

      option.rwlock3_templates.read();

      size_t opt = option.Option_templateLength - 2;
 
      pktLength = opt + 2;
      pkt = new char[ pktLength ];


      // Copy the option, if they exist.
      if ( opt > 0 ) {
        memcpy( pkt, option.Option_template + 2, opt );
      }
 
      memcpy( pkt, (char*)&opCode,  2 );
      
      option.rwlock3_templates.releaseRead();
   }

   inline void TFTP_Packet::sendOAck()
   {
      createOAck();
      option.sender->send(pkt,pktLength);        
   }
    

   inline double TFTP_Packet::getTimeStamp() {
      return timestamp;
   }

   inline double TFTP_Packet::getID() {
      return block;
   }

   inline void TFTP_Packet::setTimeStamp( double t ) {
      timestamp = ceil( t );
   }

   inline char* TFTP_Packet::getData() {
      return (char*)( pkt + 4 );
   }

   short TFTP_Packet::getBlockNo() {
      short val;
      memcpy( (char*)(&val), (pkt+2), 2 );

      return val;
   }

   inline size_t TFTP_Packet::getpktLength() {
      return pktLength;
   }

#endif

---