Return to child.c CVS log

Up to [WindowsNT SDKs] / q_a / samples / inherit

Annotation of q_a/samples/inherit/child.c, revision 1.1

1.1     ! root        1: /* Standard output handle/standard error handle redirection test
        !             2: program */
        !             3: 
        !             4: #include <stdio.h>
        !             5: #include <io.h>
        !             6: #include <string.h>
        !             7: #include <windows.h>
        !             8: 
        !             9: /* This function opens up a handle to CONOUT$ so that we can be
        !            10: guaranteed to get error messages to the console even if the standard
        !            11: handles are redirected. */
        !            12: 
        !            13: void myError(HANDLE h, char *api, int line)
        !            14: {
        !            15:   char buf[512];
        !            16:   BOOL fSuccess;
        !            17:   DWORD cBytesWritten;
        !            18:   HANDLE hConout;
        !            19: 
        !            20:   sprintf(buf, "%s: Error %d from %s on line %d\n", __FILE__, GetLastError(),
        !            21:       api, line);
        !            22:   fSuccess = WriteFile(h, buf, strlen(buf), &cBytesWritten, NULL);
        !            23:   if (!fSuccess)
        !            24:     {
        !            25:     hConout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
        !            26:         FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
        !            27:         FILE_ATTRIBUTE_NORMAL, NULL);
        !            28:     sprintf(buf, "%s: Error %d from %s on line %d\n", __FILE__,
        !            29:       GetLastError(), api, line);
        !            30:     WriteFile(hConout, buf, strlen(buf), &cBytesWritten, NULL);
        !            31:     CloseHandle(hConout);
        !            32:     }
        !            33:   return;
        !            34: }
        !            35: 
        !            36: /* get the standard output handle and standard error handle and
        !            37: write a message to each */
        !            38: 
        !            39: int main()
        !            40: {
        !            41:   DWORD cBytesWritten;
        !            42:   HANDLE hStdErr, hStdOut, hConout;
        !            43:   BOOL fSuccess;
        !            44:   char *stdErrMsg = "Hello from child to standard error!\n";
        !            45:   char *stdOutMsg = "Hello from child to standard output!\n";
        !            46: 
        !            47:   hConout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
        !            48:       FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
        !            49:       FILE_ATTRIBUTE_NORMAL, NULL);
        !            50:   if ((int) hConout == -1)
        !            51:     Beep(5000,500); /* no reliable way of reporting errors to the console */
        !            52:                     /* if we can't open a console handle */
        !            53:   hStdErr = GetStdHandle(STD_ERROR_HANDLE);
        !            54:   if ((int) hStdErr == -1)
        !            55:     myError(hConout, "GetStdHandle", __LINE__);
        !            56:   hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
        !            57:   if ((int) hStdOut == -1)
        !            58:     myError(hConout, "GetStdHandle", __LINE__);
        !            59:   fSuccess = WriteFile(hStdErr, stdErrMsg, strlen(stdErrMsg),
        !            60:       &cBytesWritten, NULL);
        !            61:   if (!fSuccess)
        !            62:     myError(hConout, "WriteFile", __LINE__);
        !            63:   fSuccess = WriteFile(hStdOut, stdOutMsg, strlen(stdOutMsg),
        !            64:       &cBytesWritten, NULL);
        !            65:   if (!fSuccess)
        !            66:     myError(hConout, "WriteFile", __LINE__);
        !            67:   CloseHandle(hConout);
        !            68:   return(0);
        !            69: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.