{
                        ph->Variable = HTTP_NOT_AVAILABLE;
                        ph->smHTTP = SM_HTTP_NOT_FOUND;
                    }
                    else
                    {
                        ph->smHTTP = SM_HTTP_HEADER;
                    }
                }
            }
            break;

        case SM_HTTP_NOT_FOUND:
            if ( TCPIsPutReady(ph->socket) )
            {
                romString = HTTPMessages[ph->Variable];

                while( (i = *romString++) )
                    TCPPut(ph->socket, i);

                TCPFlush(ph->socket);
                ph->smHTTP = SM_HTTP_DISCONNECT;
            }
            break;

        case SM_HTTP_HEADER:
            if ( TCPIsPutReady(ph->socket) )
            {
                lbContinue = TRUE;

                if ( ph->fileType == HTTP_DYNAMIC_FILE_TYPE )
				{
                    ph->bProcess = TRUE;
	                for ( i = 0; i < HTTP_OK_NO_CACHE_STRING_LEN; i++ )
	                    TCPPut(ph->socket, HTTP_OK_NO_CACHE_STRING[i]);
				}
                else
				{
                    ph->bProcess = FALSE;
	                for ( i = 0; i < HTTP_OK_STRING_LEN; i++ )
	                    TCPPut(ph->socket, HTTP_OK_STRING[i]);
				}


                romString = httpContents[ph->fileType].typeString;
                while( (i = *romString++) )
                    TCPPut(ph->socket, i);

                for ( i = 0; i < HTTP_HEADER_END_STRING_LEN; i++ )
                    TCPPut(ph->socket, HTTP_HEADER_END_STRING[i]);

                ph->smHTTPGet = SM_HTTP_GET_READ;
                ph->smHTTP = SM_HTTP_GET;
            }
            break;


        case SM_HTTP_GET:
            if ( TCPIsGetReady(ph->socket) )
                TCPDiscard(ph->socket);

            if ( SendFile(ph) )
            {
                MPFSClose();
                ph->smHTTP = SM_HTTP_DISCONNECT;
            }
            break;

        case SM_HTTP_DISCONNECT:
            if(TCPIsConnected(ph->socket))
            {
                if(TCPIsPutReady(ph->socket))
                {
                    TCPDisconnect(ph->socket);

                    // Switch to not-handled state.  This FSM has
                    // one common action that checks for disconnect
                    // condition and returns to Idle state.
                    ph->smHTTP = SM_HTTP_DISCONNECT_WAIT;
                }
            }
            break;

        }
    } while( lbContinue );
}


/*********************************************************************
 * Function:        static BOOL SendFile(HTTP_INFO* ph)
 *
 * PreCondition:    None
 *
 * Input:           ph      -   A HTTP connection info.
 *
 * Output:          File reference by this connection is served.
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            None.
 ********************************************************************/
static BOOL SendFile(HTTP_INFO* ph)
{
    BOOL lbTransmit;
    BYTE c;
    WORD_VAL HexNumber;

    MPFSGetBegin(ph->file);

	// Check if file is dynamic (.cgi) -- need to look for and 
	// process escape sequences
	if(ph->bProcess)					
	{
	    while(TCPIsPutReady(ph->socket))
	    {
	        lbTransmit = FALSE;
	
	        if(ph->smHTTPGet != SM_HTTP_GET_VAR)
	        {
	            c = MPFSGet();
	            if(MPFSIsEOF())
	            {
	                MPFSGetEnd();
	                TCPFlush(ph->socket);
	                return TRUE;
	            }
	        }
	
			switch(ph->smHTTPGet)
			{
			case SM_HTTP_GET_READ:
			    if ( c == HTTP_VAR_ESC_CHAR )
			        ph->smHTTPGet = SM_HTTP_GET_DLE;
			    else
			        lbTransmit = TRUE;
			    break;
			
			case SM_HTTP_GET_DLE:
			    if ( c == HTTP_VAR_ESC_CHAR )
			    {
			        lbTransmit = TRUE;
			        ph->smHTTPGet = SM_HTTP_GET_READ;
			    }
			    else
			    {
			        HexNumber.v[1] = c;
			        ph->smHTTPGet = SM_HTTP_GET_HANDLE;
			    }
			    break;
			
			case SM_HTTP_GET_HANDLE:
			    HexNumber.v[0] = c;
			    ph->Variable = hexatob(HexNumber);
			
			    ph->smHTTPGet = SM_HTTP_GET_VAR;
			    ph->VarRef = HTTP_START_OF_VAR;
			    break;
			
			case SM_HTTP_GET_VAR:
			    ph->VarRef = HTTPGetVar(ph->Variable, ph->VarRef, &c);
			    lbTransmit = TRUE;
			    if ( ph->VarRef == HTTP_END_OF_VAR )
			        ph->smHTTPGet = SM_HTTP_GET_READ;
			    break;
			}
			
			if(lbTransmit)
			    TCPPut(ph->socket, c);
		}
    }	
	else	// Static page content -- no processing required
	{
	    while(TCPIsPutReady(ph->socket))
		{
            c = MPFSGet();
            if(MPFSIsEOF())
            {
                MPFSGetEnd();
                TCPFlush(ph->socket);
                return TRUE;
            }
			else
	            TCPPut(ph->socket, c);
		}
	}

    ph->file = MPFSGetEnd();

    // We are not done sending a file yet...
    return FALSE;
}


/*********************************************************************
 * Function:        static HTTP_COMMAND HTTPParse(BYTE *string,
 *                                              BYTE** arg,
 *                                              BYTE* argc,
 *                                              BYTE* type)
 *
 * PreCondition:    None
 *
 * Input:           string      - HTTP Command String
 *                  arg         - List of string pointer to hold
 *                                HTTP arguments.
 *                  argc        - Pointer to hold total number of
 *                                arguments in this command string/
 *                  type        - Pointer to hold type of file
 *                                received.
 *                              Valid values are:
 *                                  HTTP_TXT
 *                                  HTTP_HTML
 *                                  HTTP_GIF
 *                                  HTTP_CGI
 *                                  HTTP_UNKNOWN
 *
 * Output:          HTTP FSM and connections are initialized
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            This function parses URL that may or may not
 *                  contain arguments.
 *                  e.g. "GET HTTP/1.0 thank.htm?name=MCHP&age=12"
 *                      would be returned as below:
 *                          arg[0] => GET
 *                          arg[1] => thank.htm
 *                          arg[2] => name
 *                          arg[3] => MCHP
 *                          arg[4] => 12
 *                          argc = 5
 *
 *                  This parses does not "de-escape" URL string.
 ********************************************************************/
static HTTP_COMMAND HTTPParse(BYTE *string,
                            BYTE** arg,
                            BYTE* argc,
                            BYTE* type)
{
    BYTE i;
    BYTE smParse;
    HTTP_COMMAND cmd;
    BYTE *ext;
    BYTE c;
    ROM char* fileType;

    enum
    {
        SM_PARSE_IDLE,
        SM_PARSE_ARG,
        SM_PARSE_ARG_FORMAT
    };

    smParse = SM_PARSE_IDLE;
    ext = NULL;
    i = 0;

    // Only "GET" is supported for time being.
    if ( !memcmppgm2ram(string, (ROM void*) HTTP_GET_STRING, HTTP_GET_STRING_LEN) )
    {
        string += (HTTP_GET_STRING_LEN + 1);
        cmd = HTTP_GET;
    }
    else
    {
        return HTTP_NOT_SUPPORTED;
    }

    // Skip white spaces.
    while( *string == ' ' )
        string++;

    c = *string;

    while ( c != ' ' &&  c != '\0' && c != '\r' && c != '\n' )

    {
        // Do not accept any more arguments than we haved designed to.
        if ( i >= *argc )
            break;

        switch(smParse)
        {
        case SM_PARSE_IDLE:
            arg[i] = string;
            c = *string;
            if ( c == '/' || c == '\\' )
                smParse = SM_PARSE_ARG;
            break;

        case SM_PARSE_ARG:
            arg[i++] = string;
            smParse = SM_PARSE_ARG_FORMAT;
            /*
             * Do not break.
             * Parameter may be empty.
             */

        case SM_PARSE_ARG_FORMAT:
            c = *string;
            if ( c == '?' || c == '&' )
            {
                *string = '\0';
                smParse = SM_PARSE_ARG;
            }
            else
            {
                // Recover space characters.
                if ( c == '+' )
                    *string = ' ';

                // Remember where file extension starts.
                else if ( c == '.' && i == 1u )
                {
                    ext = ++string;
                }

                else if ( c == '=' )
                {
                    *string = '\0';
                    smParse = SM_PARSE_ARG;
                }

                // Only interested in file name - not a path.
                else if ( c == '/' || c == '\\' )
                    arg[i-1] = string+1;

            }
            break;
        }
        string++;
        c = *string;
    }
    *string = '\0';

    *type = HTTP_UNKNOWN;
    if ( ext != NULL )
    {
        ext = (BYTE*)strupr((char*)ext);

        fileType = httpFiles[0].fileExt;
        for ( c = 0; c < TOTAL_FILE_TYPES; c++ )
        {
            if ( !memcmppgm2ram((void*)ext, (ROM void*)fileType, FILE_EXT_LEN) )
            {
                *type = c;
                break;
            }
            fileType += sizeof(FILE_TYPES);

        }
    }

    if ( i == 0u )
    {
        memcpypgm2ram(arg[0], (ROM void*)HTTP_DEFAULT_FILE_STRING,
                                     HTTP_DEFAULT_FILE_STRING_LEN);
        arg[0][HTTP_DEFAULT_FILE_STRING_LEN] = '\0';
        *type = HTTP_HTML;
        i++;
    }
    *argc = i;

    return cmd;
}


#endif //#if defined(STACK_USE_HTTP_SERVER)