Windows编程

开发平台：
Visual C++

PICKLPC.C：源码内容
							/****************************************************************************
                   Microsoft RPC Version 2.0
           Copyright Microsoft Corp. 1992, 1993, 1994- 1996
                      picklp Example
    FILE:       picklpc.c
    USAGE:      picklpc  -f filename  (file to write to/read from)
                         -d           (serialization direction: decode)
                         -e           (serialization direction: encode)
                         -i           (incremental serialization on)
    PURPOSE:    The only side of RPC application
    FUNCTIONS:  main() - serializes data to or from a file
    COMMENTS:   Data procedure serialization is demonstrated here
****************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include "picklp.h"    // header file generated by MIDL compiler
#define PURPOSE 
"This Microsoft RPC Version 2.0 sample program demonstratesn
the use of the [encode,decode] attributes. For more informationn
about the attributes and RPC API functions, see the RPC programmingn
guide and reference.nn"
/*  Used for incremental style only. */
void __RPC_USER PicAlloc( void * pState, char ** ppBuf, unsigned int * pCount);
void __RPC_USER PicWrite( void * pState, char *  pBuf,  unsigned int Count);
void __RPC_USER PicRead ( void * pState, char ** pBuf,  unsigned int * pCount);
typedef struct PickleControlBlock
{
    unsigned char *         pMemBuffer;
    unsigned char *         pBufferStart;
    unsigned long           LastSize;
} PickleControlBlock;
static PickleControlBlock                 UserState;
static PickleControlBlock * pUserState = &UserState;
void Usage(char * pszProgramName)
{
    fprintf(stderr, "%s", PURPOSE);
    fprintf(stderr, "Usage:  %sn", pszProgramName);
    fprintf(stderr, " -dn");
    fprintf(stderr, " -en");
    fprintf(stderr, " -ffilenamen");
    fprintf(stderr, " -i n");
    exit(1);
}
void DumpData(
    char * pszComment,
    char * pszText,
    OBJECT1 * pObject1,
    OBJECT2 * pObject2 )
{
    int i;
    printf( "n%sn", pszComment );
    printf( "tStringntt%sn", pszText );
    printf( "tObject1");
    for (i=0; i < ARR_SIZE; i++)
        {
        if ( (i % 5) == 0 )
            printf( "ntt");
        printf( "%08xl  ", pObject1->al[i] );
        }
    printf( "ntt%xn", pObject1->s );
    printf( "tObject2");
    printf( "ntt%x", pObject2->sSize );
    for (i=0; i < ARR_SIZE; i++)
        {
        if ( (i % 10) == 0 )
            printf( "ntt");
        printf( "%04x  ", pObject2->as[i] );
        }
    printf( "n" );
}
void WriteDataToFile(
    char *          pszFileName,
    char *          pbBuffer,
    unsigned long   ulSizeToWrite )
{
    FILE *      pFile;
    size_t      Count;
    if ( pszFileName ) {
        pFile = fopen( pszFileName, "w+b" );
        if ( pFile == NULL ) {
            printf("Cannot open the file for writingn");
            exit(1);
            }
        Count = sizeof(long);
        if ( fwrite( &ulSizeToWrite, sizeof(byte), Count, pFile) != Count ) {
            printf("Cannot write1 to the filen");
            exit(1);
            }
        Count = (size_t) ulSizeToWrite;
        if ( fwrite( pbBuffer, sizeof(byte), Count, pFile) != Count ) {
            printf("Cannot write2 to the filen");
            exit(1);
            }
        if ( fclose( pFile ) != 0) {
            printf("Failed to close the filen");
            exit(1);
            }
        }
}
void ReadDataFromFile(
    char *          pszFileName,
    char *          pbBuffer,
    unsigned long   ulBufferSize )
{
    FILE *          pFile;
    size_t          Count;
    unsigned long   ulWrittenSize;
    if ( pszFileName ) {
        pFile = fopen( pszFileName, "r+b" );
        if ( pFile == NULL ) {
            printf("Cannot open the file for readingn");
            exit(1);
            }
        Count = sizeof(long);
        if ( fread( &ulWrittenSize, sizeof(byte), Count, pFile) != Count ) {
            printf("Cannot read1 from the filen");
            exit(1);
            }
        Count = (size_t)ulWrittenSize;
        if ( fread( pbBuffer, sizeof(byte), Count, pFile) != Count ) {
            printf("Cannot read2 from the filen");
            exit(1);
            }
        if ( fclose( pFile ) != 0) {
            printf("Failed to close the filen");
            exit(1);
            }
        }
}
void _CRTAPI1 main(int argc, char **argv)
{
    RPC_STATUS status;
    unsigned char * pbPicklingBuffer = NULL;
    char * pszStyle      = NULL;
    char * pszFileName   = "pickle.dat";
    int i;
    int fEncode = 1;
    int fFixedStyle = 1;
    /* allow the user to override settings with command line switches */
    for (i = 1; i < argc; i++) {
        if ((*argv[i] == '-') || (*argv[i] == '/')) {
            switch (tolower(*(argv[i]+1))) {
            case 'd':
                fEncode = 0;
                break;
            case 'e':
                fEncode = 1;
                break;
            case 'i':
                fFixedStyle = 0;
                break;
            case 'f':
                pszFileName = argv[i] + 2;
                break;
            case 'h':
            case '?':
            default:
                Usage(argv[0]);
            }
        }
        else
            Usage(argv[0]);
    }
    /* Fixed buffer style: the buffer should be big enough.  */
    /* Please note that the buffer has to be aligned at 8.   */
    pbPicklingBuffer = (unsigned char *)
            midl_user_allocate( BUFSIZE * sizeof(unsigned char));
    if ( pbPicklingBuffer == NULL ) {
        printf("Cannot allocate the pickling buffern");
        exit(1);
        }
    else
        memset( pbPicklingBuffer, 0xdd, BUFSIZE );
    /*
        Set the pickling handle that will be used for data serialization.
        The global ImplicitPicHandle is used, but it has to be set up.
    */
    if ( fEncode ) {
        unsigned char * pszNameId;
        OBJECT1         Object1;
        OBJECT2   *     pObject2;
        unsigned long   ulEncodedSize = 0;
        printf("nEncoding run: use -d for decodingnn");
        if ( fFixedStyle ) {
            printf("Creating a fixed buffer encoding handlen");
            status = MesEncodeFixedBufferHandleCreate( pbPicklingBuffer,
                                                       BUFSIZE,
                                                       & ulEncodedSize,
                                                       & ImplicitPicHandle );
            printf("MesEncodeFixedBufferHandleCreate returned 0x%xn", status);
            if (status) {
                exit(status);
            }
        }
        else {
            pUserState->LastSize = 0;
            pUserState->pMemBuffer = (char *)pbPicklingBuffer;
            pUserState->pBufferStart = (char *)pbPicklingBuffer;
            printf("Creating an incremental encoding handlen");
            status = MesEncodeIncrementalHandleCreate( pUserState,
                                                       PicAlloc,
                                                       PicWrite,
                                                       & ImplicitPicHandle );
            printf("MesEncodeIncrementalHandleCreate returned 0x%xn", status);
            if (status) {
                exit(status);
            }
        }
        /* Creating objects to manipulate */
        pszNameId = "Procedure pickling sample";
        for (i = 0; i < ARR_SIZE; i++)
            Object1.al[i] = 0x37370000 + i;
        Object1.s = 0x4646;
        pObject2 = midl_user_allocate( sizeof(OBJECT2) + ARR_SIZE*sizeof(short) );
        if (pObject2 == NULL ) {
            printf("Out of memory for Object2n");
            exit(1);
        }
        pObject2->sSize = ARR_SIZE;
        for (i = 0; i < ARR_SIZE; i++)
            pObject2->as[i] = 0x7700 + i;
        DumpData( "Data to be encoded", pszNameId, &Object1, pObject2 );
        printf("nEncoding all the arguments to the buffernn");
        ProcPickle( pszNameId, & Object1, pObject2 );
        printf("Writing the data to the file: %sn", pszFileName);
        WriteDataToFile( pszFileName,
                         pbPicklingBuffer,
                         fFixedStyle  ? ulEncodedSize
                                      : pUserState->LastSize);
        midl_user_free( pObject2 );
    }
    else {
        char            acNameBuffer[50];
        OBJECT1         Object1;
        OBJECT2   *     pObject2;
        printf("nDecoding run: use -e for encodingnn");
        printf("Reading the data from the file: %snn", pszFileName );
        ReadDataFromFile( pszFileName,
                          pbPicklingBuffer,
                          BUFSIZE );
        if ( fFixedStyle ) {
            printf("Creating a decoding handlen");
            status = MesDecodeBufferHandleCreate( pbPicklingBuffer,
                                                  BUFSIZE,
                                                  & ImplicitPicHandle );
            printf("MesDecodeFixedBufferHandleCreate returned 0x%xn", status);
            if (status) {
                exit(status);
            }
        }
        else {
            pUserState->LastSize = 0;
            pUserState->pMemBuffer = (char *)pbPicklingBuffer;
            pUserState->pBufferStart = (char *)pbPicklingBuffer;
            printf("Creating an incremental decoding handlen");
            status = MesDecodeIncrementalHandleCreate( pUserState,
                                                       PicRead,
                                                       & ImplicitPicHandle );
            printf("MesDecodeIncrementalHandleCreate returned 0x%xn", status);
            if (status) {
                exit(status);
            }
        }
        /* Creating objects to manipulate */
        pObject2 = midl_user_allocate( sizeof(OBJECT2) + ARR_SIZE*sizeof(short));
        if (pObject2 == NULL ) {
            printf("Out of memory for Object2n");
            exit(1);
        }
        printf("nDecoding all the arguments from the buffern");
        ProcPickle( acNameBuffer, & Object1, pObject2 );
        DumpData( "Decoded data", acNameBuffer, &Object1, pObject2 );
        midl_user_free( pObject2 );
    }
    printf("nData serialization done.n");
    midl_user_free( pbPicklingBuffer );
    printf("nFreeing the serialization handle.n");
    status = MesHandleFree( ImplicitPicHandle );
    printf("MesHandleFree returned 0x%xn", status);
    exit(0);
}  // end main()
/*********************************************************************/
/*                 MIDL allocate and free                            */
/*********************************************************************/
/* A pickling buffer has to be aligned at 8.
   malloc() doesn't guarantee that, so some gimmick has to be done.
*/
#define ALIGN_TO8( p)   (char *)((unsigned long)((char *)p + 7) & ~7)
void __RPC_FAR * __RPC_USER  MIDL_user_allocate(size_t s)
{
    unsigned char * pcAllocated;
    unsigned char * pcUserPtr;
    pcAllocated = (unsigned char *) malloc( s + 15 );
    pcUserPtr =  ALIGN_TO8( pcAllocated );
    if ( pcUserPtr == pcAllocated )
        pcUserPtr = pcAllocated + 8;
    *(pcUserPtr - 1) = pcUserPtr - pcAllocated;
    return( pcUserPtr );
}
void __RPC_USER  MIDL_user_free(void __RPC_FAR *f)
{
    unsigned char * pcAllocated;
    unsigned char * pcUserPtr;
    pcUserPtr = (unsigned char *) f;
    pcAllocated = pcUserPtr - *(pcUserPtr - 1);
    free( pcAllocated );
}
/*********************************************************************/
/*                 Incremental style helper routines                 */
/*********************************************************************/
void  __RPC_USER
PicAlloc(
    void *          pState,
    char **         ppBuf,
    unsigned int  * pCount )
{
    /* This routines "allocates" the next part from the preallocated
       buffer. It could call midl_user_allocate, too.
    */
    PickleControlBlock * pPic = (PickleControlBlock *)pState;
    if ( (pPic->pMemBuffer - pPic->pBufferStart) + *pCount <= BUFSIZE )
        *ppBuf = (char *)pPic->pMemBuffer;
    else {
        printf(" Buffer too smalln");
        exit(1);
    }
}
void __RPC_USER
PicWrite(
    void *          pState,
    char *          pBuf,
    unsigned int    Count )
{
    /* This routine just marks how much of the preallocated buffer is used.
    */
    PickleControlBlock * pPic = (PickleControlBlock *)pState;
    if ( pPic->pMemBuffer != pBuf ) {
        printf(" Buffer poiner corruptedn");
        exit(1);
    }
    pPic->pMemBuffer += Count;
    pPic->LastSize += Count;
}
void __RPC_USER
PicRead(
    void *          pState,
    char **         ppBuf,
    unsigned int  * pCount )
{
    /* This routine returns another portion of the preread buffer. */
    PickleControlBlock * pPic = (PickleControlBlock *)pState;
    *ppBuf = (char *)pPic->pMemBuffer;
    pPic->pMemBuffer += *pCount;
}
/* end picklpc.c */

						