Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
CXHNDLC.C
Package: MSDN_VC98.zip　[view]
Upload User: bangxh
Upload Date: 2007-01-31
Package Size: 42235k
Code Size: 5k
Category:

Windows Develop

Development Platform:

Visual C++

CXHNDLC.C：Code Content
  1. /****************************************************************************
  2.                    Microsoft RPC Version 2.0
  3.            Copyright Microsoft Corp. 1992, 1993, 1994- 1996
  4.                       cxhndl Example
  6.     FILE:       cxhndlc.c
  8.     USAGE:      cxhndlc  -n network_address
  9.                          -p protocol_sequence
  10.                          -e endpoint
  11.                          -o options
  12.                          -f filename
  14.     PURPOSE:    Client side of RPC distributed application
  16.     FUNCTIONS:  main() - binds to server and calls remote procedure
  18.     COMMENTS:   This distributed application uses a context handle.
  20. ****************************************************************************/
  22. #include <stdlib.h>
  23. #include <stdio.h>
  24. #include "cxhndl.h"    // header file generated by MIDL compiler
  27. #define PURPOSE 
  28. "This Microsoft RPC Version 2.0 sample program demonstratesn
  29. the use of the [context_handle] attribute. For more informationn
  30. about attributes and RPC API functions, see the RPC programmingn
  31. guide and reference.nn"
  34. void Usage(char * pszProgramName)
  35. {
  36.     fprintf(stderr, "%s", PURPOSE);
  37.     fprintf(stderr, "Usage:  %sn", pszProgramName);
  38.     fprintf(stderr, " -p protocol_sequencen");
  39.     fprintf(stderr, " -n network_addressn");
  40.     fprintf(stderr, " -e endpointn");
  41.     fprintf(stderr, " -o optionsn");
  42.     fprintf(stderr, " -f filenamen");
  43.     exit(1);
  44. }
  46. void _CRTAPI1 main(int argc, char **argv)
  47. {
  48.     RPC_STATUS status;
  49.     PCONTEXT_HANDLE_TYPE phContext = NULL;
  51.     unsigned char * pbBuf = NULL;
  52.     short cbRead;    // count of bytes read
  54.     unsigned char * pszUuid             = NULL;
  55.     unsigned char * pszProtocolSequence = "ncacn_np";
  56.     unsigned char * pszNetworkAddress   = NULL;
  57.     unsigned char * pszEndpoint         = "\pipe\cxhndl";
  58.     unsigned char * pszOptions          = NULL;
  59.     unsigned char * pszStringBinding    = NULL;
  60.     unsigned char * pszFileName         = "readme.txt";
  61.     int i;
  63.     /* allow the user to override settings with command line switches */
  64.     for (i = 1; i < argc; i++) {
  65.         if ((*argv[i] == '-') || (*argv[i] == '/')) {
  66.             switch (tolower(*(argv[i]+1))) {
  67.             case 'p':  // protocol sequence
  68.                 pszProtocolSequence = argv[++i];
  69.                 break;
  70.             case 'n':  // network address
  71.                 pszNetworkAddress = argv[++i];
  72.                 break;
  73.             case 'e':
  74.                 pszEndpoint = argv[++i];
  75.                 break;
  76.             case 'o':
  77.                 pszOptions = argv[++i];
  78.                 break;
  79.             case 'f':
  80.                 pszFileName = argv[++i];
  81.                 break;
  82.             case 'h':
  83.             case '?':
  84.             default:
  85.                 Usage(argv[0]);
  86.             }
  87.         }
  88.         else
  89.             Usage(argv[0]);
  90.     }
  92.     pbBuf = (unsigned char *)
  93.             midl_user_allocate(BUFSIZE * sizeof(unsigned char));
  95.     /* Use a convenience function to concatenate the elements of  */
  96.     /* the string binding into the proper sequence.               */
  97.     status = RpcStringBindingCompose(pszUuid,
  98.                                      pszProtocolSequence,
  99.                                      pszNetworkAddress,
  100.                                      pszEndpoint,
  101.                                      pszOptions,
  102.                                      &pszStringBinding);
  103.     printf("RpcStringBindingCompose returned 0x%xn", status);
  104.     printf("pszStringBinding = %sn", pszStringBinding);
  105.     if (status) {
  106.         exit(status);
  107.     }
  109.     /* Set the binding handle that will be used to bind to the server. */
  110.     status = RpcBindingFromStringBinding(pszStringBinding,
  111.                                          &hStarter);
  112.     printf("RpcBindingFromStringBinding returned 0x%xn", status);
  113.     if (status) {
  114.         exit(status);
  115.     }
  117.     printf("Calling the remote procedure RemoteOpenn");
  118.     if (RemoteOpen(&phContext, pszFileName) < 0) {
  119.         printf("Unable to open %sn", pszFileName);
  120.         Shutdown();
  121.         exit(2);
  122.     }
  124.     /* Now the context handle also manages the binding. */
  125.     status = RpcBindingFree(&hStarter);
  126.     printf("RpcBindingFree returned 0x%xn", status);
  127.     if (status) {
  128.         exit(status);
  129.     }
  131.     /*  Free the string binding */
  132.     status = RpcStringFree(&pszStringBinding);
  133.     printf("RpcStringFree returned 0x%xn", status);
  134.     if (status) {
  135.         exit(status);
  136.     }
  138.     printf("Calling the remote procedure RemoteReadn");
  139.     while (RemoteRead(phContext, pbBuf, &cbRead) > 0) {
  140.         for (i = 0; i < cbRead; i++)
  141.             putchar(*(pbBuf+i));
  142.     }
  144.     printf("Calling the remote procedure RemoteClosen");
  145.     if (RemoteClose(&phContext) < 0 ) {
  146.         printf("Close failed on %sn", pszFileName);
  147.         exit(2);
  148.     }
  150.     exit(0);
  152. }  // end main()
  155. /*********************************************************************/
  156. /*                 MIDL allocate and free                            */
  157. /*********************************************************************/
  159. void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
  160. {
  161.     return(malloc(len));
  162. }
  164. void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
  165. {
  166.     free(ptr);
  167. }
  169. /* end cxhndlc.c */