Return to serv.c CVS log

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

Annotation of os2sdk/demos/examples/queues/serv.c, revision 1.1

1.1     ! root        1: /* Server.c
        !             2:  *
        !             3:  * This program emulates the headwaiter reading requests (from a queue)
        !             4:  * placed in the queue by the gatekeeper (see customer.c).  The following
        !             5:  * functions are illustrated here:
        !             6:  *      DOSCREATEQUEUE, DOSQUERYQUEUE, DOSREADQUEUE, DOSCLOSEQUEUE
        !             7:  *
        !             8:  * This example first makes the shared segment created by customer.c
        !             9:  * addressable. The data queued by the customer.c is contained in this
        !            10:  * segment. It creates a queue, loops querying the number of elements in the
        !            11:  * queue. It exits the loop when the number of elements in the queue is
        !            12:  * nonzero. It loops reading each element from the queue and checking the
        !            13:  * value of the RequestID in the element. It exits the loop when the
        !            14:  * RequestID indicates nomore elements. It frees the shared segment
        !            15:  * and closes the queue.
        !            16:  *
        !            17:  * Compile as: cl -AL -G2 -Lp server.c
        !            18:  *
        !            19:  * Copyright (C) Microsoft Corp. 1986
        !            20:  */
        !            21: 
        !            22: #include <doscalls.h>                   /* 286DOS function declarations     */
        !            23: #include "defines.h"                    /* definitions for example programs */
        !            24: 
        !            25: #define Q                       0       /* determine type of Queue to create */
        !            26: #define ERROR_FILE_NOT_FOUND    2
        !            27: 
        !            28: 
        !            29: 
        !            30: 
        !            31: 
        !            32: 
        !            33: void main (argc, argv, envp)
        !            34:     int argc;
        !            35:     char *argv[];
        !            36:     char *envp;
        !            37: {
        !            38:         unsigned        QueueHandle,        /* handle to the queue          */
        !            39:                         NumberElements = 0, /* number of elements in queue  */
        !            40:                         DataLength,         /* length of element received   */
        !            41:                         SharedSel;          /* selector to shared segment   */
        !            42:         unsigned long   DataAddress,        /* address of element received  */
        !            43:                         PID_RequestID;      /* will hold PID & request ID   */
        !            44:         unsigned char   ElemPriority,       /* priority of element in queue */
        !            45:                         TableID,            /* ID of the table              */
        !            46:                         Priorty,            /* Priority of the Data Element */
        !            47:                         type;               /* example type                 */
        !            48: 
        !            49:         /* get the shared segment */
        !            50:         while (DOSGETSHRSEG (SEGNAME, &SharedSel) ==
        !            51:                ERROR_FILE_NOT_FOUND) /* keep trying to get the shared seg...*/
        !            52:                   DOSSLEEP(1000L);   /* ...until the customer creates it    */
        !            53: 
        !            54:         /* create the appropriate queue */
        !            55:         if (argc > 1){
        !            56:            ++argv;
        !            57:            type = *argv[0];
        !            58:         }
        !            59:         else type = 'd';
        !            60:         switch (*argv[0]) {
        !            61:           case 'f': DOSCREATEQUEUE (&QueueHandle, FIFO, QUEUENAME);
        !            62:                     printf("FIFO Queue selected ... \n");
        !            63:             break;
        !            64:           case 'F': DOSCREATEQUEUE (&QueueHandle, FIFO, QUEUENAME);
        !            65:                     printf("FIFO Queue selected ...\n");
        !            66:             break;
        !            67:           case 'l': DOSCREATEQUEUE (&QueueHandle, LIFO, QUEUENAME);
        !            68:                     printf("LIFO Queue selected ...\n");
        !            69:             break;
        !            70:           case 'L': DOSCREATEQUEUE (&QueueHandle, LIFO, QUEUENAME);
        !            71:                     printf("LIFO Queue selected ...\n");
        !            72:             break;
        !            73:           case 'p': DOSCREATEQUEUE (&QueueHandle, PRIO, QUEUENAME);
        !            74:                     printf("PRIO Queue selected ...\n");
        !            75:             break;
        !            76:           case 'P': DOSCREATEQUEUE (&QueueHandle, PRIO, QUEUENAME);
        !            77:                     printf("PRIO Queue selected ...\n");
        !            78:             break;
        !            79:           default: DOSCREATEQUEUE (&QueueHandle, FIFO, QUEUENAME);
        !            80:                     printf("FIFO Queue selected - default\n");
        !            81:             ;
        !            82:         } /* endswitch */
        !            83: 
        !            84:         /* check if there are any requests */
        !            85:         while (NumberElements == 0) {
        !            86:           DOSQUERYQUEUE (QueueHandle, &NumberElements);
        !            87:           DOSSLEEP(1000L);
        !            88:         }
        !            89: 
        !            90:         /* there are requests in the queue. */
        !            91: 
        !            92:         /* initialise request ID */
        !            93:         *((unsigned *)(&PID_RequestID) + 1) = REQWAITER;
        !            94: 
        !            95:         /* loop for rest of queue elements until no nore */
        !            96: 
        !            97:         do {
        !            98: 
        !            99:           /* read an element from the queue */
        !           100:           DOSREADQUEUE (QueueHandle, &PID_RequestID,
        !           101:                         &DataLength, &DataAddress, FIRSTELEMENT,
        !           102:                         (unsigned char) WAIT, &ElemPriority,
        !           103:                         (unsigned long) DUMMYPARAM);
        !           104:           TableID = *((unsigned char *) DataAddress);
        !           105:           Priorty  = *((unsigned char *) DataAddress + 1);
        !           106: 
        !           107:           /* dispatch waiter to table */
        !           108: 
        !           109:           if (*((unsigned *)(&PID_RequestID) + 1) != NOMORE){
        !           110:             printf("Server sending waiter to Table %u : Priority = %u ", TableID, Priorty);
        !           111:             printf(": Data Length= %u\n", DataLength);
        !           112:           } /* endif */
        !           113: 
        !           114:         } while (*((unsigned *)(&PID_RequestID) + 1) != NOMORE); /* enddo */
        !           115: 
        !           116: 
        !           117: 
        !           118:         /* free the shared segment */
        !           119:         DOSFREESEG (SharedSel);
        !           120: 
        !           121:         /* close the queue */
        !           122:         DOSCLOSEQUEUE (QueueHandle);
        !           123: }

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