Return to db32.c CVS log

Up to [WindowsNT SDKs] / mstools / win32s / ut / samples / ut_def

Annotation of mstools/win32s/ut/samples/ut_def/db32.c, revision 1.1

1.1     ! root        1: /*++
        !             2: 
        !             3: Copyright (c) 1985-92, Microsoft Corporation
        !             4: 
        !             5: Module Name:
        !             6: 
        !             7:     db32.c
        !             8: 
        !             9: Abstract:
        !            10: 
        !            11:     Win32s sample code of Universal Thunk (UT) -
        !            12:     32bit code that provides the same services as DB.DLL by means
        !            13:     of thunking to 16bit dll.
        !            14:     This is the main source file of DB32.DLL
        !            15: 
        !            16: --*/
        !            17: 
        !            18: 
        !            19: #define W32SUT_32
        !            20: 
        !            21: #include <windows.h>
        !            22: #include <w32sut.h>
        !            23: #include <db.h>
        !            24: 
        !            25: UT32PROC  pfnUTProc=NULL;
        !            26: int       cProcessesAttached = 0;
        !            27: 
        !            28: 
        !            29: BOOL
        !            30: DllInit(HANDLE hInst, DWORD fdwReason, LPVOID lpReserved)
        !            31: {
        !            32: 
        !            33:   if ( fdwReason == DLL_PROCESS_ATTACH ) {
        !            34: 
        !            35:     /*
        !            36:      * Registration of UT need to be done only once for first
        !            37:      * attaching process.
        !            38:      */
        !            39: 
        !            40:     if ( cProcessesAttached++ ) {
        !            41:         return(TRUE);
        !            42:     }
        !            43: 
        !            44:     return UTRegister( hInst,        // DB32.DLL module handle
        !            45:                        "DB16.DLL",   // name of 16bit thunk dll
        !            46:                        NULL,         // no init routine
        !            47:                        "UTProc",     // name of 16bit dispatch routine
        !            48:                                      // exported from DB16.DLL
        !            49:                        &pfnUTProc,   // Global variable to receive thunk address
        !            50:                        NULL,         // no call back function
        !            51:                        NULL          // no shared memroy
        !            52:                      );
        !            53:   } else if ( fdwReason == DLL_PROCESS_DETACH ) {
        !            54: 
        !            55:       if ( --cProcessesAttached == 0 ) {
        !            56:           UTUnRegister( hInst );
        !            57:       }
        !            58:   }
        !            59: 
        !            60: }
        !            61: 
        !            62: /*
        !            63:  * constants for dispatcher in 16bit side
        !            64:  */
        !            65: 
        !            66: #define DB_SRV_GETVERSION   0
        !            67: #define DB_SRV_SETTIME      1
        !            68: #define DB_SRV_ADDUSER      2
        !            69: 
        !            70: 
        !            71: int
        !            72: DbGetVersion(void)
        !            73: {
        !            74: 
        !            75:     /*
        !            76:      * call the 16bit dispatch thru the 32bit thunk. no parameters
        !            77:      * are passed.
        !            78:      * returned value is the service result.
        !            79:      */
        !            80: 
        !            81:     return( (int) (* pfnUTProc)(NULL, DB_SRV_GETVERSION, NULL) );
        !            82: 
        !            83: }
        !            84: 
        !            85: void
        !            86: DbSetTime(LPDB_TIME pTime)
        !            87: {
        !            88: 
        !            89:     /*
        !            90:      * call the 16bit dispatch thru the 32bit thunk.
        !            91:      * pass one pointer to a buffer which will be translated
        !            92:      * to 16:16 address before passed to 16bit side.
        !            93:      *
        !            94:      */
        !            95: 
        !            96:     (* pfnUTProc)(pTime, DB_SRV_SETTIME, NULL);
        !            97: 
        !            98: }
        !            99: 
        !           100: short
        !           101: DbAddUser(LPDB_NAME pName, DWORD Permission, LPDWORD pId)
        !           102: {
        !           103: 
        !           104:     DWORD    Args[3];           // function has three arguments
        !           105:     PVOID    TransList[4];      // Three pointers need translation:
        !           106:                                 //     pName
        !           107:                                 //     pName->str
        !           108:                                 //     pId
        !           109:                                 // plus null to indicate end of list
        !           110:     char    *pSaveStr;
        !           111:     int     Ret;
        !           112: 
        !           113:     /*
        !           114:      * put arguments in buffer
        !           115:      */
        !           116: 
        !           117:     Args[0] = (DWORD) pName;
        !           118:     Args[1] = Permission;
        !           119:     Args[2] = (DWORD) pId;
        !           120: 
        !           121:     /*
        !           122:      * build translation list for all the flat pointers that need to
        !           123:      * be translated to segmented form.
        !           124:      */
        !           125:     TransList[0] = & Args[0];
        !           126:     TransList[1] = & pName->str;
        !           127:     TransList[2] = & Args[2];
        !           128:     TransList[3] = 0;
        !           129: 
        !           130:     /*
        !           131:      * save the original pointer in the NAME struct so it can be restored
        !           132:      * after the call to the thunk.
        !           133:      * This is required only if the caller of the service expects the
        !           134:      * structure to be left unmodified.
        !           135:      */
        !           136: 
        !           137:     pSaveStr = pName->str;
        !           138: 
        !           139:     /*
        !           140:      * call the 16bit dispatch thru the 32bit thunk.
        !           141:      * pass arguments in buffer along with list of addresses
        !           142:      * that need to be translated equivalent segmented format.
        !           143:      *
        !           144:      */
        !           145: 
        !           146:     Ret = (int) (* pfnUTProc)(Args, DB_SRV_ADDUSER, TransList);
        !           147: 
        !           148:     /*
        !           149:      * restore flat pointer
        !           150:      */
        !           151:     pName->str = pSaveStr;
        !           152: 
        !           153:     return(Ret);
        !           154: }
        !           155: 
        !           156: 

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