web.c

Go to the documentation of this file.

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

    #define     WEB_C
    #include    "web.h"
    #include    "webprocess.h"
    #include    "config.h"
    #include    "xml.h"

    #include    "projectdefs.h"


// ////////////////////////////////////////////////////////////////////////////
// Local Defines
// ////////////////////////////////////////////////////////////////////////////

#define WEB_STACKSIZE   200

// ////////////////////////////////////////////////////////////////////////////
// Local Typedefs
// ////////////////////////////////////////////////////////////////////////////

typedef enum
{
    VAR_PROTO_ACTIVATE_REQ = 0,
    VAR_PROTO_NAME_REQ,
    VAR_PROTO_BUS_REQ,
    VAR_PROTO_REQ,
    VAR_PROTO_MINADD_REQ,
    VAR_PROTO_MAXADD_REQ,
    VAR_PROTO_SPEC1_REQ,
    VAR_PROTO_SPEC2_REQ,
    VAR_PROTO_REQ_COUNT
} PROTO_REQ_VARS;

typedef enum
{
    VAR_SET_NR_REQ = 0,
    VAR_SET_ACTIVATE_REQ,
    VAR_SET_NAME_REQ,
    VAR_SET_ADDRESS_REQ,
    VAR_SET_SETTINGS,
    VAR_SET_REQ_COUNT
} SET_REQ_VARS;

typedef enum
{
    NAV_CLOSE = 0,
    NAV_SUBNAV,
    NAV_END,
    NAV_SUBNAVEND
} NAV_CONTROL;

typedef struct
{
    WORD u16StringId;
    ROM BYTE * pFilename;
    NAV_CONTROL eNavControl;
} sNavigation;


// ////////////////////////////////////////////////////////////////////////////
// Local Variables
// ////////////////////////////////////////////////////////////////////////////

static BYTE str[WEB_STACKSIZE];
static BYTE * pStr;
static BYTE _currentProcessingIdx = 0;

ROM sNavigation _asROMNavigation[] =
{
    PROJECT_WEBSITES
};


// Local Function Prototypes

static BYTE _u8OptionROM(auto BOOL bSel, auto BYTE u8Val, auto char * pu8Dest, auto ROM BYTE * pu8String);
static BYTE _u8RadioROM(auto ROM BYTE * pu8Name, auto DWORD u32Val, auto BOOL bSel, auto BYTE * pu8Dest);
static void _loadNavigation(WORD u16NavId, ROM sNavigation * pNavEntry);

#ifdef _SRCP
static BYTE _u8Option(auto BOOL bSel, auto BYTE u8Val, auto char * pu8Dest, auto BYTE * pu8String);
static BYTE _u8CheckboxROM(auto ROM BYTE * pu8Name, auto BYTE u8Val, auto BOOL bSel, auto BYTE * pu8Dest);
static BYTE _u8TextROM(auto ROM BYTE * pu8Name, auto BYTE * pu8Val, auto BYTE u8Size, auto BYTE * pu8Dest);
static BYTE _u8Radio(auto BYTE * pu8Name, auto DWORD u32Val, auto BOOL bSel, auto BYTE * pu8Dest);
static BYTE _u8HiddenROM(auto ROM BYTE * pu8Name, auto BYTE u8Val, auto BYTE * pu8Dest);
#endif

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_string(WORD u16StringId)
{
    TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(u16StringId));
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_header(WORD u16NavId)
{
    if(curHTTP.callbackPos == 0)
    {
        // Include the head line.
        TCPPutROMString(sktHTTP, (ROM BYTE *)"<h1>eWicht ");
        TCPPutROMString(sktHTTP, StrTbl_cau8GetStringPointer(STRTBLID_CONFIGURATION));
        TCPPutROMString(sktHTTP, (ROM BYTE *)"</h1>");

        // Include the navigation.
        TCPPutROMString(sktHTTP, (ROM BYTE *)"<ul id=\"nav\">");
    }

    if (curHTTP.callbackPos < sizeof(_asROMNavigation)/sizeof(sNavigation))
    {
        _loadNavigation(u16NavId, &_asROMNavigation[curHTTP.callbackPos++]);
    }
    else
        curHTTP.callbackPos = 0;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static void _loadNavigation(WORD u16NavId, ROM sNavigation * pNavEntry)
{
    TCPPutROMString(sktHTTP, (ROM BYTE *)"<li><a ");
    if(u16NavId == pNavEntry->u16StringId)
    {
        TCPPutROMString(sktHTTP, (ROM BYTE *)"class=\"active\" ");
    }
    TCPPutROMString(sktHTTP, (ROM BYTE *)"href=\"");
    TCPPutROMString(sktHTTP, pNavEntry->pFilename);
    TCPPutROMString(sktHTTP, (ROM BYTE *)"\">");
    TCPPutROMString(sktHTTP, StrTbl_cau8GetStringPointer(pNavEntry->u16StringId));
    TCPPutROMString(sktHTTP, (ROM BYTE *)"</a>");

    switch(pNavEntry->eNavControl)
    {
    case NAV_CLOSE:
        TCPPutROMString(sktHTTP, (ROM BYTE *)"</li>");
        break;
    case NAV_SUBNAV:
        TCPPutROMString(sktHTTP, (ROM BYTE *)"<ul>");
        break;
    case NAV_SUBNAVEND:
        TCPPutROMString(sktHTTP, (ROM BYTE *)"</li></ul></li>");
        break;
    case NAV_END:
        TCPPutROMString(sktHTTP, (ROM BYTE *)"</li></ul>");
        break;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_version(WORD u16Pos)
{
    // Determine the version digit.
    switch(u16Pos)
    {
    case VAR_FIRMWARE_VERSION_MAJOR:
        TCPPut(sktHTTP, FIRMWARE_VERSION_MAJOR+0x30);
        break;

    case VAR_FIRMWARE_VERSION_MINOR:
        TCPPut(sktHTTP, FIRMWARE_VERSION_MINOR+0x30);
        break;

    case VAR_FIRMWARE_VERSION_STRING:
        TCPPutROMString(sktHTTP, (ROM char *) PROJECT_NAME " ");
        TCPPutROMString(sktHTTP, (ROM char *) FIRMWARE_VERSION_STRING " ");
        TCPPutROMString(sktHTTP, (ROM char*)__DATE__);
        break;

    case VAR_BOOTLOADER_VERSION:
        {
            LONG version;

            memcpypgm2ram((void *)&version, BOOTVERSION, sizeof(version));

            // First bootloader had no version id (only unwritten flash with value -1).
            // Handle this version like version 1:
            if (version == -1)
            {
                version = 1;
            }

            sprintf(str, (ROM char *)"%lu", version);
            TCPPutString(sktHTTP, str);
        }
        break;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_macaddress(void)
{
    // Format the entire string
    BYTE i = 0;
    while(1)
    {
        TCPPut(sktHTTP, btohexa_high(pu8MAC[i]));
        TCPPut(sktHTTP, btohexa_low(pu8MAC[i]));

        if(++i == 6)
        {
            break;
        }
        TCPPut(sktHTTP, '-');
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_ip(WORD u16Pos)
{
    // Format the entire string
    BYTE i;
    DWORD helper = 0;
    BYTE * pDataSource = (BYTE*) &helper;

    switch(u16Pos)
    {
        case VAR_IP_ADDRESS:
            pDataSource = (BYTE*)&sIPConfig.MyIPAddr;
            break;

        case VAR_SUBNET_MASK:
            pDataSource = (BYTE*)&sIPConfig.MyMask;
            break;

        case VAR_GATEWAY_ADDRESS:
            pDataSource = (BYTE*)&sIPConfig.MyGateway;
            break;

        case VAR_CONNECTED_SERVER_IP:
            if (ApplIsConnected())
            {
                pDataSource = (BYTE*)ApplGetServerIP();
            }
            break;

        case VAR_MAN_IP_ADDRESS:
            pDataSource = (BYTE*)&sPCommonConfig.ManIPAddr;
            break;

        case VAR_MAN_SUBNET_MASK:
            helper = IPConvertSubnetToMask(sPCommonConfig.ManMask);
            break;

        case VAR_MAN_GATEWAY_ADDRESS:
            pDataSource = (BYTE*)&sPCommonConfig.ManGateway;
            break;

        case VAR_SERVER_IP:
            pDataSource = (BYTE*)&sPApplConfig.sSrvIPAdd;
            break;

        case VAR_IP_ADDRESS_EEPROM:
            XEEReadArray(BOOTUP_EEPROM_ADD+offsetof(PCOMMON_CONFIG, ManIPAddr), (BYTE *)&helper, sizeof(IP_ADDR));
            break;

        case VAR_SUBNET_MASK_EEPROM:
            XEEReadArray(BOOTUP_EEPROM_ADD+offsetof(PCOMMON_CONFIG, ManMask), &i, 1);
            helper = IPConvertSubnetToMask(i);
            break;

        case VAR_GATEWAY_ADDRESS_EEPROM:
            XEEReadArray(BOOTUP_EEPROM_ADD+offsetof(PCOMMON_CONFIG, ManGateway), (BYTE *)&helper, sizeof(IP_ADDR));
            break;

        case VAR_SERVER_IP_EEPROM:
            XEEReadArray(APPL_EEPROM_ADD+offsetof(SPAPPLDATA, sSrvIPAdd), (BYTE *)&helper, sizeof(IP_ADDR));
            break;
    }
        
    if (pDataSource==0)
    {
        TCPPutROMString(sktHTTP,(ROM char*)"0.0.0.0");
    }
    else
    {
        i = 0;
        
        while(1)
        {
            itoa((WORD)*pDataSource++, str);
            TCPPutString(sktHTTP,str);
            if(++i == 4)
            {
                break;
            }
            TCPPut(sktHTTP, '.');
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_addressmode(void)
{
    if(sPCommonConfig.Flags.bIsDHCPEnabled)
    {
        TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_AUTO));
    }
    else
    {
        TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_MANUAL));
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_askforaddressmode(void)
{
    sIPFlags flags;
    XEEReadArray(BOOTUP_EEPROM_ADD+offsetof(PCOMMON_CONFIG, Flags), (BYTE *)&flags, sizeof(sIPFlags));


    _u8RadioROM((ROM char *)"ubm", TRUE, flags.bIsDHCPEnabled==TRUE, str);
    TCPPutString(sktHTTP, str);
    TCPPut(sktHTTP, ' ');
    TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_AUTO));

    TCPPutROMString(sktHTTP,(ROM char *)"<br>");

    _u8RadioROM((ROM char *)"ubm", FALSE, flags.bIsDHCPEnabled==FALSE, str);
    TCPPutString(sktHTTP, str);
    TCPPut(sktHTTP, ' ');
    TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_MANUAL));
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_hostname(void)
{
    TCPPutROMString(sktHTTP, HOSTNAME);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_mdns(void)
{
    if(eGetMDNSState() == MDNS_HAS_STOPPED)
    {
        TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_INACTIVE));
    }
    else
    {
        TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_ACTIVE));
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_connection(void)
{
    if (ApplIsConnected()==TRUE)
    {
        TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_ACTIVE));
    }
    else
    {
        TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_INACTIVE));
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_serverport(void)
{
    WORD port = ApplGetServerPort().Val;
    if (ApplIsConnected()==FALSE)
    {
        port = 0;
    }
    sprintf(str, (ROM char *) "%5hu", port);
    TCPPutString(sktHTTP, str);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_locodir(void)
{
    if (sPApplConfig.sFlags.bToggleLocoDirMode==TOGGLEDIRMODE_CLICK)
    {
        TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_CLICK));
    }
    else
    {
        TCPPutROMString(sktHTTP,StrTbl_cau8GetStringPointer(STRTBLID_ZEROPOINT));
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_toggledir(void)
{
    WORD len = TCPIsPutReady(sktHTTP);
    BOOL bFlag = FALSE;

    if(curHTTP.callbackPos == 0)
    {
        pStr = str;
        curHTTP.callbackPos = 
            _u8OptionROM(!sPApplConfig.sFlags.bToggleLocoDirMode, 
                         TOGGLEDIRMODE_CLICK, 
                         pStr, 
                         StrTbl_cau8GetStringPointer(STRTBLID_CLICK));

        curHTTP.callbackPos += 
            _u8OptionROM(sPApplConfig.sFlags.bToggleLocoDirMode, 
                         TOGGLEDIRMODE_ZERO, 
                         &pStr[curHTTP.callbackPos],
                         StrTbl_cau8GetStringPointer(STRTBLID_ZEROPOINT));
    }

    if (len > curHTTP.callbackPos)
    {
        len = curHTTP.callbackPos;
    }

    TCPPutArray(sktHTTP, pStr, len);
    pStr+=len;
    curHTTP.callbackPos-= len;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmllanguage(void)
{
    sprintf(str, 
            (ROM char *)"%hhu", 
            sPCommonConfig.u8LanguageID);
    TCPPutString(sktHTTP, str);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_ledlight(void)
{
    sprintf(str, (ROM char *)"%hhu", sPCommonConfig.u8LCDLight);
    TCPPutString(sktHTTP, str);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmlip(void)
{
    TCPPutROMString(sktHTTP, (ROM char *)"autoip=\"");

    if (sPCommonConfig.Flags.bIsDHCPEnabled == TRUE)
    {
        // No IP settings if DHCP (resp. AutoIP) is enabled.
        TCPPut(sktHTTP, '1');
    }
    else
    {
        TCPPut(sktHTTP, '0');
        TCPPutROMString(sktHTTP, (ROM char *)"ip=\"");
        HTTPPrint_ip(VAR_MAN_IP_ADDRESS);
        TCPPutROMString(sktHTTP, (ROM char *)"\" sub=\"");
        HTTPPrint_ip(VAR_MAN_SUBNET_MASK);
        TCPPutROMString(sktHTTP, (ROM char *)"\" gate=\"");
        HTTPPrint_ip(VAR_MAN_GATEWAY_ADDRESS);
    }
    TCPPut(sktHTTP, '\"');
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmltoggle(void)
{
    str[0] = '0';
    str[1] = 0;
    if (sPApplConfig.sFlags.bToggleLocoDirMode)
    {
        str[0] = '1';
    }
    TCPPutString(sktHTTP, str);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_serverurl(void)
{
    SEARCH_MODE mode;
    XEEReadArray(APPL_EEPROM_ADD + offsetof(SPAPPLDATA, eFindMode), (BYTE *)&mode, sizeof(SEARCH_MODE));

    switch(mode)
    {
        case SEARCH_UNKNOWN:
            return;
        
        case SEARCH_IP:
            {
                WORD port;
                HTTPPrint_ip(VAR_SERVER_IP_EEPROM);
                XEEReadArray(APPL_EEPROM_ADD + offsetof(SPAPPLDATA, sIPPort), (BYTE *)&port, 2);
                sprintf(str, (ROM char *)":%hu", port);
            }
            break;

        case SEARCH_NAME:
            {
                WORD port;
                XEEReadArray(APPL_EEPROM_ADD + offsetof(SPAPPLDATA, au8Name), str, LCD_CHARS_IN_A_ROW+1);
                XEEReadArray(APPL_EEPROM_ADD + offsetof(SPAPPLDATA, sNamePort), (BYTE *)&port, 2);
                sprintf(&str[strlen(str)], (ROM char *)":%hu", port);
            }
            break;

        case SEARCH_SERVICE:
            XEEReadArray(APPL_EEPROM_ADD + offsetof(SPAPPLDATA, au8Service), str, LCD_CHARS_IN_A_ROW+1);
            break;
    }


    TCPPutString(sktHTTP, str);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_language(void)
{
    WORD len = TCPIsPutReady(sktHTTP);
    BOOL bFlag = FALSE;

    if(curHTTP.callbackPos == 0)
    {
        pStr = str;
        
        curHTTP.callbackPos = 
            _u8OptionROM(sPCommonConfig.u8LanguageID==LANGID_GERMAN, 
                         LANGID_GERMAN,
                         pStr, 
                         StrTbl_cau8GetLanguageStringPointer(LANGID_GERMAN, STRTBLID_LANGUAGE_NAME));

        curHTTP.callbackPos += 
            _u8OptionROM(sPCommonConfig.u8LanguageID==LANGID_ENGLISH, 
                         LANGID_ENGLISH,
                         &pStr[curHTTP.callbackPos],
                         StrTbl_cau8GetLanguageStringPointer(LANGID_ENGLISH, STRTBLID_LANGUAGE_NAME));
    }

    if (len > curHTTP.callbackPos)
        len = curHTTP.callbackPos;

    TCPPutArray(sktHTTP, pStr, len);
    pStr+=len;
    curHTTP.callbackPos -= len;
}


// ////////////////////////////////////////////////////////////////////////////
#ifdef _SRCP
// ////////////////////////////////////////////////////////////////////////////

#include "srcp.h"

void HTTPPrint_locoproto(void)
{
    if (sPSRCPConfig.sFlags.bGLAskForProto == TRUE)
    {
        TCPPutROMString(sktHTTP, StrTbl_cau8GetStringPointer(STRTBLID_ON));
    }
    else
    {
        TCPPutROMString(sktHTTP, StrTbl_cau8GetStringPointer(STRTBLID_OFF));
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_accproto(void)
{
    if (sPSRCPConfig.sFlags.bGAAskForProto == TRUE)
    {
        TCPPutROMString(sktHTTP, StrTbl_cau8GetStringPointer(STRTBLID_ON));
    }
    else
    {
        TCPPutROMString(sktHTTP, StrTbl_cau8GetStringPointer(STRTBLID_OFF));
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmldelay(void)
{
    sprintf(str, (ROM char *) "%ld", sPSRCPConfig.s32GADelay);
    TCPPutString(sktHTTP, str);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_askfordelay(void)
{
    BYTE num[20];
    sprintf(num, (ROM char *) "%ld", sPSRCPConfig.s32GADelay);
    _u8TextROM((ROM char *)"dV", num, 9, str);
            
    TCPPutString(sktHTTP, str);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_askforproto(WORD u16IsGL)
{
    WORD len = TCPIsPutReady(sktHTTP);
    BOOL bFlag = FALSE;

    if (u16IsGL)
    {
        bFlag = sPSRCPConfig.sFlags.bGLAskForProto;
    }
    else
    {
        bFlag = sPSRCPConfig.sFlags.bGAAskForProto;
    }   

    if(curHTTP.callbackPos == 0)
    {
        pStr = str;
        curHTTP.callbackPos = 
            _u8OptionROM(!bFlag, 
                         0, 
                         pStr, 
                         StrTbl_cau8GetStringPointer(STRTBLID_OFF));

        curHTTP.callbackPos += _u8OptionROM(bFlag, 
                         1, 
                         &pStr[curHTTP.callbackPos],
                         StrTbl_cau8GetStringPointer(STRTBLID_ON));
    }

    if (len > curHTTP.callbackPos)
    {
        len = curHTTP.callbackPos;
    }

    TCPPutArray(sktHTTP, pStr, len);
    pStr+=len;
    curHTTP.callbackPos -= len;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmlproto(WORD u16Pos)
{
    SPPROTOCOL protocoldata;
    WORD len;

    SRCP_GetProtoFromEEPROM((BYTE)u16Pos, &protocoldata);

    if (protocoldata.sFlags.bActive == FALSE)
    {
        return;
    }

    len = TCPIsPutReady(sktHTTP);

    TCPPutROMString(sktHTTP, (ROM char *) "\n<srcpproto ");
    sprintf(str, (ROM char *)" id=\"%hu\">\n\t<data", u16Pos);
    TCPPutString(sktHTTP, str);

    TCPPutROMString(sktHTTP, (ROM char *)" name=\"");
    XMLPutString(sktHTTP, protocoldata.au8Desc);
    TCPPut(sktHTTP, '\"');

    TCPPutROMString(sktHTTP, (ROM char *)" proto=\"");
    XMLPutString(sktHTTP, protocoldata.au8Proto);
    TCPPut(sktHTTP, '\"');

    sprintf(str, (ROM char *)" bus=\"%hhu\" minadd=\"%hu\" maxadd=\"%hu\"", 
            protocoldata.u8Bus, protocoldata.u16MinAdd, protocoldata.u16MaxAdd);
    TCPPutString(sktHTTP, str);

    // Check for accessory:
    if (u16Pos >= MAX_PROTO_SLOTS)
    {
        sprintf(str, (ROM char *) " minport=\"%hhu\" maxport=\"%hhu\"", 
            protocoldata.uSpec.sGA.u8MinP, protocoldata.uSpec.sGA.u8MaxP);
    }
    else
    {
        sprintf(str, (ROM char *) " steps=\"%hhu\" funcs=\"%hhu\"", 
            protocoldata.uSpec.sGL.u8MaxSteps, protocoldata.uSpec.sGL.u8NrFunc);
    }

    TCPPutString(sktHTTP, str);
    TCPPutROMString(sktHTTP, (ROM char *) "/></srcpproto>\n");
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmlset(WORD u16SetIdx)
{
    SPSET setdata;
    SRCP_GetSetFromEEPROM((BYTE)u16SetIdx, &setdata);

    if (setdata.sFlags.bActive == FALSE)
    {
        return;
    }

    TCPPutROMString(sktHTTP, (ROM char *) "\n<srcpdb ");

    sprintf(str, (ROM char *)"id=\"%hu\">\n\t<data", u16SetIdx);
    TCPPutString(sktHTTP, str);
    TCPPutROMString(sktHTTP, (ROM char *)" name=\"");
    XMLPutString(sktHTTP, setdata.au8Name);
    sprintf(str, (ROM char *)"\" bus=\"%hhu\"", setdata.u8BusNr);
    TCPPutString(sktHTTP, str);
    TCPPutROMString(sktHTTP, (ROM char *)" proto=\"");
    XMLPutString(sktHTTP, setdata.au8Proto);
    sprintf(str, (ROM char *)"\" add=\"%lu\"", setdata.u32Address);
    TCPPutString(sktHTTP, str);

    if (u16SetIdx & SRCP_EEPROMSET_GA_MASK)
    {
        sprintf(str, (ROM char *)" minport=\"%hu\" maxport=\"%hu\" delay=\"%ld\"", 
            setdata.uSpec.sGA.u8MinP, setdata.uSpec.sGA.u8MaxP, setdata.uSpec.sGA.s32Delay);
    }
    else
    {
        sprintf(str, (ROM char *)" steps=\"%hu\" funcs=\"%hu\" maxspeed=\"%hu\" togglemask=\"%lu\"", 
            setdata.uSpec.sGL.u8MaxSteps, setdata.uSpec.sGL.u8NrFunc, setdata.uSpec.sGL.u16MaxV, setdata.uSpec.sGL.u32FuncToggleMask);
    }

    TCPPutString(sktHTTP, str);
    TCPPutROMString(sktHTTP, (ROM char *) "/></srcpdb>\n");
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE u8Colcount;
static BOOL bStartNewCol;

void HTTPPrint_eepromset(WORD u16SetIdx)
{
    WORD len = TCPIsPutReady(sktHTTP);

    if(curHTTP.callbackPos == 0)
    {
        // First time here!
        u8Colcount = 0;
        bStartNewCol = TRUE;

        // Starting the row...
        strcpypgm2ram(str, (ROM char *) "<tr>");
        pStr = &str[4];
    }

    if (bStartNewCol == TRUE)   
    {
        SPSET setdata;
        BYTE num[6];
        SRCP_GetSetFromEEPROM(u16SetIdx, &setdata);

        strcpypgm2ram(pStr, (ROM char *) "<td>");
        pStr += 4;

        switch(u8Colcount++)
        {
            case VAR_SET_NR_REQ:
            {
                BYTE nr = u16SetIdx & SRCP_EEPROMSET_IDX_MASK;
                pStr += _u8HiddenROM((ROM BYTE *)"A", u16SetIdx, pStr);
                pStr += sprintf(pStr, (ROM char *) "S%hu", nr+1);
                break;
            }

            case VAR_SET_ACTIVATE_REQ:
                pStr += _u8CheckboxROM((ROM char *)"c", 
                                    u16SetIdx, 
                                    (setdata.sFlags.bActive),
                                    pStr);
                break;

            case VAR_SET_NAME_REQ:
                pStr += _u8TextROM((ROM char *)"n", setdata.au8Name, SRCP_NAME_MAXLEN, pStr);
                break;

            case VAR_SET_ADDRESS_REQ:
                sprintf(num, (ROM char *) "%lu", setdata.u32Address);
                pStr += _u8TextROM((ROM char *)"usm", num, 5, pStr);
                break;

            case VAR_SET_SETTINGS:
                if (setdata.sFlags.bGL == FALSE)
                {
                    strcpypgm2ram(pStr, (ROM char *)"<a href=\"accset.htm?");
                }
                else
                {
                    strcpypgm2ram(pStr, (ROM char *)"<a href=\"locoset.htm?");
                }

                pStr = &str[strlen(str)];
                sprintf(pStr, (ROM char *)"%hhu\">%HS...</a>", u16SetIdx, StrTbl_cau8GetStringPointer(STRTBLID_CONFIGURE));
                pStr = &str[strlen(str)];
                pStr += _u8HiddenROM((ROM BYTE *)"E", u16SetIdx, pStr);
                break;
        }

        strcpypgm2ram(pStr, (ROM char *) "</td>");
        pStr += 5;

        // Have we reached the last column?
        if (u8Colcount == VAR_PROTO_REQ_COUNT)
        {
            // Lets close the row!
            strcpypgm2ram(pStr, (ROM char *) "</tr>");
        }

        bStartNewCol = FALSE;
        curHTTP.callbackPos = strlen(str);
        pStr = str;
    }

#ifdef __DEBUG
    if(curHTTP.callbackPos>WEB_STACKSIZE)
    {
        while(1);
    }
#endif

    if (len > curHTTP.callbackPos)
    {
        len = curHTTP.callbackPos;
    }

    TCPPutArray(sktHTTP, pStr, len);
    curHTTP.callbackPos-= len;

    if (curHTTP.callbackPos == 0)
    {
        bStartNewCol = TRUE;

        if (u8Colcount == VAR_SET_REQ_COUNT)
        {
            // Finished writing the entire row.
            return;
        }

        // Ensure that the function is called again.
        curHTTP.callbackPos = 1;
    }
    else
    {
        pStr+=len;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_protoreq(WORD u16Pos)
{
    WORD len = TCPIsPutReady(sktHTTP);

    if(curHTTP.callbackPos == 0)
    {
        // First time here!
        u8Colcount = 0;
        bStartNewCol = TRUE;
    }

    if (bStartNewCol == TRUE)   
    {
        SPPROTOCOL protocoldata;
        BYTE num[6];
        SRCP_GetProtoFromEEPROM(u16Pos, &protocoldata);

        pStr = str;
        if (u8Colcount == 0)
        {
            strcpypgm2ram(pStr, (ROM char *) "<tr>");
            pStr = &str[4];
        }

        strcpypgm2ram(pStr, (ROM char *) "<td>");
        pStr += 4;

        switch(u8Colcount++)
        {
            case VAR_PROTO_ACTIVATE_REQ:
                pStr += _u8HiddenROM((ROM BYTE *)"A", u16Pos, pStr);
                pStr += _u8CheckboxROM((ROM char *)"c", 
                                       u16Pos, 
                                       protocoldata.sFlags.bActive, 
                                       pStr);
                break;

            case VAR_PROTO_NAME_REQ:
                pStr += _u8TextROM((ROM char *)"n", protocoldata.au8Desc, 16, pStr);
                break;

            case VAR_PROTO_BUS_REQ:
                sprintf(num, (ROM char *) "%hhu", protocoldata.u8Bus);
                pStr += _u8TextROM((ROM char *)"ubb", num, 3, pStr);
                break;

            case VAR_PROTO_REQ:
                pStr += _u8TextROM((ROM char *)"p", protocoldata.au8Proto, 3, pStr);
                break;

            case VAR_PROTO_MINADD_REQ:
                sprintf(num, (ROM char *) "%hu", protocoldata.u16MinAdd);
                pStr += _u8TextROM((ROM char *)"usm", num, 5, pStr);
                break;  
        
            case VAR_PROTO_MAXADD_REQ:
                sprintf(num, (ROM char *) "%hu", protocoldata.u16MaxAdd);
                pStr += _u8TextROM((ROM char *)"usx", num, 5, pStr);
                break;

            case VAR_PROTO_SPEC1_REQ:
                sprintf(num, (ROM char *) "%hhu", protocoldata.uSpec.sGL.u8MaxSteps);
                if (protocoldata.sFlags.bGL == TRUE)
                {
                    pStr += _u8TextROM((ROM char *)"ubs", num, 3, pStr);
                }
                else
                {
                    pStr += _u8TextROM((ROM char *)"ubq", num, 3, pStr);
                }
                break;

            case VAR_PROTO_SPEC2_REQ:
                sprintf(num, (ROM char *) "%hhu", protocoldata.uSpec.sGL.u8NrFunc);
                if (protocoldata.sFlags.bGL == TRUE)
                {
                    pStr += _u8TextROM((ROM char *)"ubf", num, 3, pStr);
                }
                else
                {
                    pStr += _u8TextROM((ROM char *)"ubr", num, 3, pStr);
                }
                pStr += _u8HiddenROM((ROM BYTE *)"E", u16Pos, pStr);
                break;
        }

        strcpypgm2ram(pStr, (ROM char *) "</td>");
        pStr += 5;

        // Have we reached the last column?
        if (u8Colcount == VAR_PROTO_REQ_COUNT)
        {
            // Lets close the row!
            strcpypgm2ram(pStr, (ROM char *) "</tr>");
        }

        bStartNewCol = FALSE;
        curHTTP.callbackPos = strlen(str);
        pStr = str;
    }

#ifdef __DEBUG
    if(curHTTP.callbackPos>WEB_STACKSIZE)
    {
        while(1);
    }
#endif

    if (len > curHTTP.callbackPos)
    {
        len = curHTTP.callbackPos;
    }

    TCPPutArray(sktHTTP, pStr, len);
    curHTTP.callbackPos-= len;

    if (curHTTP.callbackPos == 0)
    {
        bStartNewCol = TRUE;

        if (u8Colcount == VAR_PROTO_REQ_COUNT)
        {
            // Finished writing the entire row.
            return;
        }

        // Ensure that the function is called again.
        curHTTP.callbackPos = 1;
    }
    else
    {
        pStr+=len;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmllocoprotoreq(void)
{
    if (sPSRCPConfig.sFlags.bGLAskForProto)
    {
        TCPPut(sktHTTP, '1');
    }
    else
    {
        TCPPut(sktHTTP, '0');
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmlaccprotoreq(void)
{
    if (sPSRCPConfig.sFlags.bGAAskForProto)
    {
        TCPPut(sktHTTP, '1');
    }
    else
    {
        TCPPut(sktHTTP, '0');
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmllocostandard(void)
{
    sprintf(str, (ROM char *)"%hhu", sPSRCPConfig.u8DefaultGLProtoId);
    TCPPutString(sktHTTP, str); 
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_xmlaccstandard(void)
{
    sprintf(str, (ROM char *)"%hhu", sPSRCPConfig.u8DefaultGAProtoId);
    TCPPutString(sktHTTP, str); 
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_locostandard(void)
{
    auto WORD len = TCPIsPutReady(sktHTTP);

    if(curHTTP.callbackPos == 0)
    {
        // First time here!
        _u8OptionROM(sPSRCPConfig.u8DefaultGLProtoId == SRCP_SERVERCACHE_ID,
                             SRCP_SERVERCACHE_ID, 
                             str, 
                             StrTbl_cau8GetStringPointer(STRTBLID_SERVER_CACHE));

        pStr = &str[strlen(str)];
        _u8OptionROM(sPSRCPConfig.u8DefaultGLProtoId == SRCP_EEPROMSET_ID,
                             SRCP_EEPROMSET_ID, 
                             pStr, 
                             StrTbl_cau8GetStringPointer(STRTBLID_DATABASE));

        pStr = str;
        // As long as callbackPos is not zero the function is called again and 
        // again.
        curHTTP.callbackPos = 1;
    }
    else if ((strlen(pStr) == 0) && (curHTTP.callbackPos < 9))
    {
        SPPROTOCOL protocoldata;
        SRCP_GetProtoFromEEPROM(curHTTP.callbackPos-1, &protocoldata);

        if (protocoldata.sFlags.bActive)
        {
            _u8Option(sPSRCPConfig.u8DefaultGLProtoId == (curHTTP.callbackPos-1), 
                                        curHTTP.callbackPos-1, 
                                        str,
                                        protocoldata.au8Desc);
            pStr = str;
        }
        curHTTP.callbackPos++;
    }

    if (len > strlen(pStr))
    {
        len = strlen(pStr);
    }

    TCPPutArray(sktHTTP, pStr, len);
    pStr+=len;
    
    if ((strlen(pStr) == 0) && (curHTTP.callbackPos == 9))
    {
        curHTTP.callbackPos = 0;
        return;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_accstandard(void)
{
    auto WORD len = TCPIsPutReady(sktHTTP);

    if(curHTTP.callbackPos == 0)
    {
        // First time here!
        _u8OptionROM(sPSRCPConfig.u8DefaultGAProtoId == SRCP_EEPROMSET_ID,
                             SRCP_EEPROMSET_ID, 
                             str, 
                             StrTbl_cau8GetStringPointer(STRTBLID_DATABASE));

        pStr = str;
        // As long as callbackPos is not zero the function is called again and 
        // again.
        curHTTP.callbackPos = 8;
    }
    
    if ((strlen(pStr) == 0)&&(curHTTP.callbackPos<16))
    {
        SPPROTOCOL protocoldata;
        SRCP_GetProtoFromEEPROM(curHTTP.callbackPos, &protocoldata);

        if (protocoldata.sFlags.bActive)
        {
            _u8Option(sPSRCPConfig.u8DefaultGAProtoId == (curHTTP.callbackPos), 
                                        curHTTP.callbackPos, 
                                        str,
                                        protocoldata.au8Desc);
            pStr = str;
        }
        curHTTP.callbackPos++;
    }

    if (len > strlen(pStr))
    {
        len = strlen(pStr);
    }

    TCPPutArray(sktHTTP, pStr, len);
    pStr+=len;
    
    if ((strlen(pStr) == 0) && (curHTTP.callbackPos == 16))
    {
        curHTTP.callbackPos = 0;
        return;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setid(void)
{
    auto BYTE tmp[6];
    btoa((_currentProcessingIdx & SRCP_EEPROMSET_IDX_MASK)+1, tmp);
    TCPPutString(sktHTTP, tmp);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setidx(void)
{
    auto BYTE tmp[6];
    btoa(_currentProcessingIdx, tmp);
    TCPPutString(sktHTTP, tmp);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setname(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    BYTE * pStr = &str[sizeof(SPSET)];

    _u8TextROM((ROM char *)"n",pSetdata->au8Name,SRCP_NAME_MAXLEN,pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setaddress(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[10];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    sprintf(num, (ROM char *) "%lu", pSetdata->u32Address);
    _u8TextROM((ROM char *)"usm", num, 5, pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setmaxspeed(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[6];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    sprintf(num, (ROM char *) "%hu", pSetdata->uSpec.sGL.u16MaxV);
    _u8TextROM((ROM char *)"ush", num, 5, pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setbus(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[4];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    sprintf(num, (ROM char *) "%hhu", pSetdata->u8BusNr);
    _u8TextROM((ROM char *)"ubb", num, 3, pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setprotocol(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[4];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    _u8TextROM((ROM char *)"p", pSetdata->au8Proto, 3, pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setsteps(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[4];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    sprintf(num, (ROM char *) "%hhu", pSetdata->uSpec.sGL.u8MaxSteps);
    _u8TextROM((ROM char *)"ubs", num, 3, pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setfunctions(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[4];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    sprintf(num, (ROM char *) "%hhu", pSetdata->uSpec.sGL.u8NrFunc);
    _u8TextROM((ROM char *)"ubf", num, 3, pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setprotos(WORD u16ProtoId)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto SPPROTOCOL protocoldata;
    auto BYTE num[4];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    SRCP_GetProtoFromEEPROM((BYTE)u16ProtoId, &protocoldata);

    if (protocoldata.sFlags.bActive == FALSE)
    {
        return;
    }

    TCPPutROMString(sktHTTP, (ROM char *)"<tr><td>");
    _u8RadioROM((ROM char *)"P", u16ProtoId, FALSE, pStr);
    TCPPutString(sktHTTP, pStr);
    TCPPutROMString(sktHTTP, (ROM char *)"</td><td>");
    TCPPutString(sktHTTP, protocoldata.au8Desc);
    TCPPutROMString(sktHTTP, (ROM char *)"</td><td>");
    sprintf(num, (ROM char *) "%hhu", protocoldata.u8Bus);
    TCPPutString(sktHTTP, num);
    TCPPutROMString(sktHTTP, (ROM char *)"</td><td>");
    TCPPutString(sktHTTP, protocoldata.au8Proto);

    if (pSetdata->sFlags.bGL == TRUE)
    {
        TCPPutROMString(sktHTTP, (ROM char *)"</td><td>");
        sprintf(num, (ROM char *) "%hhu", protocoldata.uSpec.sGL.u8MaxSteps);
        TCPPutString(sktHTTP, num);
        TCPPutROMString(sktHTTP, (ROM char *)"</td><td>");
        sprintf(num, (ROM char *) "%hhu", protocoldata.uSpec.sGL.u8NrFunc);
        TCPPutString(sktHTTP, num);
    }
    else
    {
        TCPPutROMString(sktHTTP, (ROM char *)"</td><td>");
        sprintf(num, (ROM char *) "%hhu", protocoldata.uSpec.sGA.u8MinP);
        TCPPutString(sktHTTP, num);
        TCPPutROMString(sktHTTP, (ROM char *)"</td><td>");
        sprintf(num, (ROM char *) "%hhu", protocoldata.uSpec.sGA.u8MaxP);
        TCPPutString(sktHTTP, num);
    }

    TCPPutROMString(sktHTTP, (ROM char *)"</td></tr>");
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setfunction(WORD u16FunctionNr, WORD u16Mode)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE format[4];
    auto DWORD mask;
    auto DWORD valuemask = 0;
    auto WORD i;
    auto BOOL bDefault = FALSE;
    auto BYTE * pStr = &str[sizeof(SPSET)];

    // Build the mask for the current function.
    mask = 0x01;
    for (i = 0; i < u16FunctionNr; i++)
    {
        mask = mask << 1;
    }

    // Set the default value (depends on what is currently configured in the set)
    if ((u16Mode && (pSetdata->uSpec.sGL.u32FuncToggleMask & mask)) ||
        ((u16Mode == 0) && ((pSetdata->uSpec.sGL.u32FuncToggleMask & mask) == 0)))
    {
        bDefault = TRUE;
    }

    if (u16Mode)
    {
        valuemask = mask;
    }

    TCPPutROMString(sktHTTP, (ROM char *)"<td>");
    sprintf(format, (ROM char *) "F%hu", u16FunctionNr);
    _u8Radio(format, valuemask, bDefault, pStr);
    TCPPutString(sktHTTP, pStr);
    TCPPutROMString(sktHTTP, (ROM char *)"</td>");
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setminport(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[4];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    sprintf(num, (ROM char *) "%hhu", pSetdata->uSpec.sGA.u8MinP);
    _u8TextROM((ROM char *)"ubq", num, 3, pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setmaxport(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[4];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    sprintf(num, (ROM char *) "%hhu", pSetdata->uSpec.sGA.u8MaxP);
    _u8TextROM((ROM char *)"ubr", num, 3, pStr);
    TCPPutString(sktHTTP, pStr);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void HTTPPrint_setdelay(void)
{
    auto SPSET * pSetdata = (SPSET *)str;
    auto BYTE num[10];
    auto BYTE * pStr = &str[sizeof(SPSET)];

    sprintf(num, (ROM char *) "%ld", pSetdata->uSpec.sGA.s32Delay);
    _u8TextROM((ROM char *)"dd", num, 9, pStr);
    TCPPutString(sktHTTP, pStr);
}


// ////////////////////////////////////////////////////////////////////////////
#endif  // #ifdef _SRCP
// ////////////////////////////////////////////////////////////////////////////



HTTP_IO_RESULT HTTPExecuteGet(void)
{
    BYTE *ptr;
    BYTE filename[20];
    
    // Load the file name
    // Make sure BYTE filename[] above is large enough for your longest name
    MPFSGetFilename(curHTTP.file, filename, 20);
    

    // Verify the file name
    if(!strcmppgm2ram(filename, (ROM char*)"index.htm"))
    {
        ApplRestart(curHTTP.data[0]=='2');
    }

#ifdef _SRCP
    else if(!strcmppgm2ram(filename, (ROM char*)"locoset.htm")||
            !strcmppgm2ram(filename, (ROM char*)"accset.htm"))
    {
        _currentProcessingIdx = atob(curHTTP.data);
        if (_currentProcessingIdx >= SRCP_EEPROMSET_COUNT)
        {
            _currentProcessingIdx = 0;
        }
        
        SRCP_GetSetFromEEPROM(_currentProcessingIdx, (SPSET *)str);
    }
#endif

    curHTTP.httpStatus = HTTP_REDIRECT;
    strcpy(curHTTP.data, filename);

    // Indicate completion
    return HTTP_IO_DONE;
}


// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

// Define post state machine values
#define SM_READ_NAME       (0u)
#define SM_READ_VALUE      (1u)

#define EXEC_POST_NAME_LENGTH       (5+1)
#define EXEC_POST_FILENAME_LENGTH   (20+1)
#define EXEC_POST_VALUE_LENGTH      (32+1)

#define EXEC_POST_NEEDED_SPACE      (EXEC_POST_NAME_LENGTH+EXEC_POST_FILENAME_LENGTH+EXEC_POST_VALUE_LENGTH)


HTTP_IO_RESULT HTTPExecutePost(void)
{
    auto BYTE * name = str;
    auto BYTE * filename = &str[EXEC_POST_NAME_LENGTH];
    auto BYTE * value = &filename[EXEC_POST_FILENAME_LENGTH];
    
    // Load the file name
    // Make sure BYTE filename[] above is large enough for your longest name
    MPFSGetFilename(curHTTP.file, filename, (EXEC_POST_FILENAME_LENGTH-1));

    // Verify the file name
    if(!strcmppgm2ram(filename, (ROM char*)"file.htm"))
    {
        return ConfigPostFile(str);
    }


    while(1)
    {
        // Fetch the name value pair from the post stream.
        switch(curHTTP.smPost)
        {
        case SM_READ_NAME:
            if(HTTPReadPostName(name, (EXEC_POST_NAME_LENGTH-1)) == HTTP_READ_INCOMPLETE)
            {
                return HTTP_IO_NEED_DATA;
            }

            // Move to the next state, but do not break yet
            curHTTP.smPost = SM_READ_VALUE;
            // Intented fall through... 

        case SM_READ_VALUE:
            if(HTTPReadPostValue(value, (EXEC_POST_VALUE_LENGTH-1)) == HTTP_READ_INCOMPLETE)
            {
                return HTTP_IO_NEED_DATA;
            }

            // Return to read a new name
            curHTTP.smPost = SM_READ_NAME;
            break;
        }

        if (strcmppgm2ram(filename, (ROM char*)"common.htm")==0)
        {
            ProcessCommonData(name, value);
        }

#ifdef _SRCP
        else if (strcmppgm2ram(filename, (ROM char*)"srcp.htm")==0)
        {
            ProcessSRCPData(name, value);
        }
        else if (strcmppgm2ram(filename, (ROM char*)"locoproto.htm")==0)
        {
            ProcessProtoData(&str[EXEC_POST_NEEDED_SPACE], name, value);
        }
        else if (strcmppgm2ram(filename, (ROM char*)"accproto.htm")==0)
        {
            ProcessProtoData(&str[EXEC_POST_NEEDED_SPACE], name, value);
        }
        else if (!strcmppgm2ram(filename, (ROM char*)"locos.htm")==0) 
        {
            ProcessSetData(&str[EXEC_POST_NEEDED_SPACE], name, value);
        }
        else if (!strcmppgm2ram(filename, (ROM char*)"accs.htm")==0)
        {
            ProcessSetData(&str[EXEC_POST_NEEDED_SPACE], name, value);
        }
        else if (!strcmppgm2ram(filename, (ROM char*)"locoset.htm")==0) 
        {
            ProcessSetData(&str[EXEC_POST_NEEDED_SPACE], name, value);
        }
        else if (!strcmppgm2ram(filename, (ROM char*)"accset.htm")==0)
        {
            ProcessSetData(&str[EXEC_POST_NEEDED_SPACE], name, value);
        }
#endif

        if (name[0] == 'R')
        {
            ApplRestart(FALSE); // Restart without factory reset.
            strcpypgm2ram(curHTTP.data, (ROM char*)"index.htm");
            curHTTP.httpStatus = HTTP_REDIRECT;
            return HTTP_IO_DONE;
        }
        else if (name[0] == 'O')
        {
            curHTTP.httpStatus = HTTP_REDIRECT;
            strcpy(curHTTP.data, filename);
            return HTTP_IO_DONE;
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8RadioROM(auto ROM BYTE * pu8Name, auto DWORD u32Val, auto BOOL bSel, auto BYTE * pu8Dest)
{
    auto BYTE len=sprintf(pu8Dest, 
            (ROM char *)"<input type=\"radio\" name=\"%HS\" value=\"%lu\"", 
            pu8Name, u32Val);

    if (bSel==TRUE)
    {
        strcpypgm2ram(&pu8Dest[len], (ROM char *)" checked=\"checked\"");
        len+=18;
    }

    strcpypgm2ram(&pu8Dest[len], (ROM char *)" />");
    return (len+3);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8OptionROM(auto BOOL bSel, auto BYTE u8Val, auto char * pu8Dest, 
                                                          auto ROM BYTE * pu8String)
{
    BYTE len=sprintf(pu8Dest, (ROM char *)"<option value=\"%hhu\"", u8Val);

    if (bSel == TRUE)
    {
        strcpypgm2ram(&pu8Dest[len], (ROM char *)" selected=\"selected\"");
        len += 20;
    }
    pu8Dest[len++] = '>';
    strcpypgm2ram(&pu8Dest[len], (ROM char *)pu8String);
    len += strlenpgm((ROM char *)pu8String);
    strcpypgm2ram(&pu8Dest[len], (ROM char *)"</option>");
    len += 9;

    return len;
}

// ////////////////////////////////////////////////////////////////////////////
#ifdef _SRCP
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8HiddenROM(auto ROM BYTE * pu8Name, auto BYTE u8Val, auto BYTE * pu8Dest)
{
    BYTE len=sprintf(pu8Dest, 
        (ROM char *)"<input type=\"hidden\" name=\"%HS\" value=\"%hhu\" />", 
        pu8Name, u8Val);

    return len;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8Option(auto BOOL bSel, auto BYTE u8Val, auto char * pu8Dest, auto BYTE * pu8String)
{
    BYTE len=sprintf(pu8Dest, (ROM char *)"<option value=\"%hhu\"", u8Val);

    if (bSel == TRUE)
    {
        strcpypgm2ram(&pu8Dest[len], (ROM char *)" selected=\"selected\"");
        len += 20;
    }
    pu8Dest[len++] = '>';
    strcpy(&pu8Dest[len], pu8String);
    len += strlen(pu8String);
    strcpypgm2ram(&pu8Dest[len], (ROM char *)"</option>");
    len += 9;

    return len;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8CheckboxROM(auto ROM BYTE * pu8Name, auto BYTE u8Val, auto BOOL bSel, 
                                                                auto BYTE * pu8Dest)
{
    BYTE len=sprintf(pu8Dest, 
            (ROM char *)"<input type=\"checkbox\" name=\"%HS\" value=\"%hhu\"", 
            pu8Name, u8Val);

    if (bSel==TRUE)
    {
        strcpypgm2ram(&pu8Dest[len], (ROM char *)" checked=\"checked\"");
        len+=18;
    }

    strcpypgm2ram(&pu8Dest[len], (ROM char *)" />");
    return (len+3);
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8TextROM(auto ROM BYTE * pu8Name, auto BYTE * pu8Val, auto BYTE u8Size, 
                    auto BYTE * pu8Dest)
{
    BYTE len=sprintf(pu8Dest, 
            (ROM char *)"<input type=\"text\" name=\"%HS\" value=\"%s\" ", 
            pu8Name, pu8Val);

    len+=sprintf(&pu8Dest[len], 
            (ROM char *)"size=\"%hhu\" maxlength=\"%hhu\" />", 
            u8Size, u8Size);

    return len;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BYTE _u8Radio(auto BYTE * pu8Name, auto DWORD u32Val, auto BOOL bSel, auto BYTE * pu8Dest)
{
    auto BYTE len=sprintf(pu8Dest, 
            (ROM char *)"<input type=\"radio\" name=\"%s\" value=\"%lu\"", 
            pu8Name, u32Val);

    if (bSel==TRUE)
    {
        strcpypgm2ram(&pu8Dest[len], (ROM char *)" checked=\"checked\"");
        len+=18;
    }

    strcpypgm2ram(&pu8Dest[len], (ROM char *)" />");
    return (len+3);
}

// ////////////////////////////////////////////////////////////////////////////
#endif      // #ifdef _SRCP
// ////////////////////////////////////////////////////////////////////////////

---