Return to pp.c CVS log

Up to [OS/2 SDKs] / os2sdk / demos / examples / pipes

Annotation of os2sdk/demos/examples/pipes/pp.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * DOSMAKEPIPE example (pp.c, needs related program pc.c).
                      3:  *
                      4:  * Pipes are a byte stream oriented IPC mechanism which uses
                      5:  * standard DOSREAD and DOSWRITE file system calls. Since file
                      6:  * handles are used to access the pipe, each process using the
                      7:  * pipe needs to know the handles. There are two general ways
                      8:  * this is done:
                      9:  *
                     10:  *     1. Have very closely cooperating processes which notify
                     11:  *        each other of the file handles via some private method
                     12:  *        such as shared memory or command line arguments.
                     13:  *
                     14:  *     2. With unrelated processes, a process which reads and writes
                     15:  *        from STDIN (handle 0) and STDOUT (handle 1) can be attached
                     16:  *        to a pipe without being aware of it.
                     17:  *
                     18:  * This example demonstrates case #2 since that is the harder of the
                     19:  * two to set up. This process, pp.exe, creates a pipe and exec's a
                     20:  * child process pc.exe whose stdin is attached to the pipe. The parent
                     21:  * process writes a lower case message repeatedly into the pipe, and
                     22:  * the child process translates it into upper case and prints it on
                     23:  * the screen.
                     24:  *
                     25:  * Compile as: cl -AL -G2 -Lp pp.c   (parent process)
                     26:  *             cl -AL -G2 -Lp pc.c   (child process)
                     27:  *
                     28:  * Copyright (C) Microsoft Corp. 1986
                     29:  */
                     30: #include <stdio.h>
                     31: #include <doscalls.h>
                     32: 
                     33: #define PSIZE 256                      /* pipe buffer size */
                     34: 
                     35: char msg[] = "hello there!\n";         /* message to write down pipe */
                     36: char exec_buf[100];                    /* buffer for DosExecPgm ObjName */
                     37: char *pgmname = "pc.exe";              /* name of child program */
                     38: 
                     39: main()
                     40: {
                     41:        unsigned pread;                 /* pipe read handle */
                     42:        unsigned pwrite;                /* pipe write handle */
                     43:        unsigned newstdin, newstdout;   /* stdin as a pipe handle */
                     44:        unsigned FileHandlState;        /* Used to modify handle inheritance */
                     45:        int i;
                     46:        int bytecount;                  /* bytes written result */
                     47:        struct ResultCodes rc2;         /* double return codes for EXEC */
                     48: 
                     49:        DOSMAKEPIPE(&pread, &pwrite, PSIZE);    /* create the pipe */
                     50: 
                     51:        /*
                     52:         * Now close our stdin which is attached to the console,
                     53:         * and make it refer to the pipe instead.
                     54:         */
                     55:        DOSCLOSE(0);                    /* close stdin */
                     56:        newstdin = 0;
                     57:        DOSDUPHANDLE(pread, &newstdin); /* make pipe = stdin */
                     58:        /*
                     59:         * Since the child process will normaly inherit the handles of
                     60:         * the parent we need to close the input of the pipe.  If we
                     61:         * don't then the child will hang on the output of the pipe. (since
                     62:         * it still has an open handle to the input).
                     63:         *
                     64:         * We don't really close the input, simply make it non-inheritable
                     65:         * to the child.  Thus the only input to the pipe is from the parent.
                     66:         * When the parent closes the pipe, any outstanding READs from the
                     67:         * child will return a length of 0 (EOF).
                     68:         */
                     69:        i = DOSQFHANDSTATE(pwrite, (unsigned far *)&FileHandlState);
                     70:        if (i) printf("Query of pwrite failed\n");
                     71:        FileHandlState &= 0x7F88;       /* Mask bits offensive to the call */
                     72:        FileHandlState |= 0x080;        /* Deny inheritance to child */
                     73:        i = DOSSETFHANDSTATE(pwrite, FileHandlState);
                     74:        if (i) printf("Set of pwrite failed, i = %x\n",i);
                     75: #ifdef NOCODE
                     76:        i = DOSQFHANDSTATE(pread, (unsigned far *)&FileHandlState);
                     77:        if (i) printf("Query of pread failed\n");
                     78:        FileHandlState &= 0x7F88;       /* Mask bits offensive to the call */
                     79:        FileHandlState |= 0x080;        /* Deny inheritance to child */
                     80:        i = DOSSETFHANDSTATE(pread, FileHandlState);
                     81:        if (i) printf("Set of pread failed, i = %x\n",i);
                     82: #endif
                     83:        /* exec child program, which will inherit new stdin */
                     84:         DOSEXECPGM(exec_buf, sizeof(exec_buf), 1, (unsigned *)0L, 
                     85:                        (unsigned *)0L, &rc2, pgmname);
                     86: 
                     87:        /* write 20 messages down the pipe */
                     88:        printf("Writing messages to the pipe\n");
                     89:        for(i = 0; i < 20; i++)
                     90:                DOSWRITE(pwrite, msg, sizeof(msg) - 1, &bytecount);
                     91: 
                     92:        DOSCLOSE(pwrite);
                     93:        DOSCLOSE(pread);
                     94:        printf("Parent exiting\n");
                     95:        DOSEXIT(1,0);       /* Terminate and kill any lingering children */
                     96: }

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