/*++

File: cgiwrap.c

Demonstrates an executable which can be used to load an ISAPI DLL like
a CGI script.

--*/

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <httpext.h>
#include <stdio.h>
#include <stdlib.h>

//
// These are things that go out in the Response Header
// 

#define HTTP_VER "HTTP/1.0"
#define SERVER_VERSION "Http-Srv-Beta2/1.0"

//
// Simple wrappers for the heap APIS
// 

#define xmalloc(s) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (s))
#define xfree(s)   HeapFree(GetProcessHeap(), 0, (s))

//
// The mandatory exports from the ISAPI DLL
// 

typedef BOOL(WINAPI * VersionProc) (HSE_VERSION_INFO *);
typedef DWORD(*HttpExtProc) (EXTENSION_CONTROL_BLOCK *);


//
// Prototypes of the functions this sample implements
// 

BOOL WINAPI FillExtensionControlBlock(EXTENSION_CONTROL_BLOCK *);
BOOL WINAPI GetServerVariable(HCONN, LPSTR, LPVOID, LPDWORD);
BOOL WINAPI ReadClient(HCONN, LPVOID, LPDWORD);
BOOL WINAPI WriteClient(HCONN, LPVOID, LPDWORD, DWORD);
BOOL WINAPI ServerSupportFunction(HCONN, DWORD, LPVOID, LPDWORD, LPDWORD);
char *MakeDateStr(VOID);
char *GetEnv(char *);


//
// In the startup of this program, we look at our executable name and      
// replace the ".EXE" with ".DLL" to find the ISAPI DLL we need to load.   
// This means that the executable need only be given the same "name" as    
// the DLL to load. There is no recompilation required.                    
//

int __cdecl
main(int argc, char **argv)
{

    HINSTANCE hDll;
    VersionProc GetExtensionVersion;
    HttpExtProc HttpExtensionProc;
    HSE_VERSION_INFO version_info;
    EXTENSION_CONTROL_BLOCK ECB;
    DWORD rc;
    char szModuleFileName[256], *c;


    if (!GetModuleFileName(NULL, szModuleFileName, 256)) {
        fprintf(stderr, "cannot get ModuleFileName %d\n", GetLastError());
        return -1;
    }

    rc = strlen(szModuleFileName);
    c = szModuleFileName + rc - 4;  // Go back to the last "."

    c[1] = 'D';
    c[2] = 'L';
    c[3] = 'L';

    hDll = LoadLibrary(szModuleFileName);   // Load our DLL

    if (!hDll) {
        fprintf(stderr, "Error: Failure to load %s.dll (%d)\n",
            argv[0], GetLastError());
        return -1;
    }

    // 
    // Find the exported functions
    //

    GetExtensionVersion = (VersionProc) GetProcAddress(hDll, 
                                            "GetExtensionVersion");
    if (!GetExtensionVersion) {
        fprintf(stderr, "Can't Get Extension Version %d\n", GetLastError());
        return -1;
    }
    HttpExtensionProc = (HttpExtProc) GetProcAddress(hDll, 
                                          "HttpExtensionProc");
    if (!HttpExtensionProc) {
        fprintf(stderr, "Can't Get Extension proc %d\n", GetLastError());
        return -1;
    }

    //
    // This should really check if the version information matches what 
    // we expect.
    // 

    __try {
        if (!GetExtensionVersion(&version_info)) {
            fprintf(stderr, "Fatal: GetExtensionVersion failed\n");
            return -1;
        }
    }
    __except(1) {
        return -1;
    }

    // 
    // Fill the ECB with the necessary information
    // 

    if (!FillExtensionControlBlock(&ECB)) {
        fprintf(stderr, "Fill Ext Block Failed\n");
        return -1;
    }

    //
    // Call the DLL
    // 

    __try {
        rc = HttpExtensionProc(&ECB);
    }
    __except(1) {
        return -1;
    }


    //
    // We should really free memory (e.g., from GetEnv), but we'll be dead
    // soon enough
    //
    
    if (rc == HSE_STATUS_PENDING)   
        
        //
        // We will exit in ServerSupportFunction
        //

        Sleep(INFINITE);

    return 0;

}


//
// GetServerVariable() is how the DLL calls the main program to figure out
// the environment variables it needs. This is a required function.
// 

BOOL WINAPI
GetServerVariable(HCONN hConn, LPSTR lpszVariableName,
    LPVOID lpBuffer, LPDWORD lpdwSize)
{

    DWORD rc;

    // 
    // We don't really have an HCONN, so we assume a value of 0 (which is
    // passed
    // to the DLL in the ECB by HttpExtensionProc().
    // Hence the check for a non-zero HCONN

    if (hConn) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    rc = GetEnvironmentVariable(lpszVariableName, lpBuffer, *lpdwSize);

    if (!rc) {                  

        //
        // return of 0 indicates the variable was not found
        //
        SetLastError(ERROR_NO_DATA);
        return FALSE;
    }

    if (rc > *lpdwSize) {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }

    //
    // GetEnvironmentVariable does not count the NUL character
    //
    *lpdwSize = rc + 1;         

    return TRUE;

}


//
// Again, we don't have an HCONN, so we simply wrap ReadClient() to
// ReadFile on stdin. The semantics of the two functions are the same
// 

BOOL WINAPI
ReadClient(HCONN hConn, LPVOID lpBuffer, LPDWORD lpdwSize)
{

    return ReadFile(GetStdHandle(STD_INPUT_HANDLE), lpBuffer, (*lpdwSize),
        lpdwSize, NULL);

}


//
// ditto for WriteClient()
// 

BOOL WINAPI
WriteClient(HCONN hConn, LPVOID lpBuffer, LPDWORD lpdwSize,
    DWORD dwReserved)
{

    return WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), lpBuffer, *lpdwSize,
        lpdwSize, NULL);

}


//
// This is a special callback function used by the DLL for certain extra 
// functionality. Look at the API help for details.
// 

BOOL WINAPI
ServerSupportFunction(HCONN hConn, DWORD dwHSERequest,
    LPVOID lpvBuffer, LPDWORD lpdwSize, LPDWORD lpdwDataType)
{

    char *lpszRespBuf;
    char *temp;
    DWORD dwBytes;
    BOOL bRet;

    switch (dwHSERequest) {

    case (HSE_REQ_SEND_RESPONSE_HEADER):
        lpszRespBuf = xmalloc(*lpdwSize + 80);  // accomodate our header

        if (!lpszRespBuf)
            return FALSE;
        wsprintf(lpszRespBuf, "%s %s %s %s\r\n%s", 
            HTTP_VER,
            lpvBuffer ? lpvBuffer : "200 Ok",   // Default response is 200 Ok
            temp = MakeDateStr(),               // Create a time string
            SERVER_VERSION,

        //
        // If this exists, it is a pointer to a data buffer to be sent. 
        //
            lpdwDataType ? (char *) lpdwDataType : NULL);

        xfree(temp);

        dwBytes = strlen(lpszRespBuf);
        bRet = WriteClient(0, lpszRespBuf, &dwBytes, 0);
        xfree(lpszRespBuf);

        break;


    case (HSE_REQ_DONE_WITH_SESSION):

        // 
        // A real server would do cleanup here
        //

        ExitProcess(0);
        break;

    case (HSE_REQ_SEND_URL_REDIRECT_RESP):

        // 
        // This sends a redirect (temporary) to the client.
        // The header construction is similar to RESPONSE_HEADER above.
        // 

        lpszRespBuf = xmalloc(*lpdwSize + 80);
        if (!lpszRespBuf)
            return FALSE;
        wsprintf(lpszRespBuf, "%s %s %s\r\n",
            HTTP_VER,
            "302 Moved Temporarily",
            (lpdwSize > 0) ? lpvBuffer : 0);
        dwBytes = strlen(lpszRespBuf);
        bRet = WriteClient(0, lpszRespBuf, &dwBytes, 0);
        xfree(lpszRespBuf);
        break;

    default:
        return FALSE;
        break;
    }
    return bRet;

}



//
// Makes a string of the date and time from GetSystemTime().
// This is in UTC, as required by the HTTP spec.`
// 

char *
MakeDateStr(void)
{
    SYSTEMTIME systime;
    char *szDate = xmalloc(64);

    char *DaysofWeek[] = 
        {"Sun", "Mon", "Tue", "Wed", "Thurs", "Fri", "Sat"};
    char *Months[] = 
        {"NULL", "Jan", "Feb", "Mar", "Apr", "May", "Jun", 
         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

    GetSystemTime(&systime);

    wsprintf(szDate, "%s, %d %s %d %d:%d.%d", 
        DaysofWeek[systime.wDayOfWeek],
        systime.wDay,
        Months[systime.wMonth],
        systime.wYear,
        systime.wHour, systime.wMinute,
        systime.wSecond);

    return szDate;
}


//
// Fill the ECB up 
// 

BOOL WINAPI
FillExtensionControlBlock(EXTENSION_CONTROL_BLOCK * ECB)
{

    char *temp;

    ECB->cbSize = sizeof (EXTENSION_CONTROL_BLOCK);
    ECB->dwVersion = MAKELONG(HSE_VERSION_MINOR, HSE_VERSION_MAJOR);
    ECB->ConnID = 0;

    // 
    // Pointers to the functions the DLL will call.
    // 
    
    ECB->GetServerVariable = GetServerVariable;
    ECB->ReadClient = ReadClient;
    ECB->WriteClient = WriteClient;
    ECB->ServerSupportFunction = ServerSupportFunction;

    // 
    // Fill in the standard CGI environment variables
    // 
    
    ECB->lpszMethod = GetEnv("REQUEST_METHOD");
    ECB->lpszQueryString = GetEnv("QUERY_STRING");
    ECB->lpszPathInfo = GetEnv("PATH_INFO");
    ECB->lpszPathTranslated = GetEnv("PATH_TRANSLATED");
    ECB->cbTotalBytes = ((temp = GetEnv("CONTENT_LENGTH")) ? 
                            (atoi(temp)) : 0);
    ECB->cbAvailable = 0;
    ECB->lpbData = "";
    ECB->lpszContentType = GetEnv("CONTENT_TYPE");

    return TRUE;

}


//
// Works like _getenv(), but uses win32 functions instead.
// 

char *
GetEnv(LPSTR lpszEnvVar)
{

    char *var, dummy;
    DWORD dwLen;

    if (!lpszEnvVar)
        return "";

    dwLen = GetEnvironmentVariable(lpszEnvVar, &dummy, 1);

    if (dwLen == 0)
        return "";

    var = xmalloc(dwLen);
    if (!var)
        return "";

    (void) GetEnvironmentVariable(lpszEnvVar, var, dwLen);

    return var;
}