Return to pipes.c CVS log

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

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

1.1       root        1: /***   pipes.c - parent program
                      2:  *
                      3:  *     Example of DOSMAKEPIPE usage in parent/child communication
                      4:  *
                      5:  *     This program gets some shared memory, makes a pipe, writes
                      6:  *     a string into it, and then execs a child.  The child gets
                      7:  *     the shared memory segment, then reads from the pipe using
                      8:  *     the handle passed in the shared memory segment.
                      9:  */
                     10: #include <stdio.h>
                     11: #include <doscalls.h>
                     12: 
                     13: typedef struct {                       /* structure of shared mem segment */
                     14:        unsigned read_handle;           /* pipe read handle */
                     15:        unsigned write_handle;          /* pipe write handle */
                     16: } SharedData;
                     17: 
                     18: SharedData far *fp;                    /* pointer to shared memory */
                     19: unsigned mem_handle;                   /* selector of the allocated segment */
                     20: 
                     21: 
                     22: main()
                     23: {
                     24: 
                     25:        static char pname[] = "\\SHAREMEM\\public";        /* shared mem name */
                     26:        static char writeout[] = "Writing to the child";   /* pipe string */
                     27:        char exec_buf[100];             /* buffer for DosExecPgm ObjName */
                     28:        char *pgmname = "pchild.exe";   /* name of child program */
                     29:        int i;
                     30:        int retcode;                    /* holds return code from call */
                     31:        struct ResultCodes tcodes;      /* termination codes from DosExecPgm */
                     32:        unsigned far *fpinit;           /* pointer to shared memory */
                     33:        unsigned buflen;                /* DosWrite buffer length */
                     34:        unsigned memsiz = 1024;         /* size of memory segment requested */
                     35:        unsigned pipe_size;             /* size to reserve for the pipe */
                     36:        unsigned written;               /* number bytes written by DosWrite */
                     37: 
                     38:        /* allocate 1k shared memory segment and initialize it */
                     39:        printf("Getting shared memory segment\n");
                     40:        retcode = DOSALLOCSHRSEG( memsiz, (char far *)pname,
                     41:                        (unsigned far *)&mem_handle);
                     42: 
                     43:        /* create pointers to shared memory segment */
                     44:        fp = (SharedData far *)(((unsigned long)mem_handle << 16) | 0);
                     45:        fpinit = (unsigned far *)(((unsigned long)mem_handle << 16) | 0);
                     46: 
                     47:        /* zero initialize the segment */
                     48:        for (i = 0; i < memsiz / 2; i++) {
                     49:            *fpinit = 0;
                     50:            fpinit++;
                     51:        }
                     52: 
                     53:        /* make the pipe */
                     54:        pipe_size = 0;                  /* use default size */
                     55:        printf("Making the pipe\n");
                     56:        retcode = DOSMAKEPIPE((unsigned far *)&fp->read_handle,
                     57:                        (unsigned far *)&fp->write_handle, pipe_size);
                     58: 
                     59:        if ( retcode ) {
                     60:            printf("DosMakePipe returned error %d, aborting\n", retcode);
                     61:            exit(2);
                     62:        }
                     63:        else
                     64:            printf("DosMakePipe retcode %d, read_handle %d, write_handle %d\n",
                     65:                retcode, fp->read_handle, fp->write_handle);
                     66: 
                     67:         /* write string to pipe */
                     68:        buflen = strlen(writeout) + 1;
                     69:        if( retcode = DOSWRITE( fp->write_handle, (char far *)writeout,
                     70:                        buflen, (unsigned far *)&written)) {
                     71:                 printf("Write to pipe failed, retcode %d\n", retcode);
                     72:                 exit(2);
                     73:         }
                     74:        else 
                     75:                printf("Write to write_handle %d, bytes written %d\n",
                     76:                    fp->write_handle, written);
                     77:         
                     78:         /* create the child */
                     79:        printf("Creating child\n");
                     80:        retcode = DOSEXECPGM( (char far *)exec_buf, 100, 0,
                     81:                        (unsigned far *)0L,
                     82:                        (unsigned far *)0L,
                     83:                        (struct ResultCodes far *)&tcodes, pgmname );
                     84: 
                     85:        if ( retcode )
                     86:                 printf("DosExecPgm of child error %d\n", retcode);
                     87:        else 
                     88:                printf("Back in parent\n");
                     89:        
                     90:        /* close the pipe */
                     91:        DOSCLOSE( fp->read_handle );
                     92:        DOSCLOSE( fp->write_handle );
                     93: 
                     94:        DOSEXIT(1,0);   /* Terminate, kill any dangling children */
                     95: 
                     96: }

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