Microchip%20TCP_IP%20stack/TCPIP%20Stack/FTP.c

/*********************************************************************
 *
 *      File Transfer Protocol (FTP) Client
 *  Module for Microchip TCP/IP Stack
 *       -Provides ability to remotely upload new MPFS image (web pages) 
 *        to external EEPROM memory
 *       -Reference: RFC 959
 *
 *********************************************************************
 * FileName:        FTP.c
 * Dependencies:    StackTsk.h
 *                  TCP.h
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
 * Complier:        Microchip C18 v3.02 or higher
 *                                      Microchip C30 v2.01 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright © 2002-2007 Microchip Technology Inc.  All rights 
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and 
 * distribute: 
 * (i)  the Software when embedded on a Microchip microcontroller or 
 *      digital signal controller product (“Device”) which is 
 *      integrated into Licensee’s product; or
 * (ii) ONLY the Software driver source files ENC28J60.c and 
 *      ENC28J60.h ported to a non-Microchip device used in 
 *      conjunction with a Microchip ethernet controller for the 
 *      sole purpose of interfacing with the ethernet controller. 
 *
 * You should refer to the license agreement accompanying this 
 * Software for additional information regarding your rights and 
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT 
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT 
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF 
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS 
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE 
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER 
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT 
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date    Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Nilesh Rajbharti     4/23/01  Original        (Rev 1.0)
 * Nilesh Rajbharti     11/13/02 Fixed FTPServer()
 * Howard Schlunder             07/10/06 Added hash printing to FTP client
 * Howard Schlunder             07/20/06 Added FTP_RESP_DATA_NO_SOCKET error message
  ********************************************************************/
#define __FTP_C

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_FTP_SERVER)

#define FTP_COMMAND_PORT                (21u)
#define FTP_DATA_PORT                   (20u)
#define FTP_TIMEOUT                     (TICK)((TICK)180u * TICK_SECOND)
#define MAX_FTP_ARGS                    (7u)
#define MAX_FTP_CMD_STRING_LEN          (31u)

typedef enum _SM_FTP
{
    SM_FTP_NOT_CONNECTED,
    SM_FTP_CONNECTED,
    SM_FTP_USER_NAME,
    SM_FTP_USER_PASS,
    SM_FTP_RESPOND
} SM_FTP;

typedef enum _SM_FTP_CMD
{
    SM_FTP_CMD_IDLE,
    SM_FTP_CMD_WAIT,
    SM_FTP_CMD_RECEIVE,
    SM_FTP_CMD_WAIT_FOR_DISCONNECT
} SM_FTP_CMD;

typedef enum _FTP_COMMAND
{
    FTP_CMD_USER,
    FTP_CMD_PASS,
    FTP_CMD_QUIT,
    FTP_CMD_STOR,
    FTP_CMD_PORT,
    FTP_CMD_ABORT,
    FTP_CMD_UNKNOWN,
    FTP_CMD_NONE,
} FTP_COMMAND;

// Each entry in following table must match with that of FTP_COMMAND enum.
static ROM char *FTPCommandString[] =
{
    "USER",                         // FTP_CMD_USER
    "PASS",                         // FTP_CMD_PASS
    "QUIT",                         // FTP_CMD_QUIT
    "STOR",                         // FTP_CMD_STOR
    "PORT",                         // FTP_CMD_PORT
    "ABOR"                          // FTP_CMD_ABORT
};
#define FTP_COMMAND_TABLE_SIZE  ( sizeof(FTPCommandString)/sizeof(FTPCommandString[0]) )


typedef enum _FTP_RESPONSE
{
    FTP_RESP_BANNER,
    FTP_RESP_USER_OK,
    FTP_RESP_PASS_OK,
    FTP_RESP_QUIT_OK,
    FTP_RESP_STOR_OK,
    FTP_RESP_UNKNOWN,
    FTP_RESP_LOGIN,
    FTP_RESP_DATA_OPEN,
    FTP_RESP_DATA_READY,
    FTP_RESP_DATA_CLOSE,
        FTP_RESP_DATA_NO_SOCKET,
    FTP_RESP_OK,

    FTP_RESP_NONE                       // This must always be the last
                                        // There is no corresponding string.
} FTP_RESPONSE;

// Each entry in following table must match with FTP_RESPONE enum
static ROM char *FTPResponseString[] =
{
    "220 Ready\r\n",                    // FTP_RESP_BANNER
    "331 Password required\r\n",        // FTP_RESP_USER_OK
    "230 Logged in\r\n",                // FTP_RESP_PASS_OK
    "221 Bye\r\n",                      // FTP_RESP_QUIT_OK
    "500 \r\n",                         // FTP_RESP_STOR_OK
    "502 Not implemented\r\n",          // FTP_RESP_UNKNOWN
    "530 Login required\r\n",           // FTP_RESP_LOGIN
    "150 Transferring data...\r\n",     // FTP_RESP_DATA_OPEN
    "125 Done\r\n",                     // FTP_RESP_DATA_READY
    "\r\n226 Transfer Complete\r\n",    // FTP_RESP_DATA_CLOSE
        "425 Can't create data socket.  Increase MAX_TCP_SOCKETS.\r\n", //FTP_RESP_DATA_NO_SOCKET
    "200 Ok\r\n"                        // FTP_RESP_OK
};


static union
{
    struct
    {
        unsigned char bUserSupplied : 1;
        unsigned char bLoggedIn: 1;
    } Bits;
    BYTE Val;
} FTPFlags;


static TCP_SOCKET       FTPSocket;      // Main ftp command socket.
static TCP_SOCKET       FTPDataSocket;  // ftp data socket.
static WORD_VAL         FTPDataPort;    // ftp data port number as supplied by client

static SM_FTP           smFTP;          // ftp server FSM state
static SM_FTP_CMD       smFTPCommand;   // ftp command FSM state

static FTP_COMMAND      FTPCommand;
static FTP_RESPONSE     FTPResponse;

static BYTE             FTPUser[FTP_USER_NAME_LEN];
static BYTE             FTPString[MAX_FTP_CMD_STRING_LEN+2];
static BYTE             FTPStringLen;
static BYTE             *FTP_argv[MAX_FTP_ARGS];    // Parameters for a ftp command
static BYTE             FTP_argc;       // Total number of params for a ftp command
static TICK             lastActivity;   // Timeout keeper.


static MPFS             FTPFileHandle;

// Private helper functions.
static void ParseFTPString(void);
static FTP_COMMAND ParseFTPCommand(BYTE *cmd);
static void ParseFTPString(void);
static BOOL ExecuteFTPCommand(FTP_COMMAND cmd);
static BOOL PutFile(void);
static BOOL Quit(void);


// Uncomment following line if ftp transactions are to be displayed on
// RS-232 - for debug purpose only.

//#define FTP_SERVER_DEBUG_MODE
#define FTP_PUT_ENABLED

#if defined(FTP_SERVER_DEBUG_MODE)
static USARTPut(BYTE c)
{
    while( !TXSTA_TRMT);
    TXREG = c;
}
#else

#define USARTPut(a)

#endif


/*********************************************************************
 * Function:        void FTPInit(void)
 *
 * PreCondition:    TCP module is already initialized.
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Initializes internal variables of FTP
 *
 * Note:
 ********************************************************************/
void FTPInit(void)
{
    FTPSocket       = TCPListen(FTP_COMMAND_PORT);
        FTPDataSocket   = INVALID_SOCKET;
    smFTP           = SM_FTP_NOT_CONNECTED;
    FTPStringLen    = 0;
    FTPFlags.Val    = 0;
    FTPDataPort.Val = FTP_DATA_PORT;
}


/*********************************************************************
 * Function:        void FTPServer(void)
 *
 * PreCondition:    FTPInit() must already be called.
 *
 * Input:           None
 *
 * Output:          Opened FTP connections are served.
 *
 * Side Effects:    None
 *
 * Overview:
 *
 * Note:            This function acts as a task (similar to one in
 *                  RTOS).  This function performs its task in
 *                  co-operative manner.  Main application must call
 *                  this function repeatdly to ensure all open
 *                  or new connections are served on time.
 ********************************************************************/
BOOL FTPServer(void)
{
    BYTE v;
    TICK currentTick;

    if ( !TCPIsConnected(FTPSocket) )
    {
        FTPStringLen    = 0;
        FTPCommand      = FTP_CMD_NONE;
        smFTP           = SM_FTP_NOT_CONNECTED;
        FTPFlags.Val    = 0;
        smFTPCommand    = SM_FTP_CMD_IDLE;
                if(FTPDataSocket != INVALID_SOCKET)
                {
                        TCPDisconnect(FTPDataSocket);
                        FTPDataSocket = INVALID_SOCKET;
                }

        return TRUE;
    }

    if ( TCPIsGetReady(FTPSocket) )
    {
        lastActivity    = TickGet();

        while( TCPGet(FTPSocket, &v ) )
        {
            USARTPut(v);
            FTPString[FTPStringLen++]   = v;
            if ( FTPStringLen == MAX_FTP_CMD_STRING_LEN )
                FTPStringLen            = 0;
        }
        TCPDiscard(FTPSocket);


        if ( v == '\n' )
        {
            FTPString[FTPStringLen]     = '\0';
            FTPStringLen                = 0;
            ParseFTPString();
            FTPCommand                  = ParseFTPCommand(FTP_argv[0]);
        }
    }
    else if ( smFTP != SM_FTP_NOT_CONNECTED )
    {
        currentTick = TickGet();
        currentTick = TickGetDiff(currentTick, lastActivity);
        if ( currentTick >= FTP_TIMEOUT )
        {
            lastActivity                = TickGet();
            FTPCommand                  = FTP_CMD_QUIT;
            smFTP                       = SM_FTP_CONNECTED;
        }
    }

    switch(smFTP)
    {
    case SM_FTP_NOT_CONNECTED:
        FTPResponse = FTP_RESP_BANNER;
        lastActivity = TickGet();
        /* No break - Continue... */

    case SM_FTP_RESPOND:
SM_FTP_RESPOND_Label:
        if(!TCPIsPutReady(FTPSocket))
                {
                        return TRUE;
                }
                else
                {
                        ROM char* pMsg;
                        
                        pMsg = FTPResponseString[FTPResponse];
                        
                        while( (v = *pMsg++) )
                        {
                            USARTPut(v);
                            TCPPut(FTPSocket, v);
                        }
                        TCPFlush(FTPSocket);
                        FTPResponse = FTP_RESP_NONE;
                        smFTP = SM_FTP_CONNECTED;
                }
        // No break - this will speed up little bit

    case SM_FTP_CONNECTED:
        if ( FTPCommand != FTP_CMD_NONE )
        {
            if ( ExecuteFTPCommand(FTPCommand) )
            {
                if ( FTPResponse != FTP_RESP_NONE )
                    smFTP = SM_FTP_RESPOND;
                else if ( FTPCommand == FTP_CMD_QUIT )
                    smFTP = SM_FTP_NOT_CONNECTED;

                FTPCommand = FTP_CMD_NONE;
                smFTPCommand = SM_FTP_CMD_IDLE;
            }
            else if ( FTPResponse != FTP_RESP_NONE )
            {
                smFTP = SM_FTP_RESPOND;
                goto SM_FTP_RESPOND_Label;
            }
        }
        break;


    }

    return TRUE;
}

static BOOL ExecuteFTPCommand(FTP_COMMAND cmd)
{
    switch(cmd)
    {
    case FTP_CMD_USER:
        FTPFlags.Bits.bUserSupplied = TRUE;
        FTPFlags.Bits.bLoggedIn = FALSE;
        FTPResponse = FTP_RESP_USER_OK;
        strncpy((char*)FTPUser, (char*)FTP_argv[1], sizeof(FTPUser));
        break;

    case FTP_CMD_PASS:
        if ( !FTPFlags.Bits.bUserSupplied )
            FTPResponse = FTP_RESP_LOGIN;
        else
        {
            if ( FTPVerify(FTPUser, FTP_argv[1]) )
            {
                FTPFlags.Bits.bLoggedIn = TRUE;
                FTPResponse = FTP_RESP_PASS_OK;
            }
            else
                FTPResponse = FTP_RESP_LOGIN;
        }
        break;

    case FTP_CMD_QUIT:
        return Quit();

    case FTP_CMD_PORT:
        FTPDataPort.v[1] = (BYTE)atoi((char*)FTP_argv[5]);
        FTPDataPort.v[0] = (BYTE)atoi((char*)FTP_argv[6]);
        FTPResponse = FTP_RESP_OK;
        break;

    case FTP_CMD_STOR:
        return PutFile();

    case FTP_CMD_ABORT:
        FTPResponse = FTP_RESP_OK;
        if ( FTPDataSocket != INVALID_SOCKET )
                {
                        TCPDisconnect(FTPDataSocket);
                        FTPDataSocket = INVALID_SOCKET;
                }
        break;

    default:
        FTPResponse = FTP_RESP_UNKNOWN;
        break;
    }
    return TRUE;
}

static BOOL Quit(void)
{
    switch(smFTPCommand)
    {
    case SM_FTP_CMD_IDLE:
#if defined(FTP_PUT_ENABLED)
        if ( smFTPCommand == SM_FTP_CMD_RECEIVE )
            MPFSClose();
#endif

        if ( FTPDataSocket != INVALID_SOCKET )
        {
#if defined(FTP_PUT_ENABLED)
            MPFSClose();
#endif
            TCPDisconnect(FTPDataSocket);
            smFTPCommand = SM_FTP_CMD_WAIT;
        }
        else
            goto Quit_Done;
        break;

    case SM_FTP_CMD_WAIT:
        if ( !TCPIsConnected(FTPDataSocket) )
        {
Quit_Done:
            FTPResponse = FTP_RESP_QUIT_OK;
            smFTPCommand = SM_FTP_CMD_WAIT_FOR_DISCONNECT;
        }
        break;

    case SM_FTP_CMD_WAIT_FOR_DISCONNECT:
        if ( TCPIsPutReady(FTPSocket) )
        {
            if ( TCPIsConnected(FTPSocket) )
                TCPDisconnect(FTPSocket);
        }
        break;

    }
    return FALSE;
}


static BOOL PutFile(void)
{
    BYTE v;


    switch(smFTPCommand)
    {
    case SM_FTP_CMD_IDLE:
        if ( !FTPFlags.Bits.bLoggedIn )
        {
            FTPResponse     = FTP_RESP_LOGIN;
            return TRUE;
        }
        else
        {
                        FTPResponse     = FTP_RESP_DATA_OPEN;
            FTPDataSocket   = TCPConnect(&TCPGetRemoteInfo(FTPSocket)->remote, FTPDataPort.Val);

                        // Make sure that a valid socket was available and returned
                        // If not, return with an error
                        if(FTPDataSocket != INVALID_SOCKET)
                        {
                    smFTPCommand = SM_FTP_CMD_WAIT;
                        }
                        else
                        {
                    FTPResponse = FTP_RESP_DATA_NO_SOCKET;
                    return TRUE;
                        }
        }
        break;

    case SM_FTP_CMD_WAIT:
        if ( TCPIsConnected(FTPDataSocket) )
        {
#if defined(FTP_PUT_ENABLED)
//            if ( !MPFSIsInUse() )
#endif
            {
#if defined(FTP_PUT_ENABLED)
                FTPFileHandle   = MPFSFormat();
#endif

                smFTPCommand    = SM_FTP_CMD_RECEIVE;
            }
        }
        break;

    case SM_FTP_CMD_RECEIVE:
        if ( TCPIsGetReady(FTPDataSocket) )
        {
            // Reload timeout timer.
            lastActivity    = TickGet();
            MPFSPutBegin(FTPFileHandle);
            while( TCPGet(FTPDataSocket, &v) )
            {
                USARTPut(v);

#if defined(FTP_PUT_ENABLED)
                MPFSPut(v);
#endif
            }
            FTPFileHandle = MPFSPutEnd();
            TCPDiscard(FTPDataSocket);

                        // Print hash characters on FTP client display
                if(TCPIsPutReady(FTPSocket))
                {
                                TCPPut(FTPSocket, '#');
                                TCPFlush(FTPSocket);
                }

        }
        else if ( !TCPIsConnected(FTPDataSocket) )
        {
#if defined(FTP_PUT_ENABLED)
            MPFSClose();
#endif
            TCPDisconnect(FTPDataSocket);
            FTPDataSocket   = INVALID_SOCKET;
            FTPResponse     = FTP_RESP_DATA_CLOSE;
            return TRUE;
        }
    }
    return FALSE;
}


static FTP_COMMAND ParseFTPCommand(BYTE *cmd)
{
    FTP_COMMAND i;

    for ( i = 0; i < (FTP_COMMAND)FTP_COMMAND_TABLE_SIZE; i++ )
    {
    if ( !memcmppgm2ram((void*)cmd, (ROM void*)FTPCommandString[i], 4) )
            return i;
    }

    return FTP_CMD_UNKNOWN;
}

static void ParseFTPString(void)
{
    BYTE *p;
    BYTE v;
    enum { SM_FTP_PARSE_PARAM, SM_FTP_PARSE_SPACE } smParseFTP;

    smParseFTP  = SM_FTP_PARSE_PARAM;
    p           = (BYTE*)&FTPString[0];

    // Skip white blanks
    while( *p == ' ' )
        p++;

    FTP_argv[0]  = (BYTE*)p;
    FTP_argc     = 1;

    while( (v = *p) )
    {
        switch(smParseFTP)
        {
        case SM_FTP_PARSE_PARAM:
            if ( v == ' ' || v == ',' )
            {
                *p = '\0';
                smParseFTP = SM_FTP_PARSE_SPACE;
            }
            else if ( v == '\r' || v == '\n' )
                *p = '\0';
            break;

        case SM_FTP_PARSE_SPACE:
            if ( v != ' ' )
            {
                FTP_argv[FTP_argc++] = (BYTE*)p;
                smParseFTP = SM_FTP_PARSE_PARAM;
            }
            break;
        }
        p++;
    }
}

#endif  // #if defined(STACK_USE_FTP_SERVER)
1	/*********************************************************************
2	*
3	* File Transfer Protocol (FTP) Client
4	* Module for Microchip TCP/IP Stack
5	* -Provides ability to remotely upload new MPFS image (web pages)
6	* to external EEPROM memory
7	* -Reference: RFC 959
8	*
9	*********************************************************************
10	* FileName: FTP.c
11	* Dependencies: StackTsk.h
12	* TCP.h
13	* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
14	* Complier: Microchip C18 v3.02 or higher
15	* Microchip C30 v2.01 or higher
16	* Company: Microchip Technology, Inc.
17	*
18	* Software License Agreement
19	*
20	* Copyright © 2002-2007 Microchip Technology Inc. All rights
21	* reserved.
22	*
23	* Microchip licenses to you the right to use, modify, copy, and
24	* distribute:
25	* (i) the Software when embedded on a Microchip microcontroller or
26	* digital signal controller product (“Device”) which is
27	* integrated into Licensee’s product; or
28	* (ii) ONLY the Software driver source files ENC28J60.c and
29	* ENC28J60.h ported to a non-Microchip device used in
30	* conjunction with a Microchip ethernet controller for the
31	* sole purpose of interfacing with the ethernet controller.
32	*
33	* You should refer to the license agreement accompanying this
34	* Software for additional information regarding your rights and
35	* obligations.
36	*
37	* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
38	* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
39	* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
40	* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
41	* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
42	* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
43	* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
44	* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
45	* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
46	* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
47	* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
48	*
49	*
50	* Author Date Comment
51	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
52	* Nilesh Rajbharti 4/23/01 Original (Rev 1.0)
53	* Nilesh Rajbharti 11/13/02 Fixed FTPServer()
54	* Howard Schlunder 07/10/06 Added hash printing to FTP client
55	* Howard Schlunder 07/20/06 Added FTP_RESP_DATA_NO_SOCKET error message
56	********************************************************************/
57	#define __FTP_C
58
59	#include "TCPIP Stack/TCPIP.h"
60
61	#if defined(STACK_USE_FTP_SERVER)
62
63	#define FTP_COMMAND_PORT (21u)
64	#define FTP_DATA_PORT (20u)
65	#define FTP_TIMEOUT (TICK)((TICK)180u * TICK_SECOND)
66	#define MAX_FTP_ARGS (7u)
67	#define MAX_FTP_CMD_STRING_LEN (31u)
68
69	typedef enum _SM_FTP
70	{
71	SM_FTP_NOT_CONNECTED,
72	SM_FTP_CONNECTED,
73	SM_FTP_USER_NAME,
74	SM_FTP_USER_PASS,
75	SM_FTP_RESPOND
76	} SM_FTP;
77
78	typedef enum _SM_FTP_CMD
79	{
80	SM_FTP_CMD_IDLE,
81	SM_FTP_CMD_WAIT,
82	SM_FTP_CMD_RECEIVE,
83	SM_FTP_CMD_WAIT_FOR_DISCONNECT
84	} SM_FTP_CMD;
85
86	typedef enum _FTP_COMMAND
87	{
88	FTP_CMD_USER,
89	FTP_CMD_PASS,
90	FTP_CMD_QUIT,
91	FTP_CMD_STOR,
92	FTP_CMD_PORT,
93	FTP_CMD_ABORT,
94	FTP_CMD_UNKNOWN,
95	FTP_CMD_NONE,
96	} FTP_COMMAND;
97
98	// Each entry in following table must match with that of FTP_COMMAND enum.
99	static ROM char *FTPCommandString[] =
100	{
101	"USER", // FTP_CMD_USER
102	"PASS", // FTP_CMD_PASS
103	"QUIT", // FTP_CMD_QUIT
104	"STOR", // FTP_CMD_STOR
105	"PORT", // FTP_CMD_PORT
106	"ABOR" // FTP_CMD_ABORT
107	};
108	#define FTP_COMMAND_TABLE_SIZE ( sizeof(FTPCommandString)/sizeof(FTPCommandString[0]) )
109
110
111	typedef enum _FTP_RESPONSE
112	{
113	FTP_RESP_BANNER,
114	FTP_RESP_USER_OK,
115	FTP_RESP_PASS_OK,
116	FTP_RESP_QUIT_OK,
117	FTP_RESP_STOR_OK,
118	FTP_RESP_UNKNOWN,
119	FTP_RESP_LOGIN,
120	FTP_RESP_DATA_OPEN,
121	FTP_RESP_DATA_READY,
122	FTP_RESP_DATA_CLOSE,
123	FTP_RESP_DATA_NO_SOCKET,
124	FTP_RESP_OK,
125
126	FTP_RESP_NONE // This must always be the last
127	// There is no corresponding string.
128	} FTP_RESPONSE;
129
130	// Each entry in following table must match with FTP_RESPONE enum
131	static ROM char *FTPResponseString[] =
132	{
133	"220 Ready\r\n", // FTP_RESP_BANNER
134	"331 Password required\r\n", // FTP_RESP_USER_OK
135	"230 Logged in\r\n", // FTP_RESP_PASS_OK
136	"221 Bye\r\n", // FTP_RESP_QUIT_OK
137	"500 \r\n", // FTP_RESP_STOR_OK
138	"502 Not implemented\r\n", // FTP_RESP_UNKNOWN
139	"530 Login required\r\n", // FTP_RESP_LOGIN
140	"150 Transferring data...\r\n", // FTP_RESP_DATA_OPEN
141	"125 Done\r\n", // FTP_RESP_DATA_READY
142	"\r\n226 Transfer Complete\r\n", // FTP_RESP_DATA_CLOSE
143	"425 Can't create data socket. Increase MAX_TCP_SOCKETS.\r\n", //FTP_RESP_DATA_NO_SOCKET
144	"200 Ok\r\n" // FTP_RESP_OK
145	};
146
147
148	static union
149	{
150	struct
151	{
152	unsigned char bUserSupplied : 1;
153	unsigned char bLoggedIn: 1;
154	} Bits;
155	BYTE Val;
156	} FTPFlags;
157
158
159	static TCP_SOCKET FTPSocket; // Main ftp command socket.
160	static TCP_SOCKET FTPDataSocket; // ftp data socket.
161	static WORD_VAL FTPDataPort; // ftp data port number as supplied by client
162
163	static SM_FTP smFTP; // ftp server FSM state
164	static SM_FTP_CMD smFTPCommand; // ftp command FSM state
165
166	static FTP_COMMAND FTPCommand;
167	static FTP_RESPONSE FTPResponse;
168
169	static BYTE FTPUser[FTP_USER_NAME_LEN];
170	static BYTE FTPString[MAX_FTP_CMD_STRING_LEN+2];
171	static BYTE FTPStringLen;
172	static BYTE *FTP_argv[MAX_FTP_ARGS]; // Parameters for a ftp command
173	static BYTE FTP_argc; // Total number of params for a ftp command
174	static TICK lastActivity; // Timeout keeper.
175
176
177	static MPFS FTPFileHandle;
178
179	// Private helper functions.
180	static void ParseFTPString(void);
181	static FTP_COMMAND ParseFTPCommand(BYTE *cmd);
182	static void ParseFTPString(void);
183	static BOOL ExecuteFTPCommand(FTP_COMMAND cmd);
184	static BOOL PutFile(void);
185	static BOOL Quit(void);
186
187
188	// Uncomment following line if ftp transactions are to be displayed on
189	// RS-232 - for debug purpose only.
190
191	//#define FTP_SERVER_DEBUG_MODE
192	#define FTP_PUT_ENABLED
193
194	#if defined(FTP_SERVER_DEBUG_MODE)
195	static USARTPut(BYTE c)
196	{
197	while( !TXSTA_TRMT);
198	TXREG = c;
199	}
200	#else
201
202	#define USARTPut(a)
203
204	#endif
205
206
207	/*********************************************************************
208	* Function: void FTPInit(void)
209	*
210	* PreCondition: TCP module is already initialized.
211	*
212	* Input: None
213	*
214	* Output: None
215	*
216	* Side Effects: None
217	*
218	* Overview: Initializes internal variables of FTP
219	*
220	* Note:
221	********************************************************************/
222	void FTPInit(void)
223	{
224	FTPSocket = TCPListen(FTP_COMMAND_PORT);
225	FTPDataSocket = INVALID_SOCKET;
226	smFTP = SM_FTP_NOT_CONNECTED;
227	FTPStringLen = 0;
228	FTPFlags.Val = 0;
229	FTPDataPort.Val = FTP_DATA_PORT;
230	}
231
232
233	/*********************************************************************
234	* Function: void FTPServer(void)
235	*
236	* PreCondition: FTPInit() must already be called.
237	*
238	* Input: None
239	*
240	* Output: Opened FTP connections are served.
241	*
242	* Side Effects: None
243	*
244	* Overview:
245	*
246	* Note: This function acts as a task (similar to one in
247	* RTOS). This function performs its task in
248	* co-operative manner. Main application must call
249	* this function repeatdly to ensure all open
250	* or new connections are served on time.
251	********************************************************************/
252	BOOL FTPServer(void)
253	{
254	BYTE v;
255	TICK currentTick;
256
257	if ( !TCPIsConnected(FTPSocket) )
258	{
259	FTPStringLen = 0;
260	FTPCommand = FTP_CMD_NONE;
261	smFTP = SM_FTP_NOT_CONNECTED;
262	FTPFlags.Val = 0;
263	smFTPCommand = SM_FTP_CMD_IDLE;
264	if(FTPDataSocket != INVALID_SOCKET)
265	{
266	TCPDisconnect(FTPDataSocket);
267	FTPDataSocket = INVALID_SOCKET;
268	}
269
270	return TRUE;
271	}
272
273	if ( TCPIsGetReady(FTPSocket) )
274	{
275	lastActivity = TickGet();
276
277	while( TCPGet(FTPSocket, &v ) )
278	{
279	USARTPut(v);
280	FTPString[FTPStringLen++] = v;
281	if ( FTPStringLen == MAX_FTP_CMD_STRING_LEN )
282	FTPStringLen = 0;
283	}
284	TCPDiscard(FTPSocket);
285
286
287	if ( v == '\n' )
288	{
289	FTPString[FTPStringLen] = '\0';
290	FTPStringLen = 0;
291	ParseFTPString();
292	FTPCommand = ParseFTPCommand(FTP_argv[0]);
293	}
294	}
295	else if ( smFTP != SM_FTP_NOT_CONNECTED )
296	{
297	currentTick = TickGet();
298	currentTick = TickGetDiff(currentTick, lastActivity);
299	if ( currentTick >= FTP_TIMEOUT )
300	{
301	lastActivity = TickGet();
302	FTPCommand = FTP_CMD_QUIT;
303	smFTP = SM_FTP_CONNECTED;
304	}
305	}
306
307	switch(smFTP)
308	{
309	case SM_FTP_NOT_CONNECTED:
310	FTPResponse = FTP_RESP_BANNER;
311	lastActivity = TickGet();
312	/* No break - Continue... */
313
314	case SM_FTP_RESPOND:
315	SM_FTP_RESPOND_Label:
316	if(!TCPIsPutReady(FTPSocket))
317	{
318	return TRUE;
319	}
320	else
321	{
322	ROM char* pMsg;
323
324	pMsg = FTPResponseString[FTPResponse];
325
326	while( (v = *pMsg++) )
327	{
328	USARTPut(v);
329	TCPPut(FTPSocket, v);
330	}
331	TCPFlush(FTPSocket);
332	FTPResponse = FTP_RESP_NONE;
333	smFTP = SM_FTP_CONNECTED;
334	}
335	// No break - this will speed up little bit
336
337	case SM_FTP_CONNECTED:
338	if ( FTPCommand != FTP_CMD_NONE )
339	{
340	if ( ExecuteFTPCommand(FTPCommand) )
341	{
342	if ( FTPResponse != FTP_RESP_NONE )
343	smFTP = SM_FTP_RESPOND;
344	else if ( FTPCommand == FTP_CMD_QUIT )
345	smFTP = SM_FTP_NOT_CONNECTED;
346
347	FTPCommand = FTP_CMD_NONE;
348	smFTPCommand = SM_FTP_CMD_IDLE;
349	}
350	else if ( FTPResponse != FTP_RESP_NONE )
351	{
352	smFTP = SM_FTP_RESPOND;
353	goto SM_FTP_RESPOND_Label;
354	}
355	}
356	break;
357
358
359	}
360
361	return TRUE;
362	}
363
364	static BOOL ExecuteFTPCommand(FTP_COMMAND cmd)
365	{
366	switch(cmd)
367	{
368	case FTP_CMD_USER:
369	FTPFlags.Bits.bUserSupplied = TRUE;
370	FTPFlags.Bits.bLoggedIn = FALSE;
371	FTPResponse = FTP_RESP_USER_OK;
372	strncpy((char)FTPUser, (char)FTP_argv[1], sizeof(FTPUser));
373	break;
374
375	case FTP_CMD_PASS:
376	if ( !FTPFlags.Bits.bUserSupplied )
377	FTPResponse = FTP_RESP_LOGIN;
378	else
379	{
380	if ( FTPVerify(FTPUser, FTP_argv[1]) )
381	{
382	FTPFlags.Bits.bLoggedIn = TRUE;
383	FTPResponse = FTP_RESP_PASS_OK;
384	}
385	else
386	FTPResponse = FTP_RESP_LOGIN;
387	}
388	break;
389
390	case FTP_CMD_QUIT:
391	return Quit();
392
393	case FTP_CMD_PORT:
394	FTPDataPort.v[1] = (BYTE)atoi((char*)FTP_argv[5]);
395	FTPDataPort.v[0] = (BYTE)atoi((char*)FTP_argv[6]);
396	FTPResponse = FTP_RESP_OK;
397	break;
398
399	case FTP_CMD_STOR:
400	return PutFile();
401
402	case FTP_CMD_ABORT:
403	FTPResponse = FTP_RESP_OK;
404	if ( FTPDataSocket != INVALID_SOCKET )
405	{
406	TCPDisconnect(FTPDataSocket);
407	FTPDataSocket = INVALID_SOCKET;
408	}
409	break;
410
411	default:
412	FTPResponse = FTP_RESP_UNKNOWN;
413	break;
414	}
415	return TRUE;
416	}
417
418	static BOOL Quit(void)
419	{
420	switch(smFTPCommand)
421	{
422	case SM_FTP_CMD_IDLE:
423	#if defined(FTP_PUT_ENABLED)
424	if ( smFTPCommand == SM_FTP_CMD_RECEIVE )
425	MPFSClose();
426	#endif
427
428	if ( FTPDataSocket != INVALID_SOCKET )
429	{
430	#if defined(FTP_PUT_ENABLED)
431	MPFSClose();
432	#endif
433	TCPDisconnect(FTPDataSocket);
434	smFTPCommand = SM_FTP_CMD_WAIT;
435	}
436	else
437	goto Quit_Done;
438	break;
439
440	case SM_FTP_CMD_WAIT:
441	if ( !TCPIsConnected(FTPDataSocket) )
442	{
443	Quit_Done:
444	FTPResponse = FTP_RESP_QUIT_OK;
445	smFTPCommand = SM_FTP_CMD_WAIT_FOR_DISCONNECT;
446	}
447	break;
448
449	case SM_FTP_CMD_WAIT_FOR_DISCONNECT:
450	if ( TCPIsPutReady(FTPSocket) )
451	{
452	if ( TCPIsConnected(FTPSocket) )
453	TCPDisconnect(FTPSocket);
454	}
455	break;
456
457	}
458	return FALSE;
459	}
460
461
462	static BOOL PutFile(void)
463	{
464	BYTE v;
465
466
467	switch(smFTPCommand)
468	{
469	case SM_FTP_CMD_IDLE:
470	if ( !FTPFlags.Bits.bLoggedIn )
471	{
472	FTPResponse = FTP_RESP_LOGIN;
473	return TRUE;
474	}
475	else
476	{
477	FTPResponse = FTP_RESP_DATA_OPEN;
478	FTPDataSocket = TCPConnect(&TCPGetRemoteInfo(FTPSocket)->remote, FTPDataPort.Val);
479
480	// Make sure that a valid socket was available and returned
481	// If not, return with an error
482	if(FTPDataSocket != INVALID_SOCKET)
483	{
484	smFTPCommand = SM_FTP_CMD_WAIT;
485	}
486	else
487	{
488	FTPResponse = FTP_RESP_DATA_NO_SOCKET;
489	return TRUE;
490	}
491	}
492	break;
493
494	case SM_FTP_CMD_WAIT:
495	if ( TCPIsConnected(FTPDataSocket) )
496	{
497	#if defined(FTP_PUT_ENABLED)
498	// if ( !MPFSIsInUse() )
499	#endif
500	{
501	#if defined(FTP_PUT_ENABLED)
502	FTPFileHandle = MPFSFormat();
503	#endif
504
505	smFTPCommand = SM_FTP_CMD_RECEIVE;
506	}
507	}
508	break;
509
510	case SM_FTP_CMD_RECEIVE:
511	if ( TCPIsGetReady(FTPDataSocket) )
512	{
513	// Reload timeout timer.
514	lastActivity = TickGet();
515	MPFSPutBegin(FTPFileHandle);
516	while( TCPGet(FTPDataSocket, &v) )
517	{
518	USARTPut(v);
519
520	#if defined(FTP_PUT_ENABLED)
521	MPFSPut(v);
522	#endif
523	}
524	FTPFileHandle = MPFSPutEnd();
525	TCPDiscard(FTPDataSocket);
526
527	// Print hash characters on FTP client display
528	if(TCPIsPutReady(FTPSocket))
529	{
530	TCPPut(FTPSocket, '#');
531	TCPFlush(FTPSocket);
532	}
533
534	}
535	else if ( !TCPIsConnected(FTPDataSocket) )
536	{
537	#if defined(FTP_PUT_ENABLED)
538	MPFSClose();
539	#endif
540	TCPDisconnect(FTPDataSocket);
541	FTPDataSocket = INVALID_SOCKET;
542	FTPResponse = FTP_RESP_DATA_CLOSE;
543	return TRUE;
544	}
545	}
546	return FALSE;
547	}
548
549
550
551	static FTP_COMMAND ParseFTPCommand(BYTE *cmd)
552	{
553	FTP_COMMAND i;
554
555	for ( i = 0; i < (FTP_COMMAND)FTP_COMMAND_TABLE_SIZE; i++ )
556	{
557	if ( !memcmppgm2ram((void)cmd, (ROM void)FTPCommandString[i], 4) )
558	return i;
559	}
560
561	return FTP_CMD_UNKNOWN;
562	}
563
564	static void ParseFTPString(void)
565	{
566	BYTE *p;
567	BYTE v;
568	enum { SM_FTP_PARSE_PARAM, SM_FTP_PARSE_SPACE } smParseFTP;
569
570	smParseFTP = SM_FTP_PARSE_PARAM;
571	p = (BYTE*)&FTPString[0];
572
573	// Skip white blanks
574	while( *p == ' ' )
575	p++;
576
577	FTP_argv[0] = (BYTE*)p;
578	FTP_argc = 1;
579
580	while( (v = *p) )
581	{
582	switch(smParseFTP)
583	{
584	case SM_FTP_PARSE_PARAM:
585	if ( v == ' ' \|\| v == ',' )
586	{
587	*p = '\0';
588	smParseFTP = SM_FTP_PARSE_SPACE;
589	}
590	else if ( v == '\r' \|\| v == '\n' )
591	*p = '\0';
592	break;
593
594	case SM_FTP_PARSE_SPACE:
595	if ( v != ' ' )
596	{
597	FTP_argv[FTP_argc++] = (BYTE*)p;
598	smParseFTP = SM_FTP_PARSE_PARAM;
599	}
600	break;
601	}
602	p++;
603	}
604	}
605
606	#endif // #if defined(STACK_USE_FTP_SERVER)