Return to cxhndlp.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / rpc / handles / cxhndl

Annotation of mstools/samples/rpc/handles/cxhndl/cxhndlp.c, revision 1.1

1.1     ! root        1: /****************************************************************************
        !             2:                          Microsoft RPC Version 1.0
        !             3:                        Copyright Microsoft Corp. 1992
        !             4:                               cxhndl Example
        !             5: 
        !             6:     FILE:      cxhndlp.c
        !             7:     PURPOSE:   Remote procedures used in server application cxhndls
        !             8:     FUNCTIONS: RemoteOpen() - Open the file
        !             9:                RemoteRead() - Read a buffer's worth of the file
        !            10:                RemoteClose() - Close the file and shutdown server
        !            11:                Shutdown() - Shutdown the server
        !            12:     COMMENTS:
        !            13: 
        !            14: ****************************************************************************/
        !            15: 
        !            16: #include <stdio.h>
        !            17: #include <stdlib.h>
        !            18: #include <string.h>
        !            19: #include <rpc.h>
        !            20: #include "cxhndl.h"
        !            21: 
        !            22: #define BUFSIZE 1024
        !            23: 
        !            24: typedef struct {
        !            25:     FILE * hFile;
        !            26:     char achFile[256];
        !            27: } FILE_CONTEXT_TYPE;
        !            28: 
        !            29: FILE_CONTEXT_TYPE FileContext;
        !            30: FILE_CONTEXT_TYPE * pFileContext = &FileContext;
        !            31: 
        !            32: //
        !            33: // This remote procedure opens a file on the server.
        !            34: //
        !            35: short RemoteOpen(PPCONTEXT_HANDLE_TYPE pphContext, char * pszFileName)
        !            36: {
        !            37:     *pphContext = pFileContext;   // initialize the context handle
        !            38:     strcpy(pFileContext->achFile, pszFileName);
        !            39:     if ((pFileContext->hFile = fopen(pszFileName, "r")) == NULL)
        !            40:        return(-1);
        !            41:     else
        !            42:        return(0);
        !            43: }
        !            44: 
        !            45: //
        !            46: // This remote procedure reads a file on the server.
        !            47: //
        !            48: short RemoteRead(PPCONTEXT_HANDLE_TYPE pphContext, char *pbBuf, short *pcbBuf)
        !            49: {
        !            50:     FILE * fp;
        !            51: 
        !            52:     printf("in RemoteRead\n");
        !            53: 
        !            54:     pFileContext = (FILE_CONTEXT_TYPE *) *pphContext;
        !            55:     fp = (FILE *) pFileContext->hFile;
        !            56:     *pcbBuf = (short) fread(pbBuf,
        !            57:                            sizeof(char),
        !            58:                            BUFSIZE,
        !            59:                            fp);
        !            60:     return(*pcbBuf);
        !            61: }
        !            62: 
        !            63: // The Shutdown procedure tells the server to stop listening
        !            64: // for client requests
        !            65: //
        !            66: void Shutdown(void)
        !            67: {
        !            68:     RPC_STATUS status;
        !            69: 
        !            70:     printf("Calling RpcMgmtStopServerListening\n");
        !            71:     status = RpcMgmtStopServerListening(NULL);
        !            72:     printf("RpcMgmtStopServerListening returned: 0x%x\n", status);
        !            73:     if (status) {
        !            74:         exit(2);
        !            75:     }
        !            76: 
        !            77:     printf("Calling RpcServerUnregisterIf\n");
        !            78:     status = RpcServerUnregisterIf(NULL, NULL, FALSE);
        !            79:     printf("RpcServerUnregisterIf returned 0x%x\n", status);
        !            80:     if (status) {
        !            81:         exit(2);
        !            82:     }
        !            83: }
        !            84: 
        !            85: //
        !            86: // This remote procedure closes a file on the server and
        !            87: // shuts down the server.
        !            88: //
        !            89: short RemoteClose(PPCONTEXT_HANDLE_TYPE pphContext)
        !            90: {
        !            91:     printf("in RemoteClose\n");
        !            92: 
        !            93:     pFileContext = (FILE_CONTEXT_TYPE *) *pphContext;
        !            94:     if (fclose(pFileContext->hFile) == 0)
        !            95:        return(0);
        !            96:     else
        !            97:        return(-1);
        !            98: }
        !            99: 
        !           100: //
        !           101: // The rundown routine is associated with the context handle
        !           102: // type.
        !           103: 
        !           104: void PCONTEXT_HANDLE_TYPE_rundown(PCONTEXT_HANDLE_TYPE phContext)
        !           105: {
        !           106: FILE_CONTEXT_TYPE *pFileContext;
        !           107: 
        !           108:        printf("Context rundown routine\n");
        !           109:        Shutdown();
        !           110: 
        !           111:        pFileContext = (FILE_CONTEXT_TYPE *) phContext;
        !           112:        if (pFileContext->hFile != NULL)
        !           113:            fclose(pFileContext->hFile);
        !           114:        phContext = NULL;
        !           115: }

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