Search  

---

C:/temp/src/j2k/Net/TFTP/TFTP_design.hpp

Go to the documentation of this file.

/*
Contains everything related to the TFTP protocol/layer
HDLC, 
*/

TFTP_Option option;

class Buffer
{
private:
    char* buf;
public:
    Buffer()
    {
    }
    ~Buffer();
};


class TFTPpacket {

};

/*
Deals with the file to send/receive
*/

class TFTPfile {
public:
    void open();
  void close();
  
  FILE*   fichier;

  Buffer* toNetascii();
  Buffer* toMail();
  Buffer* toOctet();
};

/*
Deals with opening and binding each socket
*/

class UnixSocket;



/*
Deals with Receiving socket packet from UDP using
a High priority PThread
*/

class UnixSocketReceiver;



/*
Deals with Sending socket packet from UDP using
a High priority PThread
*/

class UnixSocketSender;



#define printError( s ) sprintf( stderr, char* s )

struct tftp_rrq_wrq_t {
        short opcode;
   char*   filename;
   char    null1;
   char*   mode;
   char    null2;
}rrq_wrq;

class TFTPRequestPacket
{
private:
    tftp_rrq_wrq_t rrq_wrq_packet;
public:
    TFTPRequestPacket(short opcode, char* filename)
    {
        rrq_wrq_packet.opcode= opcode;
        rrq_wrq_packet.filename = filename;
        rrq_wrq_packet.null1= '0';
        rrq_wrq_packet.mode = "octect";
        rrq_wrq_packet.null2= '0';
        
    }
    ~TFTPRequestPacket()
    {
    }
    
    short getopcode()
    {
        return rrq_wrq_packet.opcode;
    }

    void setfilename(char* filename)
    {
        rrq_wrq_packet.filename = filename;
    }

    char* getfilename()
    {
        return rrq_wrq_packet.filename;
    }
    tftp_rrq_wrq_t* get_rrq_wrq_packet()
    {
        return &rrq_wrq_packet;
    }
};
    

#define TFTP_RRQ_WRQ_INIT  { 1 , NULL, 0, NULL, 0 }

struct tftp_optext_t {
    char*   opt1;
    char    null1;
    char*   value1;
    char    null2;
};

#define TFTP_OPTEXT_INIT { NULL, 0, NULL, 0}

/*
  Data Packet Class
*/
struct tftp_data_t {
   short  opcode;
   short blockNo;
   char*   data;
};


 #define TFTP_DATA_INIT { 3, 0, NULL }
class TFTPDataPacket
{
private:
    tftp_data_t datapacket;
public:
    TFTPDataPacket (short num, char* data){
        datapacket.opcode = 3;
        datapacket.blockNo= num;
        datapacket.data= data;
    }

    ~TFTPDataPacket()
    {
    }

    short getblockNo()
    {
        return datapacket.blockNo;
    }
    void  setblockNo(short num)
    {
        datapacket.blockNo=num;
        
    }
    void setdata(char* data)
    {
        datapacket.data = data;
    }
    

    tftp_data_t* getdatapacket() 
    {
        return &datapacket;
    }
    
};

/*
  Ack Packet Class
*/
struct tftp_ack_t {
   short  opcode; 
   short  blockNo;
};

#define TFTP_ACK_INIT { 4, 0 }

class TFTPAckPacket
{
private:
    tftp_ack_t ackpacket;
public:
    TFTPAckPacket (short num){
        ackpacket.opcode = 4;
        ackpacket.blockNo= num;
    }

    ~TFTPAckPacket()
    {
    }

    short getblockNo()
    {
        return ackpacket.blockNo;
    }
    void  setblockNo(short num)
    {
        ackpacket.blockNo=num;
        
    }

    tftp_ack_t* getackpacket() 
    {
        return &ackpacket;
    }
    
    
};

struct tftp_error_t {
   short opcode;
   short errorCode;
   char* errorMsg;
   char    null1;
};

class TFTPErrorPacket
{
private:
    tftp_error_t errorpacket;
 
            
public:
    TFTPErrorPacket( short errorcode)
    {
        errorpacket.opcode = 5;
        errorpacket.errorCode = errorcode;
        errorpacket.errorMsg = NULL;
        errorpacket.null1= '0';

    }
    ~TFTPErrorPacket()
    {
    }

    short geterrorCode()
    {
        return errorpacket.errorCode;
    }
    void seterrorCode(errorcode)
    {
        errorpacket.errorCode = errorcode;
    }
    

    char* getErrorMsg()
    {
        return "Error";
    }
    tftp_error_t* geterrorpacket()
    {
        return &errorpacket;
    }
    
};
#define TFTP_ERROR_INIT { 5, 0, NULL, 0 }

enum tftp_error_code_t {
   NotDefined        = 0,
   FileNotFound      = 1,
   AccessViolation   = 2,
   DiskFull          = 3,
   AllocationExceed  = 3,
   IllegalOperation  = 4,
   UnknownTransferID = 5,
   FileAlreadyExists = 6,
   NoSuchUser        = 7
};

struct StringData_t 
{
    char*  s;
    size_t len;
};

StringData_t tftp_error_msg[8] = {
    { "Not defined.", 12 },
    { "File not found", 14 },
    { "Access violation", 15 },
    { "Disk full", 9 },
    { "Allocation exceeded", 19},
    { "Illegal operation", 17 },
    { "Unknown transfer id", 19 },
    { "File already exists", 19 },
    { "No such user", 12 }
};

enum tftp_opcode {
   ReadRequest     = 1,
   WriteRequest    = 2,
   Data            = 3,
   Acknowledgement = 4,
   Error           = 5
};


class TFTP {
    Buffer*   buffer; 
    UCHAR     windowSize;
    ULONG     blockSize;
    char*     filename;
    int       Opt;
    
    Packet* pkt;

    TFTP(short listenport, short destport, char* desthost, char* f, int o)
    {
        //Unitializes connection
        UnixSocketReceiver Receiver( listeningport );
        UnixSocketSender   Sender( desthost, destport );
        //Gives the Sender the socket of the receiver
        Sender.setSocket( Receiver.getSocket());
        pkt = new Packet( Sender);
        char* filename= f;
        int Opt;
    }
    
    ~TFTP()
    {
    }
    //Sending Packet
    int Negotiate ( UnixSocketSender Sender) 
    {
        pkt.SendRRQ(3,filename,mode,Opt_None);
        
        pkt.SendError( 23); 
        //Sender.SendMsg((void*) packet.getpacket(),sizeof (packet.getpacket()));
    }
    void negotatiate()
    {
        //Send requets
        //wait for Ack
        //send data
        //wait for Ack
};
        
    

    
    
    

void sendPacket( siz1e_t begin, size_t length ) {
     char* pkt = new char[ blockSize ];
     char* pos = buffer.getPtr();
     memcpy( pkt, pos+begin, length );
     sender.send( pkt, length );
  }

    void sendRRQ_WRQ( char opcode, char* filename)
        
    void sendRR(   int frameNo);
    void sendErr();

};

---