Search  

---

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

Go to the documentation of this file.

#ifndef __J2K__TFTP_Option_CPP__
#define __J2K__TFTP_Option_CPP__

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

/**************************************************************************
 ***  Default Constructor: Initializing every variables...              ***
 **************************************************************************/
TFTP_Option::TFTP_Option()
{ 
  rwlock1_global.write();
  fpath      = new char[  FILEPATH_LENGTH  ];  // 2 lines
  openedFile = new char[  FILEPATH_LENGTH  ];  
  filename   = new char[  FILENAME_LENGTH  ]; 
  hostname   = new char[  HOSTNAME_LENGTH  ];

  filesize  = new char[   FILESIZE_LENGTH  ];  // < 100 TB
 windowsize = new char[ WINDOWSIZE_LENGTH  ];
  blocksize = new char[  BLOCKSIZE_LENGTH  ];  
  timeout   = new char[    TIMEOUT_LENGTH  ];
  mode      = new char[       MODE_LENGTH  ];

  pgmType     = TFTP_Type_Undefined;
  state       = TFTP_Uninitialized;
  OACK_arg    = FALSE;
  myFile      = NULL;
  sender      = NULL;
  fileFactory = NULL;
  sendFactory = NULL;
  dataFactory = NULL;
  TopAck      = 0;
  LastData    = 0;
  RW_command  = 0;
  Done        = FALSE;
  waitingAck_queue = NULL;
  data_queue  = NULL;
  debug       = 0.0;  

        fpathLength = 0;
     filenameLength = 0;
     filesizeLength = 0;
   windowsizeLength = 2; // "1"
    blocksizeLength = 4; // "512"
      timeoutLength = 2; // "5"
         modeLength = 6; // "octet"

  memset( fpath,      0,   FILEPATH_LENGTH );
  memset( openedFile, 0,   FILEPATH_LENGTH );
  memset( filename,   0,   FILENAME_LENGTH );
  memset( hostname,   0,   HOSTNAME_LENGTH );
  memset( filesize,   0,   FILESIZE_LENGTH );
  memset( windowsize, 0, WINDOWSIZE_LENGTH );
  memset( blocksize,  0,  BLOCKSIZE_LENGTH );
  memset( timeout,    0,    TIMEOUT_LENGTH );
  memset( mode,       0,       MODE_LENGTH );

  port = DEFAULT_PORT;

  char* temp;

  temp = DEFAULT_BLOCKSIZE;
  memcpy( blocksize, temp, 4 );

  temp = DEFAULT_WINDOWSIZE;
  memcpy( windowsize, temp, 4 );

  temp = DEFAULT_TIMEOUT;
  memcpy( timeout,   temp, 2 );

  temp = DEFAULT_MODE;
  memcpy( mode,   temp, 6 );

  temp = DEFAULT_HOSTNAME;
  memcpy( hostname, temp, 20 );

  rwlock1_global.releaseWrite();


  rwlock3_templates.write();

  RRQ_WRQ_template = new char[ RRQ_WRQ_TEMPLATE_LENGTH ];
  Option_template  = new char[  OPTION_TEMPLATE_LENGTH ];

  RRQ_WRQ_templateLength = 6 + 2 + 2;
  Option_templateLength  = 0;

  memset( RRQ_WRQ_template, 0, RRQ_WRQ_TEMPLATE_LENGTH );
  memset(  Option_template, 0,  OPTION_TEMPLATE_LENGTH );

  rwlock3_templates.releaseWrite();
}

/**************************************************************************
 ***  Destructor: Deallocating every variables...                       ***
 **************************************************************************/
TFTP_Option::~TFTP_Option() 
{
#if 0
  rwlock1_global.write();
  if ( fpath     != NULL ) delete [] fpath;    
  if ( filename  != NULL ) delete [] filename;
  if ( hostname  != NULL ) delete [] hostname;
  if ( filesize  != NULL ) delete [] filesize;
  if ( blocksize != NULL ) delete [] blocksize;
  if ( timeout   != NULL ) delete [] timeout;
  if ( mode      != NULL ) delete [] mode;
  rwlock1_global.releaseWrite();
#endif

  rwlock2_file.write();
  if ( myFile    != NULL ) delete  myFile;
  if ( sender    != NULL ) delete sender;
  rwlock2_file.releaseWrite();

  rwlock3_templates.write();
  if ( RRQ_WRQ_template != NULL ) delete [] RRQ_WRQ_template;
  if ( Option_template  != NULL ) delete []  Option_template;
  rwlock3_templates.releaseWrite();
}


/**************************************************************************
 ***  Argument Parser: Parse the arguments passed on the command line.  ***
 **************************************************************************/
void TFTP_Option::ArgParser( int argc, char* argv[] )
{
  int i = 1;
  if (argc == 1)
  {
      char service;
      printf("Please tell me what kind of service you want. (S)erver or (C)lient?\n");
      cin>>service;

      if (service == 'S' || service == 's')
      {
          ConfigServer( NULL );
      }
      else
      {
          //Configures the hostname and port of the client
          ConfigClient( NULL );
      }
            
  }
  
  for ( ; i < argc; i++)
  {
     // Does the first character is a - or /
     if ( argv[i][0] == '-' || argv[i][0] == '/' )
     {
       char* s = argv[i] + 1;
       printf("(%s)", s );
       fflush(stdout);
       // Do we give param x by space or =
       char* p = strchr (argv[i], '=');
       if ( p > 0 )
       {
         // We have to -arg=x or --arg=x
         if ( argv[i][1] == '-' ) s++;
         *p = '\0';
         ArgDetect( s, p+1 );
 
       } else {
 
         // We have to -arg x or --arg x
         if ( argv[i][1] == '-' ) s++;
         
         char* opt = NULL;
         if ( (i+1) < argc ) opt = argv[i+1];
         fflush(stdout);
       
         ArgDetect( s, opt );
         i++;
       }
     } else {
       printf("\nInvalid parameter: [%s]\n", argv[i] );
     }
  }
}

/**************************************************************************
 ***  Argument Detection:                                               ***
 ***   Detect what kind of command line argument it is                  ***
 ***   and initialize variables in consequence to that given argument.  ***
 **************************************************************************/
void TFTP_Option::ArgDetect( const char* s, char* o )
{
    char* s2  = NULL;
    char* opt = o;
    size_t val = 0;
    
    if ( s != NULL ) 
    {
        s2 = strlwr( s );
    }
    
    if ( o != NULL ) 
    {
        opt = strlwr( o );
        val  = atol( opt );
        printf("{%s}", o );
    }
    
    printf("[%s]", s );
    fflush(stdout);
    if ( !strcmp( s2, "b" ) || !strcmp( s2, "blksize"   ) \
         || !strcmp( s2, "blocksize" ) )
    {
        OACK_arg = TRUE;   // This is an OACK extension
        setBlockSize( val );  
    }
    else if ( !strcmp( s2, "f" ) || !strcmp( s2, "file"     ) \
              || !strcmp( s2, "filename" ) )
    {
        setFileName( o );
    }
    else if ( !strcmp( s2, "put" )   || !strcmp( s2, "save"   ) || \
             !strcmp( s2, "write" ) || !strcmp( s2, "upload" ) )
    {
        setFileName( o );
        RW_command = 2;
        
        // Set Write bit and clear Read bit, if any.
        pgmType = (TFTP_Type_t)(  ((int)pgmType & 0x0B) | 0x08  );
    }
    else if ( !strcmp( s2, "get"  ) || !strcmp( s2, "load"     ) ||  \
              !strcmp( s2, "read" ) || !strcmp( s2, "download" ) )
    {
        setFileName( o );
        RW_command = 1;
        
        // Set Read bit and clear Write bit, if any.
        pgmType = (TFTP_Type_t)(  ((int)pgmType & 0x07) | 0x04  );
        
    }
    else if ( !strcmp( s2, "t" ) || !strcmp( s2, "timeout" ) )
    {
        OACK_arg = TRUE;   // This is an OACK extension
        setTimeOut( val );
    }
    else if ( !strcmp( s2, "m" ) || !strcmp( s2, "mode" ) )
    {
        setMode( opt );
    }
    else if ( !strcmp( s2, "s" ) || !strcmp( s2, "fsize" )  \
              || !strcmp( s2, "filesize" ) )
    {
        OACK_arg = TRUE;   // This is an OACK extension
        setFileSize( val );  
    }
    else if ( !strcmp( s2, "w" )      || !strcmp( s2, "wsize" ) || \
              !strcmp( s2, "window" ) || !strcmp( s2, "windowsize" ) )
    {
        OACK_arg = TRUE;   // This is an OACK extension
        setWindowSize( val );  
    }
    else if ( !strcmp( s2, "h" ) || !strcmp( s2, "host" )   \
              || !strcmp( s2, "hostname" ) )
    {
        setHostName( o );
    }
    else if ( !strcmp( s2, "p" ) || !strcmp( s2, "port" ) )
    {
        setPort( val );
    }
    else if ( !strcmp( s2, "c" ) || !strcmp( s2, "client" ) \
           || !strcmp( s2, "open" ) )
    {
        ConfigClient( opt );
    }
    else if ( !strcmp( s2, "d" )   || !strcmp( s2, "deamon" ) ||  \
              !strcmp( s2, "srv" ) || !strcmp( s2, "server" ) )
    {
        ConfigServer( opt );
    }
}
/**************************************************************************
 ***  Configures the port for the server                                ***
 **************************************************************************/

void TFTP_Option::ConfigServer( char* opt )
{
   port = DEFAULT_PORT;

   if (opt != NULL)
   {
     // Look for :
     char* q = strchr( opt, ':' );
            
     // If it's there the word after it is the port
     if ( q > 0 )
     {
       port = atol( q+1 );
     } else {
       port = atol( opt );
     }
   }
       
    setPort( port );

    // Set Server bit and clear Clients bit, if any.
    pgmType = (TFTP_Type_t)(  ((int)pgmType & 0x01) | 0x01  );
    
}

/**************************************************************************
 ***  Configures the hostname and port for the client                   ***
 **************************************************************************/

void TFTP_Option::ConfigClient(char* opt )
{
    
        short port = DEFAULT_PORT;
        if (opt != NULL)
        {
            //Look for :
            char* q = strchr( opt, ':' );
            
            //If it's there the word after it is the port
            if ( q > 0 )
            {
                port    = atol( q+1 );
                opt[ (int)(q-opt) ] = '\0';
                setPort( port );
                //And the hostname is right before.
                setHostName( opt);
            }
        }
        else
        {
            char hn[121];
            short pt;
            printf("Please enter hostname: \n");
            cin>>hn;
            printf("Please enter port: \n");
            cin>>pt;
            setPort (pt);
            setHostName(hn);
        }
        
        // Set Client bit and clear Server bit, if any.
        pgmType = (TFTP_Type_t)(  ((int)pgmType & 0xFE) | 0x02  );        
}


/**************************************************************************
 ***  RRQ & WRQ Template Builder:                                       ***
 ***   Build a template char[] that will be used                        ***
 ***   by RRQ and WRQ related functions in Packet class.                ***
 **************************************************************************/
void TFTP_Option::build_RRQ_WRQ_TemplatePacket()
{
  rwlock1_global.read();
  rwlock3_templates.write();

  printf("I'm in = (\n");
  fflush( stdout );

  showOptions();
  printf("\n);" );
  memset( RRQ_WRQ_template, 0, RRQ_WRQ_TEMPLATE_LENGTH );
  
  short op = 1;

  RRQ_WRQ_templateLength = filenameLength + modeLength + 2;
  
  memcpy( RRQ_WRQ_template, (char*)&op, 2 ); 
  memcpy( RRQ_WRQ_template + 2, filename, filenameLength );
  memcpy( RRQ_WRQ_template + 2 + filenameLength, mode, modeLength );

  rwlock1_global.releaseRead();
  rwlock3_templates.releaseWrite();
}

/**************************************************************************
 ***  Option Extension Template Builder:                                ***
 ***   Build a template char[] that will be used                        ***
 ***   by RRQ, WRQ and OACK related functions in Packet class.          ***
 **************************************************************************/
void TFTP_Option::build_OptionPacket() 
{
  size_t sz  = 2;
  size_t pos = 0;
  char* txt_blksize = "blksize";  // 8
  char* txt_tsize   = "tsize";    // 6
  char* txt_timeout = "timeout";  // 8
  char* txt_wsize   = "window";   // 7
  
  rwlock1_global.read();

  if ( blocksize != NULL ) {
    sz += blocksizeLength + 8;
  }

  if ( filesize  != NULL ) {
    sz += filesizeLength + 6;
  }

  if ( timeout   != NULL ) { 
    sz += timeoutLength + 8;
  }

  if ( windowsize != NULL ) { 
    sz += windowsizeLength + 7;
  }

  rwlock3_templates.write();

  memset( Option_template, 0, OPTION_TEMPLATE_LENGTH );  

  short oack_op = 6;

  memcpy( Option_template, (char*)&oack_op, 2 );

  pos = 2;

  if ( blocksize != NULL )
  {
    memcpy( Option_template + pos, txt_blksize, 8 );
    Option_template[ pos + 8 - 1 ] = '\0';

    memcpy( Option_template + pos + 8, blocksize, blocksizeLength );
    Option_template[ pos + 8 + blocksizeLength - 1 ] = '\0';

    pos += blocksizeLength + 8;
  }

/*
  if ( filesize  != NULL )
  {  memset( blocksize,    0, blocksizeLength );

    memcpy( Option_template + pos, txt_tsize, 6 );
    Option_template[ pos + 6 - 1 ] = '\0';

    memcpy( Option_template + pos + 6, filesize, filesizeLength );
    Option_template[ pos + 6 + filesizeLength - 1 ] = '\0';

    pos += filesizeLength + 6;
  }
*/

  if ( timeout   != NULL )
  {
    memcpy( Option_template + pos, txt_timeout, 8 );
    Option_template[ pos + 8 - 1 ] = '\0';

    memcpy( Option_template + pos + 8, timeout, timeoutLength );
    Option_template[ pos + 8 + timeoutLength - 1 ] = '\0';

    pos += timeoutLength + 8;
  }

  if ( windowsize != NULL )
  {
    memcpy( Option_template + pos, txt_wsize, 7 );
    Option_template[ pos + 7 - 1 ] = '\0';

    memcpy( Option_template + pos + 7, windowsize, windowsizeLength );
    Option_template[ pos + 7 + windowsizeLength - 1 ] = '\0';

    pos += windowsizeLength + 7;
  }

  Option_templateLength = sz;

  rwlock1_global.releaseRead();
  rwlock3_templates.releaseWrite();
}

/**************************************************************************
 ***  Set the filename                                                  ***
 **************************************************************************/
inline void TFTP_Option::setFileName( const char* fname ) 
{
  rwlock1_global.write();

  fpathLength = strlen( fname ) + 1;

  memset( fpath,    0, FILENAME_LENGTH );  
  memset( filename, 0, FILENAME_LENGTH );  

  filenameLength = fpathLength;
  memcpy( fpath,    fname, fpathLength );
  memcpy( filename, fname, fpathLength );
  rwlock1_global.releaseWrite();
}
 
/**************************************************************************
 ***  Get the filename                                                  ***
 **************************************************************************/
const char* TFTP_Option::getFileName() 
{
  rwlock1_global.read();
  char* temp = new char[ filenameLength ]; 
  memcpy( temp, filename, filenameLength );
  rwlock1_global.releaseRead();
  return (const char*)temp;
}

/**************************************************************************
 ***  Set the BlockSize                                                 ***
 **************************************************************************/
inline void TFTP_Option::setBlockSize( size_t bsize ) 
{
  rwlock1_global.write();

  char* temp = DEFAULT_BLOCKSIZE;
  memset( blocksize, 0, BLOCKSIZE_LENGTH );
  
  if ( bsize >= 8 && bsize <= 65464 ) 
  {
      blocksize = ulltostr( bsize, blocksize + BLOCKSIZE_LENGTH );
      blocksizeLength = strlen( blocksize ) + 1;      
  } else {
      blocksizeLength = strlen( temp ) + 1;
      memcpy( blocksize, temp, blocksizeLength );
  }

  rwlock1_global.releaseWrite();
}

/**************************************************************************
 ***  Requested by client Block Size                                    ***
 **************************************************************************/
inline void TFTP_Option::requestedBlockSize( size_t bsize )
{
  if ( blocksize == NULL ) return;          // Rejected.
  if ( bsize < 8 || bsize > 65464 ) return; // Rejected.

  setBlockSize( bsize );
}

/**************************************************************************
 ***  Get the BlockSize                                                 ***
 **************************************************************************/
inline size_t TFTP_Option::getBlockSize()
{
  rwlock1_global.read();
  long sz = atol( blocksize );
  rwlock1_global.releaseRead();
  return (size_t)sz;
}

/**************************************************************************
 ***  Set Port number                                                   ***
 **************************************************************************/
inline void TFTP_Option::setPort( size_t portNo ) 
{
  rwlock1_global.write();
  if ( portNo >= 0 && portNo <= 65535 ) 
  {
    port = portNo;
  }
  rwlock1_global.releaseWrite();
}

/**************************************************************************
 ***  Set Host name                                                     ***
 **************************************************************************/
inline void TFTP_Option::setHostName( const char* host )
{
  rwlock1_global.write();
  hostnameLength = strlen( host ) + 1;
  memset( hostname, 0, HOSTNAME_LENGTH );
  memcpy( hostname, host, hostnameLength );
  rwlock1_global.releaseWrite();
}

/**************************************************************************
 ***  Set the Window Size                                               ***
 **************************************************************************/
inline void TFTP_Option::setWindowSize( size_t wsize ) 
{
  rwlock1_global.write();
  char* temp = DEFAULT_WINDOWSIZE;

  memset( windowsize, 0, WINDOWSIZE_LENGTH );
  
  if ( wsize >= 1 && wsize <= 65464 ) 
  {
      windowsize = ulltostr( wsize, windowsize + WINDOWSIZE_LENGTH );
      windowsizeLength = strlen( windowsize ) + 1;      
  } else {
      windowsizeLength = strlen( temp ) + 1;
      memcpy( windowsize, temp, windowsizeLength );
  }

  rwlock1_global.releaseWrite();
}

/**************************************************************************
 ***  Requested by client Window Size                                   ***
 **************************************************************************/
inline void TFTP_Option::requestedWindowSize( size_t wsize )
{
  if ( windowsize == NULL ) return;          // Rejected.
  if ( wsize < 1 || wsize > 65464 ) return;  // Rejected.

  setWindowSize( wsize );
}

/**************************************************************************
 ***  Get the Window Size                                               ***
 **************************************************************************/
inline size_t TFTP_Option::getWindowSize()
{
  rwlock1_global.read();
  long sz = atol( windowsize );
  rwlock1_global.releaseRead();
  return (size_t)sz;
}

/**************************************************************************
 ***  Set the File Size                                                 ***
 **************************************************************************/
inline void TFTP_Option::setFileSize( size_t fsize )
{
    rwlock1_global.write();
  char* temp = "0";

  memset( filesize, 0, FILESIZE_LENGTH );
  
  if ( fsize > 0 ) 
  {
      filesize = ulltostr( fsize, filesize + FILESIZE_LENGTH );
      filesizeLength = strlen( filesize ) + 1;      
  } else {
      filesizeLength = strlen( temp ) + 1;
      memcpy( filesize, temp, filesizeLength );
  }

  rwlock1_global.releaseWrite();
}

/**************************************************************************
 ***  Requested by client File Size                                     ***
 **************************************************************************/
inline void TFTP_Option::requestedFileSize( size_t fsize )
{
  setFileSize( fsize );
}

/**************************************************************************
 ***  Get the File Size                                                 ***
 **************************************************************************/
inline const char* TFTP_Option::getFileSize()
{
  rwlock1_global.read();
  char* temp = new char[ filesizeLength ]; 
  memcpy( temp, filesize, filesizeLength );
  rwlock1_global.releaseRead();
  return (const char*)temp;
}

/**************************************************************************
 ***  Set the Transfer Mode                                             ***
 **************************************************************************/
inline void TFTP_Option::setMode( char* m )   
{
  if ( *m == 'o' ) {     // octet
    if ( *mode != 'o' )
    {
      rwlock1_global.write();
      char* temp = DEFAULT_MODE;
      modeLength = 6;
      memcpy( mode, temp, 6 );
      rwlock1_global.releaseWrite();
    }
  } else if ( *m == 'n' ) { // NetAscii

    printf( "NetASCII TFTP Mode NOT SUPPORTED! \n" );
    exit( 2 );

  } else if ( *m == 'm' ) { // Mail

    printf( "Mail TFTP Mode NOT SUPPORTED! \n" );
    exit( 2 );

  } else {

    printf( "Unknown TFTP Mode\n" );
    exit( 2 );
  }
}

/**************************************************************************
 ***  Requested by client Transfer mode                                 ***
 **************************************************************************/
inline void TFTP_Option::requestedMode( const char* m )
{
  if ( *m == 'o' ) return;
  SendNotDefinedError( "The requested mode is not supported." );
}

/**************************************************************************
 ***  Get the Transfer Mode                                             ***
 **************************************************************************/
inline const char* TFTP_Option::getMode() 
{
  rwlock1_global.read();
  char* temp = new char[ modeLength ];
  memcpy( temp, mode, modeLength );
  rwlock1_global.releaseRead();
  return (const char*)temp;
}

/**************************************************************************
 ***  Set the Transfer Timeout                                          ***
 **************************************************************************/
inline void TFTP_Option::setTimeOut( size_t t ) 
{    
  rwlock1_global.write();
  char* temp = "5";

  memset( timeout, 0, TIMEOUT_LENGTH );
  
  if ( t >= 1 && t <= 255 )
  {
      timeout = ulltostr( t, timeout + TIMEOUT_LENGTH );
      timeoutLength = strlen( timeout ) + 1;      
  } else {
      timeoutLength = strlen( temp ) + 1;
      memcpy( timeout, temp, timeoutLength );
  }

  rwlock1_global.releaseWrite();
}

/**************************************************************************
 ***  Requested by client Timeout                                       ***
 **************************************************************************/
inline void TFTP_Option::requestedTimeOut( size_t t )
{
  if ( timeout == NULL )  return;  // Rejected.
  if ( t < 1 || t > 255 ) return;  // Rejected.

  setTimeOut( t );
}

/**************************************************************************
 ***  Get the Transfer Timeout                                          ***
 **************************************************************************/
inline const char* TFTP_Option::getTimeOut() 
{
  rwlock1_global.read();
  char* temp = new char[ timeoutLength ]; 
  memcpy( temp, timeout, timeoutLength );
  rwlock1_global.releaseRead();
  return (const char*)temp;
}

/**************************************************************************
 ***  Get the Transfer Timeout value                                    ***
 **************************************************************************/
inline ULONG TFTP_Option::getTimeOutValue()
{
  rwlock1_global.read();
  long val = atol( timeout );
  rwlock1_global.releaseRead();
  return (ULONG)val;
}

/**************************************************************************
 ***  Get the Transfer Block size value                                 ***
 **************************************************************************/
inline ULONG TFTP_Option::getBlockSizeValue()
{
  rwlock1_global.read();
  long val = atol( blocksize );
  rwlock1_global.releaseRead();
  return (ULONG)val;
}

/**************************************************************************
 ***  Get the Transfer Window size value                                 ***
 **************************************************************************/
inline ULONG TFTP_Option::getWindowSizeValue()
{
  rwlock1_global.read();
  long val = atol( windowsize );
  rwlock1_global.releaseRead();
  return (ULONG)val;
}

/**************************************************************************
 ***  Open a JFile for the transfer:                                    ***
 ***    "rb" for read, "wb" for write                                   ***
 **************************************************************************/
void TFTP_Option::openFile( char* rwmode = "rb" ) 
{
  if ( !strcmp( openedFile, fpath ) ) return;

  char* rw = rwmode;

  if ( isClient() ) 
  {
    if ( isReading() ) rw = "wb";
    if ( isWriting() ) rw = "rb";    
  } else if ( isServer() ) 
  {
    if ( isReading() ) rw = "rb";
    if ( isWriting() ) rw = "wb";    
  }

  rwlock1_global.read();
  rwlock2_file.write();
  if ( myFile != NULL ) delete myFile;

  printf( "Building myFile for %s \n", rw ); 
  fflush( stdout );

  memcpy( openedFile, fpath, FILEPATH_LENGTH );
  myFile = new JFile( fpath, rw, (size_t)atol( blocksize ) );

  memset( filename, 0, FILENAME_LENGTH );
  
  myFile->getFileName( filename );
  filenameLength = strlen( filename ) + 1;
  rwlock1_global.releaseRead();
  rwlock2_file.releaseWrite();
}

/************************************************************************** 
 ************************************************************************** 
 ***   bit 0 Init                                                       *** 
 ***   bit 1 Connected                                                  *** 
 ***   bit 2 Ack for RRQ/WRQ                                            *** 
 ***   bit 3 Reading                                                    *** 
 ***   bit 4 Writing                                                    *** 
 ***   bit 5 End of Read/Write                                          *** 
 ***   bit 6 Error                                                      *** 
 ***   bit 7 Finished, program exit signal                              *** 
 ************************************************************************** 
 ***   Disconnect means that we are not connected and that              *** 
 ***   all the variables in TFTP_Option are still initialized.          *** 
 ************************************************************************** 
 **************************************************************************/


/**************************************************************************
 ***  Does the variables in TFTP_Option are initialized ?               *** 
 **************************************************************************/
inline int TFTP_Option::isInitialized()
{
  return (( (int)state & 0x01 ) == 0x01 );
}

/**************************************************************************
 ***  Does the program is connected to a foreign host  ?                *** 
 **************************************************************************/
inline int TFTP_Option::isConnected()
{
  return (( (int)state & 0x02 ) == 0x02 );
}

/**************************************************************************
 ***  Does the program is waiting for an acknowledgement to continue ?  *** 
 **************************************************************************/
inline int TFTP_Option::isWaitingForAck()
{
  return (( (int)state & 0x04 ) == 0x04 );
}

/**************************************************************************
 ***  Does the program is performing a reading request ?                *** 
 **************************************************************************/
inline int TFTP_Option::isReading()
{
  return (( (int)state & 0x08 ) == 0x08 );
}

/**************************************************************************
 ***  Does the program is performing a writing request ?                *** 
 **************************************************************************/
inline int TFTP_Option::isWriting()
{
  return (( (int)state & 0x10 ) == 0x10 );
}

/**************************************************************************
 ***  Does the program achieved an read/write end of file tranfert ?    *** 
 **************************************************************************/
inline int TFTP_Option::isEnding()
{
  return (( (int)state & 0x20 ) == 0x20 );
}

/**************************************************************************
 ***  Does the program sended/received an ERROR packet ?                ***
 **************************************************************************/
inline int TFTP_Option::hasError()
{
  return (( (int)state & 0x40 ) == 0x40 );
}

/**************************************************************************
 ***  Does the program sended a signal to abort all other threads ?     ***
 **************************************************************************/
inline int TFTP_Option::isKilling()
{
  return (( (int)state & 0x80 ) == 0x80 );
}

/**************************************************************************
 ***  This portion is used by TFTP_Parser to decide                     ***
 ***  if the incomming Packet shall be valid or not ?                   ***
 **************************************************************************/

/**************************************************************************
 ************************************************************************** 
 ***   bit 0 Server                                                     *** 
 ***   bit 1 Client                                                     *** 
 ***   bit 2 Reading Command Line request                               *** 
 ***   bit 3 Writing Command Line request                               *** 
 ************************************************************************** 
 **************************************************************************/
inline int TFTP_Option::isServer()
{
  return (( (int)pgmType & 0x01 ) == 0x01 );
}

inline int TFTP_Option::isClient()
{
  return (( (int)pgmType & 0x02 ) == 0x02 );
}

/**************************************************************************
 ***  Does the RRQ request in the given program state is valid ?        ***
 ***  We were waiting for a connection and we are the server            ***
 **************************************************************************/
inline int TFTP_Option::isRRQ_Valid()
{
  return ( state == TFTP_Connected  &&  isServer() );
}

/**************************************************************************
 ***  Does the WRQ request in the given program state is valid ?        ***
 ***  We were waiting for a connection and we are the server            ***
 **************************************************************************/
inline int TFTP_Option::isWRQ_Valid()
{
  return ( state == TFTP_Connected  &&  isServer() );
}

/**************************************************************************
 ***  Does the program state allowed DATA packet to be received ?       ***
 ***                                                                    ***
 ***  We are the client, we want to read and we receive                 ***
 ***  a Data Packet as an Acknowledgement or after the Acknowledgement. ***
 ***                                                                    ***
 ***  We are the server, the client side wants to write on the server   ***
 ***  and we receive data after acknowledgement #0 or OACK              ***
 **************************************************************************/
inline int TFTP_Option::isDATA_Valid()
{
  return ( ( state == TFTP_ReadingNotAck  &&  isClient()  ) || \
           ( state == TFTP_Reading        &&  isClient()  ) || \
           ( state == TFTP_Writing        &&  isServer()  )    );
}

/**************************************************************************
 ***  Are we waiting for an OACK packet to be received or not ?         ***
 ***                                                                    ***
 ***  We are the client and we received an option extensions            ***
 ***  acknowledgement for reading or writing request                    ***
 **************************************************************************/
inline int TFTP_Option::isOACK_Valid()
{
  return (  (( state == TFTP_ReadingNotAck ) ||  \
             ( state == TFTP_WritingNotAck ))  &&  isClient()  );
}

/**************************************************************************
 ***  Are we waiting for an ACK packet to be received or not ?          ***
 ***                                                                    ***
 ***  We are reading or writing on either client or server side         ***
 ***  waiting for RRQ, WRQ or DATA packet acknowledgement.              ***
 **************************************************************************/
inline int TFTP_Option::isACK_Valid()
{
  return ( state == TFTP_Reading       ||  state == TFTP_Writing  \
        || state == TFTP_ReadingNotAck ||  state == TFTP_WritingNotAck );
}

/**************************************************************************
 ***  Create a socket with the given parsed parameters                  ***
 **************************************************************************/
void TFTP_Option::createSocket()
{
  rwlock2_file.write();
  if ( sender != NULL ) {
    delete sender;
  }

  if ( isServer() ) {
    sender = new UDP_SocketServer( port );
  } else
  if ( isClient() ) {
    sender = new UDP_SocketClient( hostname, port );
  } else {
    printf( "The program type, Server or Client, was not specified on the command line.\n");
    exit( 1 );
  }
  rwlock2_file.releaseWrite();
}

/************************************************************/

void TFTP_Option::showStr( const char* n, const char* s )
{
    printf( "%s[", n );
    if ( s != NULL ) {   
        printf( "%s]\n", s );
    } else {             
        printf( "Null]\n" );
    }
}

void TFTP_Option::showVal( const char* n, size_t s ) 
{
    printf( "%s[%u]\n", n, s );
}

void TFTP_Option::showChar( const char*n, const char* s, size_t sz )
{
    printf("\n%s = {", n );

    for( int i = 0; i < sz; i++ )
        printf("[%u]%c)", s[i], s[i] );
        
    printf("};\n");
}

void TFTP_Option::showOptions()
{
  showStr( "fpath",  fpath);     // Full path          "/home/fred/test.txt"
  showStr( "filename",  filename);  // Only the filename  "test.txt"
  showStr( "filesize",  filesize);
  showStr( "timeout",  timeout);
  showStr( "blocksize",  blocksize);
  showStr( "mode",  mode);
  showStr( "windowsize",  windowsize);

  short  port;
  showStr( "hostname",  hostname);
  showVal( "hostnameLength ", hostnameLength);

  showVal("fpathLength ",       fpathLength);
  showVal("filenameLength ",    filenameLength);
  
  showVal("filesizeLength ",    filesizeLength); 
  showVal("blocksizeLength ",   blocksizeLength);
  showVal("windowsizeLength ",  windowsizeLength);
  showVal("timeoutLength ",     timeoutLength);
  showVal("modeLength ",        modeLength);

  showChar( "RRQ_WRQ_template",  RRQ_WRQ_template, RRQ_WRQ_templateLength );
  showVal( "RRQ_WRQ_templateLength ", RRQ_WRQ_templateLength);

  showChar( "Option_template",  Option_template, Option_templateLength );
  showVal( "Option_templateLength ", Option_templateLength);

  showVal( "state", (int)state );
  showVal( "pgmType", (int)pgmType );

  showVal( "OCAK_arg", OACK_arg );
  showVal( "Done", Done );

  showVal("LastData ",          LastData);

  printf( "CurrentTime[%d]\n", currentTime);
  showVal("windowsizeLeft ", windowsizeLeft);

  showVal("TopAck ",          TopAck);  
}

#endif

---