Return to cluuids.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / rpc / cluuid

Annotation of mstools/samples/rpc/cluuid/cluuids.c, revision 1.1

1.1     ! root        1: /****************************************************************************
        !             2:                   Microsoft RPC Version 1.0
        !             3:                Copyright Microsoft Corp. 1992
        !             4:                       Cluuid Example
        !             5: 
        !             6:     FILE:       cluuids.c
        !             7: 
        !             8:     USAGE:      cluuids  -p protocol_sequence
        !             9:                          -e endpoint
        !            10:                          -m max calls
        !            11:                          -n min calls
        !            12:                          -f flag for RpcServerListen
        !            13:                          -1 client object uuid
        !            14:                          -2 manager epv uuid
        !            15: 
        !            16:     PURPOSE:    Server side of RPC distributed application hello
        !            17: 
        !            18:     FUNCTIONS:  main() - registers server as RPC server
        !            19: 
        !            20:     COMMENTS:   Print "hello, world" on the server.
        !            21:                 When you supply a type UUID, the client must
        !            22:                 supply the same UUID.
        !            23: 
        !            24: ****************************************************************************/
        !            25: 
        !            26: #include <stdio.h>
        !            27: #include <stdlib.h>
        !            28: #include <string.h>
        !            29: #include <ctype.h>
        !            30: #include "cluuid.h"    // header file generated by MIDL compiler
        !            31: 
        !            32: // the second implementation of the remote procedure
        !            33: extern void HelloProc2(unsigned char * pszString);
        !            34: 
        !            35: #define PURPOSE \
        !            36: "This Microsoft RPC Version 1.0 sample program demonstrates how\n\
        !            37: to supply multiple implementations of the remote procedure\n\
        !            38: specified in the interface. It also demonstrates how the client\n\
        !            39: selects among the implementations by providing a client object uuid.\n\n"
        !            40: 
        !            41: #define NULL_UUID_STRING "00000000-0000-0000-0000-000000000000"
        !            42: 
        !            43: void Usage(char * pszProgramName)
        !            44: {
        !            45:     fprintf(stderr, "%s", PURPOSE);
        !            46:     fprintf(stderr, "Usage:  %s\n", pszProgramName);
        !            47:     fprintf(stderr, " -p protocol_sequence\n");
        !            48:     fprintf(stderr, " -e endpoint\n");
        !            49:     fprintf(stderr, " -m maxcalls\n");
        !            50:     fprintf(stderr, " -n mincalls\n");
        !            51:     fprintf(stderr, " -f flag_wait_op\n");
        !            52:     fprintf(stderr, " -1 client uuid\n");
        !            53:     fprintf(stderr, " -2 manager uuid\n");
        !            54:     exit(1);
        !            55: }
        !            56: 
        !            57: /* main:  register the interface, start listening for clients */
        !            58: void _CRTAPI1 main(int argc, char * argv[])
        !            59: {
        !            60:     RPC_STATUS status;
        !            61:     UUID MgrTypeUuid, ClientUuid;
        !            62:     unsigned char * pszProtocolSequence = "ncacn_np";
        !            63:     unsigned char * pszSecurity         = NULL;
        !            64:     unsigned char * pszClientUuid       = NULL_UUID_STRING;
        !            65:     unsigned char * pszMgrTypeUuid      = "11111111-1111-1111-1111-111111111111";
        !            66:     unsigned char * pszEndpoint         = "\\pipe\\cluuid";
        !            67:     unsigned int    cMinCalls           = 1;
        !            68:     unsigned int    cMaxCalls           = 20;
        !            69:     unsigned int    fDontWait           = FALSE;
        !            70:     int i;
        !            71: 
        !            72:     cluuid_SERVER_EPV epv2;    // the mgr_epv for the 2nd implementation
        !            73: 
        !            74:     /* allow the user to override settings with command line switches */
        !            75:     for (i = 1; i < argc; i++) {
        !            76:         if ((*argv[i] == '-') || (*argv[i] == '/')) {
        !            77:             switch (tolower(*(argv[i]+1))) {
        !            78:             case 'p':  // protocol sequence
        !            79:                 pszProtocolSequence = argv[++i];
        !            80:                 break;
        !            81:             case 'e':
        !            82:                 pszEndpoint = argv[++i];
        !            83:                 break;
        !            84:             case 'm':
        !            85:                 cMaxCalls = (unsigned int) atoi(argv[++i]);
        !            86:                 break;
        !            87:             case 'n':
        !            88:                 cMinCalls = (unsigned int) atoi(argv[++i]);
        !            89:                 break;
        !            90:             case 'f':
        !            91:                 fDontWait = (unsigned int) atoi(argv[++i]);
        !            92:                 break;
        !            93:             case '1':
        !            94:                 pszMgrTypeUuid = argv[++i];
        !            95:                 break;
        !            96:             case '2':
        !            97:                 pszClientUuid = argv[++i];
        !            98:                 break;
        !            99:             case 'h':
        !           100:             case '?':
        !           101:             default:
        !           102:                 Usage(argv[0]);
        !           103:             }
        !           104:         }
        !           105:         else
        !           106:             Usage(argv[0]);
        !           107:     }
        !           108: 
        !           109:     status = RpcServerUseProtseqEp(pszProtocolSequence,
        !           110:                                    cMaxCalls, 
        !           111:                                    pszEndpoint,
        !           112:                                    pszSecurity);  // Security descriptor
        !           113:     printf("RpcServerUseProtseqEp returned 0x%x\n", status);
        !           114:     if (status) {
        !           115:         exit(status);
        !           116:     }
        !           117: 
        !           118:     status = UuidFromString(pszClientUuid, &ClientUuid);
        !           119:     printf("UuidFromString returned 0x%x = %d\n", status, status);
        !           120:     if (status) {
        !           121:         exit(status);
        !           122:     }
        !           123: 
        !           124:     status = UuidFromString(pszMgrTypeUuid, &MgrTypeUuid);
        !           125:     printf("UuidFromString returned 0x%x = %d\n", status, status);
        !           126:     if (status) {
        !           127:         exit(status);
        !           128:     }
        !           129:     if (strcmp (pszMgrTypeUuid, NULL_UUID_STRING) == 0) {
        !           130:         printf("Register object using non-null uuid %s\n", pszMgrTypeUuid);
        !           131:         exit(1);
        !           132:     }
        !           133: 
        !           134:     if (strcmp (pszClientUuid, NULL_UUID_STRING) == 0) {
        !           135:         printf("Register object using non-null uuid %s\n", pszMgrTypeUuid);
        !           136:         ClientUuid = MgrTypeUuid;
        !           137:     }
        !           138: 
        !           139:     RpcObjectSetType(&ClientUuid, &MgrTypeUuid);  // associate type UUID with nil UUID
        !           140:     printf("RpcObjectSetType returned 0x%x\n", status);
        !           141:     if (status) {
        !           142:         exit(status);
        !           143:     }
        !           144: 
        !           145:     status = RpcServerRegisterIf(cluuid_ServerIfHandle, // interface to register
        !           146:                                  NULL,   // MgrTypeUuid
        !           147:                                  NULL);  // MgrEpv; null means use default
        !           148:     printf("RpcServerRegisterIf returned 0x%x\n", status);
        !           149:     if (status) {
        !           150:         exit(status);
        !           151:     }
        !           152: 
        !           153:     /* register the second manager epv and associate it with the
        !           154:        specified uuid.  the second uuid must be non-null so that
        !           155:        it will not conflict with the NULL uuid already registered
        !           156:        for this interface
        !           157:     */
        !           158:     epv2.HelloProc = HelloProc2;
        !           159:     epv2.Shutdown = Shutdown;
        !           160:     status = RpcServerRegisterIf(cluuid_ServerIfHandle, // interface to register
        !           161:                                  &MgrTypeUuid,  // MgrTypeUuid
        !           162:                                  &epv2);        // 2nd manager epv
        !           163:     printf("RpcServerRegisterIf returned 0x%x\n", status);
        !           164:     if (status) {
        !           165:         exit(status);
        !           166:     }
        !           167: 
        !           168:     printf("Calling RpcServerListen\n");
        !           169:     status = RpcServerListen(cMinCalls,
        !           170:                              cMaxCalls,
        !           171:                              fDontWait);
        !           172:     printf("RpcServerListen returned: 0x%x\n", status);
        !           173:     if (status) {
        !           174:         exit(status);
        !           175:     }
        !           176: 
        !           177:     if (fDontWait) {
        !           178:         printf("Calling RpcMgmtWaitServerListen\n");
        !           179:         status = RpcMgmtWaitServerListen();  //  wait operation
        !           180:         printf("RpcMgmtWaitServerListen returned: 0x%x\n", status);
        !           181:         if (status) {
        !           182:             exit(status);
        !           183:         }    
        !           184:     }
        !           185: 
        !           186: } // end main()
        !           187: 
        !           188: 
        !           189: /*********************************************************************/
        !           190: /*                 MIDL allocate and free                            */
        !           191: /*********************************************************************/
        !           192: 
        !           193: void __RPC_FAR * __RPC_API midl_user_allocate(size_t len)
        !           194: {
        !           195:     return(malloc(len));
        !           196: }
        !           197: 
        !           198: void __RPC_API midl_user_free(void __RPC_FAR * ptr)
        !           199: {
        !           200:     free(ptr);
        !           201: }
        !           202: 
        !           203: 
        !           204: /* end file cluuids.c */

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