w9xpopen.c

/*
 * w9xpopen.c
 *
 * Serves as an intermediate stub Win32 console application to
 * avoid a hanging pipe when redirecting 16-bit console based
 * programs (including MS-DOS console based programs and batch
 * files) on Window 95 and Windows 98.
 *
 * This program is to be launched with redirected standard
 * handles. It will launch the command line specified 16-bit
 * console based application in the same console, forwarding
 * its own redirected standard handles to the 16-bit child.

 * AKA solution to the problem described in KB: Q150956.
 */    

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>  /* for malloc and its friends */

const char *usage =
"This program is used by Python's os.popen function\n"
"to work around a limitation in Windows 95/98.  It is\n"
"not designed to be used as a stand-alone program.";

int main(int argc, char *argv[])
{
    BOOL bRet;
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    DWORD exit_code=0;
    size_t cmdlen = 0;
    int i;
    char *cmdline, *cmdlinefill;

    if (argc < 2) {
        if (GetFileType(GetStdHandle(STD_INPUT_HANDLE))==FILE_TYPE_CHAR)
            /* Attached to a console, and therefore not executed by Python
               Display a message box for the inquisitive user
            */
            MessageBox(NULL, usage, argv[0], MB_OK);
        else {
            /* Eeek - executed by Python, but args are screwed!
               Write an error message to stdout so there is at
               least some clue for the end user when it appears
               in their output.
               A message box would be hidden and blocks the app.
             */
            fprintf(stdout, "Internal popen error - no args specified\n%s\n", usage);
        }
        return 1;
    }
    /* Build up the command-line from the args.
       Args with a space are quoted, existing quotes are escaped.
       To keep things simple calculating the buffer size, we assume
       every character is a quote - ie, we allocate double what we need
       in the worst case.  As this is only double the command line passed
       to us, there is a good chance this is reasonably small, so the total 
       allocation will almost always be < 512 bytes.
    */
    for (i=1;i<argc;i++)
        cmdlen += strlen(argv[i])*2 + 3; /* one space, maybe 2 quotes */
    cmdline = cmdlinefill = (char *)malloc(cmdlen+1);
    if (cmdline == NULL)
        return -1;
    for (i=1;i<argc;i++) {
        const char *arglook;
        int bQuote = strchr(argv[i], ' ') != NULL;
        if (bQuote)
            *cmdlinefill++ = '"';
        /* escape quotes */
        for (arglook=argv[i];*arglook;arglook++) {
            if (*arglook=='"')
                *cmdlinefill++ = '\\';
            *cmdlinefill++ = *arglook;
        }
        if (bQuote)
            *cmdlinefill++ = '"';
        *cmdlinefill++ = ' ';
    }
    *cmdlinefill = '\0';

    /* Make child process use this app's standard files. */
    ZeroMemory(&si, sizeof si);
    si.cb = sizeof si;
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    si.hStdError = GetStdHandle(STD_ERROR_HANDLE);

    bRet = CreateProcess(
        NULL, cmdline,
        NULL, NULL,
        TRUE, 0,
        NULL, NULL,
        &si, &pi
        );

    free(cmdline);

    if (bRet) {
        if (WaitForSingleObject(pi.hProcess, INFINITE) != WAIT_FAILED) {
	    GetExitCodeProcess(pi.hProcess, &exit_code);
	}
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
        return exit_code;
    }

    return 1;
}