Return to ifsmgr.inc CVS log

Up to [truecrypt] / truecrypt / driver vxd

Annotation of truecrypt/driver vxd/ifsmgr.inc, revision 1.1

1.1     ! root        1: /* IFSMGR.H -- Declarations for Installable File System Manager Calls
        !             2:  Copyright (C) 1996 by Walter Oney
        !             3:  All rights reserved
        !             4: 
        !             5:  Wrapper Modifications and extentions by Aman.
        !             6:  */
        !             7: 
        !             8: #include "ifs.h"       /* Win 95 DDk one seems ok, but Oney has his own */
        !             9: #define IFSMGRVERSION 0x22
        !            10: 
        !            11: /*
        !            12:  IFSMgr services
        !            13:  */
        !            14: 
        !            15: #ifndef IFSMgr_DEVICE_ID
        !            16: #define IFSMgr_DEVICE_ID 0x0040
        !            17: #endif
        !            18: 
        !            19: #ifndef Not_VxD
        !            20: 
        !            21: #undef IFSMgr_Service
        !            22: #define IFSMgr_Service Declare_Service
        !            23: #pragma warning(disable:4003)  /* not enough parameters */
        !            24: #include <vmm.h>
        !            25: 
        !            26: #include <vtd.h>
        !            27: Begin_Service_Table(IFSMgr)
        !            28: 
        !            29: IFSMgr_Service(IFSMgr_Get_Version)
        !            30: IFSMgr_Service(IFSMgr_RegisterMount)
        !            31: IFSMgr_Service(IFSMgr_RegisterNet)
        !            32: IFSMgr_Service(IFSMgr_RegisterMailSlot)
        !            33: IFSMgr_Service(IFSMgr_Attach)
        !            34: IFSMgr_Service(IFSMgr_Detach)
        !            35: IFSMgr_Service(IFSMgr_Get_NetTime)
        !            36: IFSMgr_Service(IFSMgr_Get_DOSTime)
        !            37: IFSMgr_Service(IFSMgr_SetupConnection)
        !            38: IFSMgr_Service(IFSMgr_DerefConnection)
        !            39: IFSMgr_Service(IFSMgr_ServerDOSCall)
        !            40: IFSMgr_Service(IFSMgr_CompleteAsync)
        !            41: IFSMgr_Service(IFSMgr_RegisterHeap)
        !            42: IFSMgr_Service(IFSMgr_GetHeap)
        !            43: IFSMgr_Service(IFSMgr_RetHeap)
        !            44: IFSMgr_Service(IFSMgr_CheckHeap)
        !            45: IFSMgr_Service(IFSMgr_CheckHeapItem)
        !            46: IFSMgr_Service(IFSMgr_FillHeapSpare)
        !            47: IFSMgr_Service(IFSMgr_Block)
        !            48: IFSMgr_Service(IFSMgr_Wakeup)
        !            49: IFSMgr_Service(IFSMgr_Yield)
        !            50: IFSMgr_Service(IFSMgr_SchedEvent)
        !            51: IFSMgr_Service(IFSMgr_QueueEvent)
        !            52: IFSMgr_Service(IFSMgr_KillEvent)
        !            53: IFSMgr_Service(IFSMgr_FreeIOReq)
        !            54: IFSMgr_Service(IFSMgr_MakeMailSlot)
        !            55: IFSMgr_Service(IFSMgr_DeleteMailSlot)
        !            56: IFSMgr_Service(IFSMgr_WriteMailSlot)
        !            57: IFSMgr_Service(IFSMgr_PopUp)
        !            58: IFSMgr_Service(IFSMgr_printf)
        !            59: IFSMgr_Service(IFSMgr_AssertFailed)
        !            60: IFSMgr_Service(IFSMgr_LogEntry)
        !            61: IFSMgr_Service(IFSMgr_DebugMenu)
        !            62: IFSMgr_Service(IFSMgr_DebugVars)
        !            63: IFSMgr_Service(IFSMgr_GetDebugString)
        !            64: IFSMgr_Service(IFSMgr_GetDebugHexNum)
        !            65: IFSMgr_Service(IFSMgr_NetFunction)
        !            66: IFSMgr_Service(IFSMgr_DoDelAllUses)
        !            67: IFSMgr_Service(IFSMgr_SetErrString)
        !            68: IFSMgr_Service(IFSMgr_GetErrString)
        !            69: IFSMgr_Service(IFSMgr_SetReqHook)
        !            70: IFSMgr_Service(IFSMgr_SetPathHook)
        !            71: IFSMgr_Service(IFSMgr_UseAdd)
        !            72: IFSMgr_Service(IFSMgr_UseDel)
        !            73: IFSMgr_Service(IFSMgr_InitUseAdd)
        !            74: IFSMgr_Service(IFSMgr_ChangeDir)
        !            75: IFSMgr_Service(IFSMgr_DelAllUses)
        !            76: IFSMgr_Service(IFSMgr_CDROM_Attach)
        !            77: IFSMgr_Service(IFSMgr_CDROM_Detach)
        !            78: IFSMgr_Service(IFSMgr_Win32DupHandle)
        !            79: IFSMgr_Service(IFSMgr_Ring0_FileIO)
        !            80: IFSMgr_Service(IFSMgr_Win32_Get_Ring0_Handle)
        !            81: IFSMgr_Service(IFSMgr_Get_Drive_Info)
        !            82: IFSMgr_Service(IFSMgr_Ring0GetDriveInfo)
        !            83: IFSMgr_Service(IFSMgr_BlockNoEvents)
        !            84: IFSMgr_Service(IFSMgr_NetToDosTime)
        !            85: IFSMgr_Service(IFSMgr_DosToNetTime)
        !            86: IFSMgr_Service(IFSMgr_DosToWin32Time)
        !            87: IFSMgr_Service(IFSMgr_Win32ToDosTime)
        !            88: IFSMgr_Service(IFSMgr_NetToWin32Time)
        !            89: IFSMgr_Service(IFSMgr_Win32ToNetTime)
        !            90: IFSMgr_Service(IFSMgr_MetaMatch)
        !            91: IFSMgr_Service(IFSMgr_TransMatch)
        !            92: IFSMgr_Service(IFSMgr_CallProvider)
        !            93: IFSMgr_Service(UniToBCS)
        !            94: IFSMgr_Service(UniToBCSPath)
        !            95: IFSMgr_Service(BCSToUni)
        !            96: IFSMgr_Service(UniToUpper)
        !            97: IFSMgr_Service(UniCharToOEM)
        !            98: IFSMgr_Service(CreateBasis)
        !            99: IFSMgr_Service(MatchBasisName)
        !           100: IFSMgr_Service(AppendBasisTail)
        !           101: IFSMgr_Service(FcbToShort)
        !           102: IFSMgr_Service(ShortToFcb)
        !           103: IFSMgr_Service(IFSMgr_ParsePath)
        !           104: IFSMgr_Service(Query_PhysLock)
        !           105: IFSMgr_Service(_VolFlush)
        !           106: IFSMgr_Service(NotifyVolumeArrival)
        !           107: IFSMgr_Service(NotifyVolumeRemoval)
        !           108: IFSMgr_Service(QueryVolumeRemoval)
        !           109: IFSMgr_Service(IFSMgr_FSDUnmountCFSD)
        !           110: IFSMgr_Service(IFSMgr_GetConversionTablePtrs)
        !           111: IFSMgr_Service(IFSMgr_CheckAccessConflict)
        !           112: IFSMgr_Service(IFSMgr_LockFile)
        !           113: IFSMgr_Service(IFSMgr_UnlockFile)
        !           114: IFSMgr_Service(IFSMgr_RemoveLocks)
        !           115: IFSMgr_Service(IFSMgr_CheckLocks)
        !           116: IFSMgr_Service(IFSMgr_CountLocks)
        !           117: IFSMgr_Service(IFSMgr_ReassignLockFileInst)
        !           118: IFSMgr_Service(IFSMgr_UnassignLockList)
        !           119: IFSMgr_Service(IFSMgr_MountChildVolume)
        !           120: IFSMgr_Service(IFSMgr_UnmountChildVolume)
        !           121: IFSMgr_Service(IFSMgr_SwapDrives)
        !           122: IFSMgr_Service(IFSMgr_FSDMapFHtoIOREQ)
        !           123: IFSMgr_Service(IFSMgr_FSDParsePath)
        !           124: IFSMgr_Service(IFSMgr_FSDAttachSFT)
        !           125: IFSMgr_Service(IFSMgr_GetTimeZoneBias)
        !           126: IFSMgr_Service(IFSMgr_PNPEvent)
        !           127: IFSMgr_Service(IFSMgr_RegisterCFSD)
        !           128: IFSMgr_Service(IFSMgr_Win32MapExtendedHandleToSFT)
        !           129: IFSMgr_Service(IFSMgr_DbgSetFileHandleLimit)
        !           130: IFSMgr_Service(IFSMgr_Win32MapSFTToExtendedHandle)
        !           131: IFSMgr_Service(IFSMgr_FSDGetCurrentDrive)
        !           132: IFSMgr_Service(IFSMgr_InstallFileSystemApiHook)
        !           133: IFSMgr_Service(IFSMgr_RemoveFileSystemApiHook)
        !           134: IFSMgr_Service(IFSMgr_RunScheduledEvents)
        !           135: IFSMgr_Service(IFSMgr_CheckDelResource)
        !           136: IFSMgr_Service(IFSMgr_Win32GetVMCurdir)
        !           137: IFSMgr_Service(IFSMgr_SetupFailedConnection)
        !           138: IFSMgr_Service(_GetMappedErr)
        !           139: IFSMgr_Service(ShortToLossyFcb)
        !           140: IFSMgr_Service(IFSMgr_GetLockState)
        !           141: IFSMgr_Service(BcsToBcs)
        !           142: IFSMgr_Service(IFSMgr_SetLoopback)
        !           143: IFSMgr_Service(IFSMgr_ClearLoopback)
        !           144: IFSMgr_Service(IFSMgr_ParseOneElement)
        !           145: IFSMgr_Service(BcsToBcsUpper)
        !           146: 
        !           147: End_Service_Table(IFSMgr)
        !           148: 
        !           149: #pragma warning(default:4003)
        !           150: 
        !           151: #endif /* Not_VxD */
        !           152: 
        !           153: /*
        !           154:  Inline service function definitions:
        !           155: */
        !           156: 
        !           157: #ifndef Not_VxD
        !           158: #pragma warning(disable:4035)  /* missing return value */
        !           159: 
        !           160: #undef NAKED
        !           161: #define NAKED __declspec(naked)
        !           162: 
        !           163: DWORD VXDINLINE IFSMgr_Get_Version()
        !           164:        {
        !           165:        VxDCall(IFSMgr_Get_Version)
        !           166:        _asm jnc okay
        !           167:        _asm xor eax, eax
        !           168:        _asm okay:
        !           169:        }
        !           170: 
        !           171: #define NORMAL_FSD 0
        !           172: #define DEFAULT_FSD 1
        !           173: 
        !           174: int VXDINLINE NAKED IFSMgr_RegisterCFSD(pIFSFunc fcn, UINT version, string_t* ppDeviceNames)
        !           175:        {
        !           176:        VxDJmp(IFSMgr_RegisterCFSD)
        !           177:        }
        !           178: 
        !           179: /* Command codes in ir_flags for calls to mailslot procedure: */
        !           180: 
        !           181: #define MSLOT_CREATE 0
        !           182: #define MSLOT_DELETE 1
        !           183: #define MSLOT_WRITE 2
        !           184: 
        !           185: int VXDINLINE NAKED IFSMgr_RegisterMailSlot(pIFSFunc fcn, UINT version)
        !           186:        {
        !           187:        VxDJmp(IFSMgr_RegisterMailSlot)
        !           188:        }
        !           189: 
        !           190: int VXDINLINE NAKED IFSMgr_RegisterMount(pIFSFunc fcn, UINT version, UINT defoption)
        !           191:        {
        !           192:        VxDJmp(IFSMgr_RegisterMount)
        !           193:        }
        !           194: 
        !           195: int VXDINLINE NAKED IFSMgr_RegisterNet(pIFSFunc fcn, UINT version, UINT netid)
        !           196:        {
        !           197:        VxDJmp(IFSMgr_RegisterNet)
        !           198:        }
        !           199: 
        !           200: #define DEBUG_FENCE_ON 1
        !           201: 
        !           202: #ifdef DEBUG
        !           203: VOID VXDINLINE NAKED IFSMgr_RegisterHeap(pIFSFunc fcn, UINT flag)
        !           204:        {
        !           205:        VxDJmp(IFSMgr_RegisterHeap)
        !           206:        }
        !           207: #else
        !           208: #define IFSMgr_RegisterHeapUser(a1,a2)
        !           209: #endif
        !           210: 
        !           211: PVOID VXDINLINE NAKED IFSMgr_GetHeap(UINT size)
        !           212:        {
        !           213:        VxDJmp(IFSMgr_GetHeap)
        !           214:        }
        !           215: 
        !           216: VOID VXDINLINE NAKED IFSMgr_RetHeap(PVOID p)
        !           217:        {
        !           218:        VxDJmp(IFSMgr_RetHeap)
        !           219:        }
        !           220: 
        !           221: #ifdef DEBUG
        !           222: #define CHECKHEAP(p) IFSMgr_CheckHeap(p, __FILE__, __LINE__);
        !           223: #define CHECKHEAPITEM(p) IFSMgr_CheckHeapItem(p, __FILE__, __LINE__);
        !           224: int VXDINLINE NAKED IFSMgr_CheckHeap(PVOID pmem, char* filename, UINT line)
        !           225:        {
        !           226:        VxDJmp(IFSMgr_CheckHeap)
        !           227:        }
        !           228: int VXDINLINE NAKED IFSMgr_CheckHeapItem(PVOID pmem, char* filename, UINT line)
        !           229:        {
        !           230:        VxDJmp(IFSMgr_CheckHeapItem)
        !           231:        }
        !           232: #else
        !           233: #define CHECKHEAP(p)
        !           234: #define CHECKHEAPITEM(p)
        !           235: #define IFSMgr_CheckHeap(a1, a2, a3)
        !           236: #define IFSMgr_CheckHeapItem(a1, a2, a3)
        !           237: #endif
        !           238: 
        !           239: VOID VXDINLINE NAKED IFSMgr_FillHeapSpare()
        !           240:        {
        !           241:        VxDJmp(IFSMgr_FillHeapSpare)
        !           242:        }
        !           243: 
        !           244: typedef DWORD nettime_t;               /* # seconds since 1/1/1970 */
        !           245: 
        !           246: typedef struct nettimex_t
        !           247:        {
        !           248:        DWORD dwSeconds;                        /* # seconds since 1/1/1970 */
        !           249:        DWORD dwMilliseconds;           /* milliseconds in last second */
        !           250:        } nettimex_t;
        !           251: 
        !           252: typedef struct dostimex_t
        !           253:        {
        !           254:        WORD wTime;                                     /* time in DOS format */
        !           255:        WORD wDate;                                     /* date in DOS format */
        !           256:        DWORD dwMilliseconds;           /* # milliseconds in last 2-sec interval */
        !           257:        } dostimex_t;
        !           258: 
        !           259: nettimex_t VXDINLINE NAKED IFSMgr_Get_NetTimeEx()
        !           260:        {
        !           261:        VxDJmp(IFSMgr_Get_NetTime)
        !           262:        }
        !           263: 
        !           264: nettime_t VXDINLINE NAKED IFSMgr_Get_NetTime()
        !           265:        {
        !           266:        VxDJmp(IFSMgr_Get_NetTime)
        !           267:        }
        !           268: 
        !           269: dostimex_t VXDINLINE NAKED IFSMgr_Get_DOSTimeEx()
        !           270:        {
        !           271:        VxDJmp(IFSMgr_Get_DOSTime)
        !           272:        }
        !           273: 
        !           274: typedef dos_time dostime_t;
        !           275: 
        !           276: dostime_t VXDINLINE NAKED IFSMgr_Get_DOSTime()
        !           277:        {
        !           278:        VxDJmp(IFSMgr_Get_DOSTime)
        !           279:        }
        !           280: 
        !           281: dostime_t VXDINLINE NAKED IFSMgr_NetToDosTime(DWORD nettime)
        !           282:        {
        !           283:        VxDJmp(IFSMgr_NetToDosTime)
        !           284:        }
        !           285: 
        !           286: DWORD VXDINLINE NAKED IFSMgr_DosToNetTime(dostime_t dostime)
        !           287:        {
        !           288:        VxDJmp(IFSMgr_DosToNetTime)
        !           289:        }
        !           290: 
        !           291: _FILETIME VXDINLINE NAKED IFSMgr_DosToWin32Time(dostime_t dostime)
        !           292:        {
        !           293:        VxDJmp(IFSMgr_DosToWin32Time)
        !           294:        }
        !           295: 
        !           296: dostime_t VXDINLINE NAKED IFSMgr_Win32ToDosTime(_FILETIME win32time)
        !           297:        {
        !           298:        VxDJmp(IFSMgr_Win32ToDosTime)
        !           299:        }
        !           300: 
        !           301: _FILETIME VXDINLINE NAKED IFSMgr_NetToWin32Time(DWORD nettime)
        !           302:        {
        !           303:        VxDJmp(IFSMgr_NetToWin32Time)
        !           304:        }
        !           305: 
        !           306: DWORD VXDINLINE NAKED IFSMgr_Win32ToNetTime(_FILETIME win32time)
        !           307:        {
        !           308:        VxDJmp(IFSMgr_Win32ToNetTime)
        !           309:        }
        !           310: 
        !           311: int VXDINLINE NAKED IFSMgr_GetTimeZoneBias()
        !           312:        {
        !           313:        VxDJmp(IFSMgr_GetTimeZoneBias)
        !           314:        }
        !           315: 
        !           316: VOID VXDINLINE NAKED IFSMgr_SetupConnection(pioreq pir, UINT resopt, UINT restype)
        !           317:        {
        !           318:        VxDJmp(IFSMgr_SetupConnection)
        !           319:        }
        !           320: 
        !           321: VOID VXDINLINE NAKED IFSMgr_DerefConnection(pioreq pir)
        !           322:        {
        !           323:        VxDJmp(IFSMgr_DerefConnection)
        !           324:        }
        !           325: 
        !           326: typedef union tagDPL32
        !           327:        {
        !           328:        struct DPL32_DW 
        !           329:                {
        !           330:                DWORD DPL32_EAX;
        !           331:                DWORD DPL32_EBX;
        !           332:                DWORD DPL32_ECX;
        !           333:                DWORD DPL32_EDX;
        !           334:                DWORD DPL32_ESI;
        !           335:                DWORD DPL32_EDI;
        !           336:                DWORD DPL32_EBP;
        !           337:                WORD  DPL32_UID;
        !           338:                WORD  DPL32_PID;
        !           339:                DWORD DPL32_DTA;
        !           340:                BYTE  DPL32_FLAGS;
        !           341:                BYTE  DPL32_PAD[3];
        !           342:                };
        !           343:        struct DPL32_W
        !           344:                {
        !           345:                WORD DPL32_AX, junk1;
        !           346:                WORD DPL32_BX, junk2;
        !           347:                WORD DPL32_CX, junk3;
        !           348:                WORD DPL32_DX, junk4;
        !           349:                WORD DPL32_SI, junk5;
        !           350:                WORD DPL32_DI, junk6;
        !           351:                WORD DPL32_BP, junk7;
        !           352:                DWORD DPL32_PID32;
        !           353:                };
        !           354:        struct DPL32_B
        !           355:                {
        !           356:                BYTE DPL32_AL, APL32_AH;
        !           357:                WORD junk8;
        !           358:                BYTE DPL32_BL, APL32_BH;
        !           359:                WORD junk9;
        !           360:                BYTE DPL32_CL, APL32_CH;
        !           361:                WORD junk10;
        !           362:                BYTE DPL32_DL, APL32_DH;
        !           363:                WORD junk11;
        !           364:                };
        !           365:        } DPL32, *PDPL32;
        !           366: 
        !           367: #define DPL32_USE_MASK         0x03
        !           368: #define DPL32_USE_ANSI         0
        !           369: #define DPL32_USE_OEM          1
        !           370: #define DPL32_USE_UNICODE      2
        !           371: 
        !           372: #define DPL32_8_3_MATCHING     0x04
        !           373: 
        !           374: BOOL VXDINLINE IFSMgr_ServerDOSCall(HVM hVM, UINT fcn, PDPL32 dpl, PCRS pRegs)
        !           375:        {
        !           376:        _asm push ebp
        !           377:        _asm mov ebx, hVM
        !           378:        _asm mov ecx, fcn
        !           379:        _asm mov esi, dpl
        !           380:        _asm mov ebp, pRegs
        !           381:        VxDCall(IFSMgr_ServerDOSCall)
        !           382:        _asm pop ebp
        !           383:        _asm cmc
        !           384:        _asm sbb eax, eax
        !           385:        }
        !           386: 
        !           387: typedef int (_cdecl *pMSFunc)(PVOID pdata, UINT len, BYTE lana);
        !           388: 
        !           389: int VXDINLINE NAKED IFSMgr_MakeMailSlot(pMSFunc fcn, path_t pmsname, PDWORD pmshand)
        !           390:        {
        !           391:        VxDJmp(IFSMgr_MakeMailSlot)
        !           392:        }
        !           393: 
        !           394: int VXDINLINE NAKED IFSMgr_DeleteMailSlot(DWORD mshand)
        !           395:        {
        !           396:        VxDJmp(IFSMgr_DeleteMailSlot)
        !           397:        }
        !           398: 
        !           399: int VXDINLINE NAKED IFSMgr_WriteMailSlot(path_t pmsname, char* pdata, WORD len, BYTE lana, string_t rname, PVOID xtra)
        !           400:        {
        !           401:        VxDJmp(IFSMgr_WriteMailSlot)
        !           402:        }
        !           403: 
        !           404: int VXDINLINE NAKED IFSMgr_SetErrString(char* errstr, UINT errorcode, UINT table)
        !           405:        {
        !           406:        VxDJmp(IFSMgr_SetErrString)
        !           407:        }
        !           408: 
        !           409: VXDINLINE NAKED PCHAR IFSMgr_GetErrString(UINT errorcode, UINT table)
        !           410:        {
        !           411:        VxDJmp(IFSMgr_GetErrString)
        !           412:        }
        !           413: 
        !           414: typedef void (__cdecl *PPREAMBLE)(); 
        !           415: 
        !           416: VXDINLINE NAKED PPREAMBLE IFSMgr_SetReqHook(UINT request, PPREAMBLE preamble)
        !           417:        {
        !           418:        VxDJmp(IFSMgr_SetReqHook)
        !           419:        }
        !           420: 
        !           421: typedef void (__cdecl *PPATHCHECKER)();
        !           422: 
        !           423: VXDINLINE NAKED PPATHCHECKER IFSMgr_SetPathHook(PPATHCHECKER fcn)
        !           424:        {
        !           425:        VxDJmp(IFSMgr_SetPathHook)
        !           426:        }
        !           427: 
        !           428: #endif /* Not_VxD */
        !           429: 
        !           430: typedef struct _LM_GUID {
        !           431:        WORD                    guid_uid;               /* LM10 style user id */
        !           432:        DWORD                   guid_serial;    /* user record serial number */
        !           433:        BYTE                    guid_rsvd[10];  /* pad to 16 bytes */
        !           434:        } _LM_GUID;
        !           435: 
        !           436: typedef struct use_info_2 {
        !           437:        char            ui2_local[9];
        !           438:        char            ui2_pad_1;
        !           439:        char*                   ui2_remote;
        !           440:        char*                   ui2_password;
        !           441:        unsigned short  ui2_status;         
        !           442:        short           ui2_asg_type;       
        !           443:        unsigned short  ui2_refcount;       
        !           444:        unsigned short  ui2_usecount;       
        !           445:        unsigned short  ui2_res_type;       
        !           446:        unsigned short  ui2_flags;          
        !           447:        unsigned short  ui2_usrclass;       
        !           448:        void*               ui2_dirname;        
        !           449:        struct _LM_GUID ui2_dfs_id;         
        !           450:        } use_info_2, *puse_info_2;
        !           451: 
        !           452: #ifndef Not_VxD
        !           453: 
        !           454: int VXDINLINE NAKED IFSMgr_UseAdd(pioreq pir, int proId, netuse_info* pinfo)
        !           455:        {
        !           456:        VxDJmp(IFSMgr_UseAdd)
        !           457:        }
        !           458: 
        !           459: int VXDINLINE NAKED IFSMgr_InitUseAdd(puse_info_2 pui2, int proId, int lana)
        !           460:        {
        !           461:        VxDJmp(IFSMgr_InitUseAdd)
        !           462:        }
        !           463: 
        !           464: int VXDINLINE NAKED IFSMgr_UseDel(pioreq pir, int proId, netuse_info* pinfo)
        !           465:        {
        !           466:        VxDJmp(IFSMgr_UseDel)
        !           467:        }
        !           468: 
        !           469: int VXDINLINE NAKED IFSMgr_DelAllUses(int proId, int force)
        !           470:        {
        !           471:        VxDJmp(IFSMgr_DelAllUses)
        !           472:        }
        !           473: 
        !           474: VOID VXDINLINE NAKED IFSMgr_DoDelAllUses(pioreq pir)
        !           475:        {
        !           476:        VxDJmp(IFSMgr_DoDelAllUses)
        !           477:        }
        !           478: 
        !           479: #if 0
        !           480: int VXDLINLINE NAKED IFSMgr_FSDMapFHtoIOREQ(pioreq pir, WORD doshandle)
        !           481:        {
        !           482:        VxDJmp(IFSMgr_FSDMapFHtoIOREQ)
        !           483:        }
        !           484: #endif
        !           485: 
        !           486: int VXDINLINE NAKED IFSMgr_CheckDelResource(PVOID rh, int force, BOOL fDelFlag)
        !           487:        {
        !           488:        VxDJmp(IFSMgr_CheckDelResource)
        !           489:        }
        !           490: 
        !           491: int VXDINLINE NAKED IFSMgr_SetupFailedConnection(pioreq pir, PDWORD pProId)
        !           492:        {
        !           493:        VxDJmp(IFSMgr_SetupFailedConnection)
        !           494:        }
        !           495: 
        !           496: int VXDINLINE NAKED IFSMgr_SetLoopback(char* pszUNCPath, char* pszLocalPath)
        !           497:        {
        !           498:        VxDJmp(IFSMgr_SetLoopback)
        !           499:        }
        !           500: 
        !           501: int VXDINLINE NAKED IFSMgr_ClearLoopback(char* pszUNCPath)
        !           502:        {
        !           503:        VxDJmp(IFSMgr_ClearLoopback)
        !           504:        }
        !           505: 
        !           506: VOID VXDINLINE NAKED IFSMgr_Block(DWORD key)
        !           507:        {
        !           508:        VxDJmp(IFSMgr_Block)
        !           509:        }
        !           510: 
        !           511: VOID VXDINLINE NAKED IFSMgr_BlockNoEvents(DWORD key)
        !           512:        {
        !           513:        VxDJmp(IFSMgr_BlockNoEvents)
        !           514:        }
        !           515: 
        !           516: VOID VXDINLINE NAKED IFSMgr_Wakeup(DWORD key)
        !           517:        {
        !           518:        VxDJmp(IFSMgr_Wakeup)
        !           519:        }
        !           520: 
        !           521: VOID VXDINLINE NAKED IFSMgr_Yield()
        !           522:        {
        !           523:        VxDJmp(IFSMgr_Yield)
        !           524:        }
        !           525: 
        !           526: VOID VXDINLINE NAKED IFSMgr_SchedEvent(pevent pev, DWORD time)
        !           527:        {
        !           528:        VxDJmp(IFSMgr_SchedEvent)
        !           529:        }
        !           530: 
        !           531: VOID VXDINLINE NAKED IFSMgr_QueueEvent(pevent pev)
        !           532:        {
        !           533:        VxDJmp(IFSMgr_QueueEvent)
        !           534:        }
        !           535: 
        !           536: VOID VXDINLINE NAKED IFSMgr_KillEvent(pevent pev)
        !           537:        {
        !           538:        VxDJmp(IFSMgr_KillEvent)
        !           539:        }
        !           540: 
        !           541: VOID VXDINLINE NAKED IFSMgr_FreeIOReq(pioreq pir)
        !           542:        {
        !           543:        VxDJmp(IFSMgr_FreeIOReq)
        !           544:        }
        !           545: 
        !           546: VOID VXDINLINE NAKED IFSMgr_RunScheduledEvents()
        !           547:        {
        !           548:        VxDJmp(IFSMgr_RunScheduledEvents)
        !           549:        }
        !           550: 
        !           551: UINT VXDINLINE NAKED IFSMgr_MetaMatch(string_t pUniPattern, string_t pUniName, int matchSem)
        !           552:        {
        !           553:        VxDJmp(IFSMgr_MetaMatch)
        !           554:        }
        !           555: 
        !           556: int VXDINLINE NAKED IFSMgr_TransMatch(pioreq pir, srch_entry* pse, string_t pattern, _WIN32_FIND_DATA* pFindBuf)
        !           557:        {
        !           558:        VxDJmp(IFSMgr_TransMatch)
        !           559:        }
        !           560: 
        !           561: UINT VXDINLINE NAKED UniToBCSPath(PBYTE pBCSPath, PathElement* pUniPath, UINT maxLength, int charSet)
        !           562:        {
        !           563:        VxDJmp(UniToBCSPath)
        !           564:        }
        !           565: 
        !           566: UINT VXDINLINE NAKED UniToBCS(PBYTE pBCSPath, string_t pUniPath, UINT length, UINT maxLength, UINT charSet)
        !           567:        {
        !           568:        VxDJmp(UniToBCS)
        !           569:        }
        !           570: 
        !           571: UINT VXDINLINE NAKED BCSToUni(string_t pUniStr, PBYTE pBCSStr, UINT length, int charSet)
        !           572:        {
        !           573:        VxDJmp(BCSToUni)
        !           574:        }
        !           575: 
        !           576: UINT VXDINLINE NAKED BcsToBcs(PBYTE pDest, PBYTE pSrc, UINT dstCharSet, UINT srcCharSet, UINT MaxLen)
        !           577:        {
        !           578:        VxDJmp(BcsToBcs)
        !           579:        }
        !           580: 
        !           581: UINT VXDINLINE NAKED UniCharToOEM(WORD uniChar)
        !           582:        {
        !           583:        VxDJmp(UniCharToOEM)
        !           584:        }
        !           585: 
        !           586: UINT VXDINLINE NAKED UniToUpper(string_t pUniUpStr, string_t pUniStr, UINT length)
        !           587:        {
        !           588:        VxDJmp(UniToUpper)
        !           589:        }
        !           590: 
        !           591: UINT VXDINLINE NAKED CreateBasis(string_t pBasisName, string_t pUniName, UINT length)
        !           592:        {
        !           593:        VxDJmp(CreateBasis)
        !           594:        }
        !           595: 
        !           596: int VXDINLINE NAKED MatchBasisName(string_t pBasisName, string_t pName)
        !           597:        {
        !           598:        VxDJmp(MatchBasisName)
        !           599:        }
        !           600: 
        !           601: int VXDINLINE NAKED AppendBasisTail(string_t pBasisName, int tail)
        !           602:        {
        !           603:        VxDJmp(AppendBasisTail)
        !           604:        }
        !           605: 
        !           606: int VXDINLINE NAKED FcbToShort(string_t p83name, string_t pFCBName, int trailDot)
        !           607:        {
        !           608:        VxDJmp(FcbToShort)
        !           609:        }
        !           610: 
        !           611: int VXDINLINE NAKED ShortToFcb(string_t pFCBName, string_t p83Name, UINT length)
        !           612:        {
        !           613:        VxDJmp(ShortToFcb)
        !           614:        }
        !           615: 
        !           616: int VXDINLINE NAKED ShortToLossyFcb(string_t pFCBName, string_t p83Name, UINT length)
        !           617:        {
        !           618:        VxDJmp(ShortToLossyFcb)
        !           619:        }
        !           620: 
        !           621: typedef struct _CONVTABLES
        !           622:        {
        !           623:        DWORD   ct_length;
        !           624:        PDWORD  ct_UniToWinAnsiTbl;
        !           625:        PDWORD  ct_UniToOemTbl;
        !           626:        PDWORD  ct_WinAnsiToUniTbl;
        !           627:        PDWORD  ct_OemToUniTable;
        !           628:        PDWORD  ct_UniToUpperDeltaTbl;
        !           629:        PDWORD  ct_UniToUpperTbl;
        !           630:        } _CONVTABLES, *_PCONVTABLES;
        !           631: 
        !           632: _PCONVTABLES VXDINLINE NAKED IFSMgr_GetConversionTablePtrs()
        !           633:        {
        !           634:        VxDJmp(IFSMgr_GetConversionTablePtrs)
        !           635:        }
        !           636: 
        !           637: int VXDINLINE NAKED IFSMgr_ParsePath(pioreq pir)
        !           638:        {
        !           639:        VxDJmp(IFSMgr_ParsePath)
        !           640:        }
        !           641: 
        !           642: int VXDINLINE NAKED IFSMgr_FSDParsePath(pioreq pir)
        !           643:        {
        !           644:        VxDJmp(IFSMgr_FSDParsePath)
        !           645:        }
        !           646: 
        !           647: int VXDINLINE NAKED IFSMgr_ParseOneElement(USHORT* pe_unichars)
        !           648:        {
        !           649:        VxDJmp(IFSMgr_ParseOneElement)
        !           650:        }
        !           651: 
        !           652: int VXDINLINE NAKED IFSMgr_CheckAccessConflict(int fSortCompatibleDisable, fmode_t pfmode, int (*pfn)(fmode_t*, const void*), const void* FSDCookie)
        !           653:        {
        !           654:        VxDJmp(IFSMgr_CheckAccessConflict)
        !           655:        }
        !           656: 
        !           657: int VXDINLINE NAKED IFSMgr_LockFile(void** ppFSDLockListHead, DWORD LockOffset, DWORD LockLength, DWORD LockOwner, PVOID pOpenFileInstance, DWORD fLockSemantics)
        !           658:        {
        !           659:        VxDJmp(IFSMgr_LockFile)
        !           660:        }
        !           661: 
        !           662: int VXDINLINE NAKED IFSMgr_UnlockFile(void** ppFSDLockListHead, DWORD LockOffset, DWORD LockLength, DWORD LockOwner, PVOID pOpenFileInstance, DWORD fLockSemantics)
        !           663:        {
        !           664:        VxDJmp(IFSMgr_UnlockFile)
        !           665:        }
        !           666: 
        !           667: VOID VXDINLINE NAKED IFSMgr_RemoveLocks(void** ppFSDLockListHead, DWORD LockOwner, PVOID pOpenFileInstance)
        !           668:        {
        !           669:        VxDJmp(IFSMgr_RemoveLocks)
        !           670:        }
        !           671: 
        !           672: int VXDINLINE NAKED IFSMgr_CheckLocks(PVOID pFSDLockListHead, DWORD Offset, DWORD Length, DWORD Process, PVOID pOpenFileInstance, DWORD fOperation)
        !           673:        {
        !           674:        VxDJmp(IFSMgr_CheckLocks)
        !           675:        }
        !           676: 
        !           677: int VXDINLINE NAKED IFSMgr_CountLocks(PVOID pFSDLockListHead, PVOID pOpenFileInstance)
        !           678:        {
        !           679:        VxDJmp(IFSMgr_CountLocks)
        !           680:        }
        !           681: 
        !           682: VOID VXDINLINE NAKED IFSMgr_UnassignLockList(PVOID pFSDLockListHead)
        !           683:        {
        !           684:        VxDJmp(IFSMgr_UnassignLockList)
        !           685:        }
        !           686: 
        !           687: VOID VXDINLINE NAKED IFSMgr_ReassignLockFileInst(PVOID pFSDLockListhead, PVOID pOldOpenFileInstance, PVOID pNewOpenFileInstance)
        !           688:        {
        !           689:        VxDJmp(IFSMgr_ReassignLockFileInst)
        !           690:        }
        !           691: 
        !           692: VOID VXDINLINE NAKED NotifyVolumeArrival(UINT drive)
        !           693:        {
        !           694:        VxDJmp(NotifyVolumeArrival)
        !           695:        }
        !           696: 
        !           697: int VXDINLINE NAKED QueryVolumeRemoval(UINT drive, int fDialog)
        !           698:        {
        !           699:        VxDJmp(QueryVolumeRemoval)
        !           700:        }
        !           701: 
        !           702: VOID VXDINLINE NAKED NotifyVolumeRemoval(UINT drive)
        !           703:        {
        !           704:        VxDJmp(NotifyVolumeRemoval)
        !           705:        }
        !           706: 
        !           707: int VXDINLINE NAKED IFSMgr_PNPEvent(UINT Message, UINT Resource, UINT Flags)
        !           708:        {
        !           709:        VxDJmp(IFSMgr_PNPEvent)
        !           710:        }
        !           711: 
        !           712: int VXDINLINE NAKED _VolFlush(UINT Volume, int Flags)
        !           713:        {
        !           714:        VxDJmp(_VolFlush)
        !           715:        }
        !           716: 
        !           717: VOID VXDINLINE NAKED IFSMgr_CompleteAsync(pioreq pir)
        !           718:        {
        !           719:        VxDJmp(IFSMgr_CompleteAsync)
        !           720:        }
        !           721: 
        !           722: int VXDINLINE R0_OpenCreateFile(BOOL incontext, WORD modeflags, WORD attrib, BYTE action, BYTE flags, char* pathname, PDWORD phandle, PDWORD paction)
        !           723:        {
        !           724:        DWORD opcode = incontext ? R0_OPENCREAT_IN_CONTEXT : R0_OPENCREATFILE;
        !           725:        DWORD result=0;
        !           726:        _asm
        !           727:                {
        !           728:                pushad
        !           729:                mov     eax, R0_OPENCREATFILE ;/* opcode */
        !           730:                xor ebx,ebx
        !           731:                xor ecx,ecx
        !           732:                xor edx,edx
        !           733:                mov bx, [modeflags]
        !           734:                mov cx, [attrib]
        !           735:                mov dl, [action]
        !           736:                mov dh, [flags]
        !           737:                mov esi, [pathname]
        !           738:                }
        !           739:        VxDCall(IFSMgr_Ring0_FileIO)
        !           740:        _asm
        !           741:                {
        !           742:                jc      error
        !           743:                mov ebx, [phandle]
        !           744:                mov [ebx], eax
        !           745:                mov ebx, [paction]
        !           746:                mov [ebx], ecx
        !           747:                xor eax, eax
        !           748:                
        !           749:        error:
        !           750:                
        !           751:                mov     [WORD PTR result], ax
        !           752:                popad
        !           753:        }
        !           754:        return result;
        !           755:        }
        !           756: 
        !           757: int VXDINLINE R0_ReadFile(BOOL incontext, DWORD handle, DWORD count, DWORD pos, PBYTE buffer, PDWORD nread)
        !           758:        {
        !           759:        DWORD opcode = incontext ? R0_READFILE_IN_CONTEXT : R0_READFILE;
        !           760:        DWORD result=0;
        !           761:        _asm
        !           762:                {
        !           763:                pushad
        !           764:                mov     eax, R0_READFILE ; /* opcode */
        !           765:                mov     ebx, [handle]
        !           766:                mov ecx, [count]
        !           767:                mov edx, [pos]
        !           768:                mov esi, [buffer]
        !           769:                }
        !           770:        VxDCall(IFSMgr_Ring0_FileIO)
        !           771:        _asm
        !           772:                {
        !           773:                jc      error
        !           774:                mov ebx, [nread]
        !           775:                mov [ebx], ecx
        !           776:                xor eax, eax
        !           777:        error:
        !           778:                mov     [WORD PTR result], ax
        !           779:                popad
        !           780:                }
        !           781:        return result;
        !           782:        }
        !           783: 
        !           784: int VXDINLINE R0_WriteFile(BOOL incontext, DWORD handle, DWORD count, DWORD pos, const BYTE* buffer, PDWORD nwritten)
        !           785:        {
        !           786:        DWORD opcode = incontext ? R0_WRITEFILE_IN_CONTEXT : R0_WRITEFILE;
        !           787:        DWORD result=0;
        !           788:        _asm
        !           789:                {
        !           790:                pushad
        !           791:                
        !           792:                mov     eax, R0_WRITEFILE ; /* opcode */
        !           793:                mov     ebx, [handle]
        !           794:                mov ecx, [count]
        !           795:                mov edx, [pos]
        !           796:                mov esi, [buffer]
        !           797:                }
        !           798:        VxDCall(IFSMgr_Ring0_FileIO)
        !           799:        _asm
        !           800:                {
        !           801:                jc      error
        !           802:        
        !           803:                mov ebx, nwritten
        !           804:                mov [ebx], ecx
        !           805:                xor eax, eax
        !           806:        error:
        !           807:                mov [WORD PTR result], ax
        !           808:                popad
        !           809:                }
        !           810:        return result;
        !           811:        }
        !           812: 
        !           813: int VXDINLINE R0_CloseFile(DWORD handle)
        !           814:        {
        !           815:        _asm
        !           816:                {
        !           817:                mov     eax, R0_CLOSEFILE
        !           818:                mov ebx, [handle]
        !           819:                }
        !           820:        VxDCall(IFSMgr_Ring0_FileIO)
        !           821:        _asm jc error
        !           822:        _asm xor eax, eax
        !           823:        _asm error:
        !           824:        _asm movzx eax, ax
        !           825:        }
        !           826: 
        !           827: int VXDINLINE R0_GetFileSize(DWORD handle, PDWORD psize)
        !           828:        {
        !           829:        _asm
        !           830:                {
        !           831:                mov     eax, R0_GETFILESIZE
        !           832:                mov ebx, handle
        !           833:                }
        !           834:        VxDCall(IFSMgr_Ring0_FileIO)
        !           835:        _asm
        !           836:                {
        !           837:                jc      error
        !           838:                mov ebx, psize
        !           839:                mov [ebx], eax
        !           840:                xor     eax, eax
        !           841:        error:
        !           842:                movzx eax, ax
        !           843:                }
        !           844:        }
        !           845: 
        !           846: int VXDINLINE R0_FindFirstFile(WORD attrib, const char* pathname, _WIN32_FIND_DATA* fd, PDWORD phandle)
        !           847:        {
        !           848:        _asm
        !           849:                {
        !           850:                mov     eax, R0_FINDFIRSTFILE
        !           851:                mov     esi, pathname
        !           852:                mov edx, fd
        !           853:                }
        !           854:        VxDCall(IFSMgr_Ring0_FileIO)
        !           855:        _asm
        !           856:                {
        !           857:                jc      error
        !           858:                mov ebx, phandle
        !           859:                mov [ebx], eax
        !           860:                xor eax, eax
        !           861:        error:
        !           862:                movzx eax, ax
        !           863:                }
        !           864:        }
        !           865: 
        !           866: int VXDINLINE R0_FindNextFile(DWORD handle, _WIN32_FIND_DATA* fd)
        !           867:        {
        !           868:        _asm
        !           869:                {
        !           870:                mov     eax, R0_FINDNEXTFILE
        !           871:                mov ebx, handle
        !           872:                mov edx, fd
        !           873:                }
        !           874:        VxDCall(IFSMgr_Ring0_FileIO)
        !           875:        _asm jc error
        !           876:        _asm xor eax, eax
        !           877:        _asm error:
        !           878:        _asm movzx eax, ax
        !           879:        }
        !           880: 
        !           881: int VXDINLINE R0_FindClose(DWORD handle)
        !           882:        {
        !           883:        _asm
        !           884:                {
        !           885:                mov     eax, R0_FINDCLOSEFILE
        !           886:                mov ebx, handle
        !           887:                }
        !           888:        VxDCall(IFSMgr_Ring0_FileIO)
        !           889:        _asm jc error
        !           890:        _asm xor eax, eax
        !           891:        _asm error:
        !           892:        _asm movzx eax, ax
        !           893:        }
        !           894: 
        !           895: int VXDINLINE R0_GetFileAttributes(const char* pathname, PWORD pattrib)
        !           896:        {
        !           897:        _asm
        !           898:                {
        !           899:                mov     eax, R0_FILEATTRIBUTES or GET_ATTRIBUTES
        !           900:                mov esi, pathname
        !           901:                }
        !           902:        VxDCall(IFSMgr_Ring0_FileIO)
        !           903:        _asm
        !           904:                {
        !           905:                jc      error
        !           906:                mov ebx, pattrib
        !           907:                mov word ptr [ebx], cx
        !           908:                xor eax, eax
        !           909:        error:
        !           910:                movzx eax, ax
        !           911:                }
        !           912:        }
        !           913: 
        !           914: int VXDINLINE R0_SetFileAttributes(const char* pathname, WORD attrib)
        !           915:        {
        !           916:        _asm
        !           917:                {
        !           918:                mov     eax, R0_FILEATTRIBUTES or SET_ATTRIBUTES
        !           919:                mov cx, attrib
        !           920:                mov esi, pathname
        !           921:                }
        !           922:        VxDCall(IFSMgr_Ring0_FileIO)
        !           923:        _asm jc error
        !           924:        _asm xor eax, eax
        !           925:        _asm error:
        !           926:        _asm movzx eax, ax
        !           927:        }
        !           928: 
        !           929: int VXDINLINE R0_RenameFile(const char* oldname, const char* newname)
        !           930:        {
        !           931:        _asm
        !           932:                {
        !           933:                mov     eax, R0_RENAMEFILE
        !           934:                mov esi, oldname
        !           935:                mov edx, newname
        !           936:                }
        !           937:        VxDCall(IFSMgr_Ring0_FileIO)
        !           938:        _asm jc error
        !           939:        _asm xor eax, eax
        !           940:        _asm error:
        !           941:        _asm movzx eax, ax
        !           942:        }
        !           943: 
        !           944: int VXDINLINE R0_DeleteFile(const char* pathname, WORD attrib)
        !           945:        {
        !           946:        _asm
        !           947:                {
        !           948:                mov eax, R0_DELETEFILE
        !           949:                mov cx, attrib
        !           950:                mov esi, pathname
        !           951:                }
        !           952:        VxDCall(IFSMgr_Ring0_FileIO)
        !           953:        _asm jc error
        !           954:        _asm xor eax, eax
        !           955:        _asm error:
        !           956:        _asm movzx eax, ax
        !           957:        }
        !           958: 
        !           959: int VXDINLINE R0_LockFile(DWORD handle, DWORD pid, DWORD dwOffset, DWORD dwLength)
        !           960:        {
        !           961:        _asm
        !           962:                {
        !           963:                mov eax, R0_LOCKFILE or LOCK_REGION
        !           964:                mov ebx, handle
        !           965:                mov ecx, pid
        !           966:                mov edx, dwOffset
        !           967:                mov esi, dwLength
        !           968:                }
        !           969:        VxDCall(IFSMgr_Ring0_FileIO)
        !           970:        _asm jc error
        !           971:        _asm xor eax, eax
        !           972:        _asm error:
        !           973:        _asm movzx eax, ax
        !           974:        }
        !           975: 
        !           976: int VXDINLINE R0_UnlockFile(DWORD handle, DWORD pid, DWORD dwOffset, DWORD dwLength)
        !           977:        {
        !           978:        _asm
        !           979:                {
        !           980:                mov eax, R0_LOCKFILE or UNLOCK_REGION
        !           981:                mov ebx, handle
        !           982:                mov ecx, pid
        !           983:                mov edx, dwOffset
        !           984:                mov esi, dwLength
        !           985:                }
        !           986:        VxDCall(IFSMgr_Ring0_FileIO)
        !           987:        _asm jc error
        !           988:        _asm xor eax, eax
        !           989:        _asm error:
        !           990:        _asm movzx eax, ax
        !           991:        }
        !           992: 
        !           993: int VXDINLINE R0_GetDiskFreeSpace(BYTE drive, PWORD pspc, PWORD pavl, PWORD psecsize, PWORD ptot)
        !           994:        {
        !           995:        _asm
        !           996:                {
        !           997:                mov     eax, R0_GETDISKFREESPACE
        !           998:                mov dl, drive
        !           999:                }
        !          1000:        VxDCall(IFSMgr_Ring0_FileIO)
        !          1001:        _asm
        !          1002:                {
        !          1003:                jc      error
        !          1004:                mov esi, pspc
        !          1005:                mov word ptr [esi], ax          ; sectors per cluster
        !          1006:                mov esi, pavl
        !          1007:                mov word ptr [esi], bx          ; available clusters
        !          1008:                mov esi, psecsize
        !          1009:                mov word ptr [esi], cx          ; bytes per sector
        !          1010:                mov esi, ptot
        !          1011:                mov word ptr [esi], dx          ; total clusters on disk
        !          1012:                xor eax, eax
        !          1013:        error:
        !          1014:                movzx eax, ax
        !          1015:                }
        !          1016:        }
        !          1017: 
        !          1018: int VXDINLINE R0_ReadAbsoluteDisk(BYTE drive, UINT nsectors, DWORD sector, PBYTE buffer)
        !          1019:        {
        !          1020:        _asm
        !          1021:                {
        !          1022:                mov     al, drive
        !          1023:                mov ah, R0_READABSOLUTEDISK shr 8
        !          1024:                mov ecx, nsectors
        !          1025:                mov edx, sector
        !          1026:                mov esi, buffer
        !          1027:                }
        !          1028:        VxDCall(IFSMgr_Ring0_FileIO)
        !          1029:        _asm jc error
        !          1030:        _asm xor eax, eax
        !          1031:        _asm error:
        !          1032:        _asm movzx eax, ax
        !          1033:        }
        !          1034: 
        !          1035: int VXDINLINE R0_WriteAbsoluteDisk(BYTE drive, UINT nsectors, DWORD sector, const BYTE* buffer)
        !          1036:        {
        !          1037:        _asm
        !          1038:                {
        !          1039:                mov     al, drive
        !          1040:                mov ah, R0_WRITEABSOLUTEDISK shr 8
        !          1041:                mov ecx, nsectors
        !          1042:                mov edx, sector
        !          1043:                mov esi, buffer
        !          1044:                }
        !          1045:        VxDCall(IFSMgr_Ring0_FileIO)
        !          1046:        _asm jc error
        !          1047:        _asm xor eax, eax
        !          1048:        _asm error:
        !          1049:        _asm movzx eax, ax
        !          1050:        }
        !          1051: 
        !          1052: int VXDINLINE IFSMgr_Ring0GetDriveInfo(UINT drive)
        !          1053:        {
        !          1054:        _asm mov edx, drive
        !          1055:        VxDCall(IFSMgr_Ring0_FileIO)
        !          1056:        _asm
        !          1057:                {
        !          1058:                jnc     noerror
        !          1059:                mov eax, -1
        !          1060:        noerror:
        !          1061:                }
        !          1062:        }
        !          1063: 
        !          1064: 
        !          1065: 
        !          1066: 
        !          1067: 
        !          1068: 
        !          1069: int VXDINLINE TimeSliceSleep(UINT time)
        !          1070:        {
        !          1071:        _asm mov eax, time
        !          1072:        VxDCall(Time_Slice_Sleep)
        !          1073:        
        !          1074:        }
        !          1075: 
        !          1076: int VXDINLINE GetVMMReenterCount()
        !          1077: {
        !          1078:     int v;
        !          1079:        _asm pushad
        !          1080:        
        !          1081:        _asm xor ecx,ecx
        !          1082:        VxDCall(Get_VMM_Reenter_Count)
        !          1083:     _asm mov [v],ecx
        !          1084:     _asm popad
        !          1085: 
        !          1086:        return v;
        !          1087:   
        !          1088: }
        !          1089: 
        !          1090: 
        !          1091: int VXDINLINE ReleaseTimeSlice()
        !          1092:        {
        !          1093:        VxDCall(Release_Time_Slice)
        !          1094:        }
        !          1095: 
        !          1096: 
        !          1097: //%%%
        !          1098: //int RestrictedEvent(unsigned int Proc,unsigned int refdata)
        !          1099: //     {
        !          1100: //     _asm
        !          1101: //     {
        !          1102: //
        !          1103: //     mov     eax, 0; 
        !          1104: //     mov     ebx, 0 ;Handle
        !          1105: //     ;;mov     ecx, PEF_ALWAYS_SCHED|PEF_RING0_EVENT; 
        !          1106: //     mov     ecx, PEF_ALWAYS_SCHED|PEF_WAIT_CRIT;
        !          1107: //     mov     edx, [refdata]
        !          1108: //     mov     esi, [Proc]
        !          1109: //     mov     edi, 0
        !          1110: //     VxDCall (Call_Restricted_Event)
        !          1111: //     }
        !          1112: //     return 0; 
        !          1113: //     }
        !          1114: 
        !          1115: 
        !          1116: ShellMessageNCB(int flags,char * message,char *caption)
        !          1117:        {
        !          1118:        int handle;
        !          1119:        handle=Get_Sys_VM_Handle();
        !          1120: 
        !          1121:        _asm
        !          1122:        {
        !          1123:         pushad
        !          1124: 
        !          1125:         mov ebx, [handle]             ; virtual machine handle
        !          1126:         mov eax, [flags]              ; message box flags
        !          1127:         mov ecx, [message]   ; address of message text
        !          1128:         mov edi, [caption]   ; address of caption text
        !          1129:         mov esi, 0  ; address of callback
        !          1130:         mov edx, 0      ; reference data for callback
        !          1131:        }
        !          1132: 
        !          1133:        VxDCall (SHELL_SYSMODAL_Message);
        !          1134:        _asm cli
        !          1135:        _asm popad
        !          1136:        }
        !          1137: 
        !          1138: ShellWinMessage(int flags,char * message,char *caption)
        !          1139:        {
        !          1140: 
        !          1141:        int handle;
        !          1142:        handle=Get_Sys_VM_Handle();
        !          1143: 
        !          1144:        _asm
        !          1145:        {
        !          1146:        pushad
        !          1147: 
        !          1148:        mov ebx, [handle]             ; virtual machine handle
        !          1149:        mov eax, [flags]              ; message box flags
        !          1150:        mov ecx, [message]   ; address of message text
        !          1151:        mov edi, [caption]   ; address of caption text
        !          1152:        mov esi, 0  ; address of callback
        !          1153:        mov edx, 0      ; reference data for callback
        !          1154:        }
        !          1155: 
        !          1156:        VxDCall (SHELL_Message);
        !          1157:        _asm jnc noerror
        !          1158:        ShellMessageNCB(flags,message,caption);
        !          1159: 
        !          1160:        _asm noerror:
        !          1161: 
        !          1162:        _asm cli
        !          1163:        _asm popad
        !          1164:        }
        !          1165: 
        !          1166: 
        !          1167: APPY_HANDLE VXDINLINE
        !          1168: SHELL_CallAtAppyTime(APPY_CALLBACK pfnAppyCallBack, DWORD dwRefData, DWORD flAppy, ...)
        !          1169:        {
        !          1170:     _asm    push    flAppy[4]
        !          1171:     _asm    push    flAppy
        !          1172:     _asm    push    dwRefData
        !          1173:     _asm    push    pfnAppyCallBack
        !          1174:     Touch_Register(eax)
        !          1175:     Touch_Register(ecx)
        !          1176:     Touch_Register(edx)
        !          1177:     VxDCall(_SHELL_CallAtAppyTime);
        !          1178:     _asm    add esp, 4*4
        !          1179:        }
        !          1180: 
        !          1181: 
        !          1182: int VXDINLINE
        !          1183: SHELLexec(int exec)
        !          1184:        {
        !          1185:        _asm    push    exec
        !          1186:        Touch_Register(eax)
        !          1187:        Touch_Register(ecx)
        !          1188:        Touch_Register(edx)
        !          1189:        VxDCall(_SHELL_ShellExecute);
        !          1190:        _asm    add esp, 4
        !          1191:        }
        !          1192:        
        !          1193: int SHELLHookBroadcast(void* haddress,int ref)
        !          1194:        {               
        !          1195:        _asm push ref
        !          1196:        _asm push haddress
        !          1197:        VxDCall (_SHELL_HookSystemBroadcast)
        !          1198:        _asm add esp,8
        !          1199:        }
        !          1200: 
        !          1201: int VXDINLINE WaitShTime(unsigned int time)
        !          1202:        {
        !          1203:        unsigned int timelow;
        !          1204:        unsigned int time2=0;
        !          1205:        _asm pushad
        !          1206: 
        !          1207:        Touch_Register(eax)
        !          1208:        Touch_Register(edx)
        !          1209: 
        !          1210:        VxDCall(VTD_Get_Real_Time)
        !          1211: 
        !          1212:        _asm mov [timelow],eax
        !          1213:        while (time2<time)
        !          1214:        {
        !          1215:        Touch_Register(eax)
        !          1216:        Touch_Register(edx)
        !          1217:        VxDCall(VTD_Get_Real_Time)   
        !          1218:        _asm sub eax,[timelow]
        !          1219:        _asm mov [time2],eax
        !          1220: 
        !          1221:        }
        !          1222: 
        !          1223:        _asm popad
        !          1224: 
        !          1225:        }
        !          1226: 
        !          1227: 
        !          1228: int VXDINLINE AdjustThreadPriority(UINT pb,UINT th)
        !          1229:        {
        !          1230:        _asm mov eax, pb
        !          1231:        _asm mov edi,th
        !          1232:        VxDCall(Adjust_Thread_Exec_Priority)
        !          1233:        
        !          1234:        }
        !          1235: 
        !          1236: 
        !          1237: ppIFSFileHookFunc IFSMgr_InstallFileSystemApiHook(pIFSFileHookFunc fcn)
        !          1238:        {
        !          1239:        ppIFSFileHookFunc p;
        !          1240:        _asm push fcn 
        !          1241:        _asm mov eax,fcn        /*  not sure which! */
        !          1242:        VxDCall(IFSMgr_InstallFileSystemApiHook)
        !          1243:        _asm add esp,4  
        !          1244:        _asm mov [p],eax
        !          1245:        return p;
        !          1246:        }
        !          1247: 
        !          1248: int VXDINLINE NAKED IFSMgr_RemoveFileSystemApiHook(pIFSFileHookFunc fcn)
        !          1249:        {
        !          1250:        VxDJmp(IFSMgr_RemoveFileSystemApiHook)
        !          1251:        }
        !          1252: 
        !          1253: int VXDINLINE NAKED IFSMgr_CDROM_Attach(DWORD drive, struct _VRP** pvrp, int fDoMount)
        !          1254:        {
        !          1255:        VxDJmp(IFSMgr_CDROM_Attach)
        !          1256:        }
        !          1257: 
        !          1258: int VXDINLINE NAKED IFSMgr_CDROM_Detach(DWORD Drive, struct _VRP* vrp)
        !          1259:        {
        !          1260:        VxDJmp(IFSMgr_CDROM_Detach)
        !          1261:        }
        !          1262: 
        !          1263: int VXDINLINE NAKED IFSMgr_FSDUnmountCFSD(DWORD rh)
        !          1264:        {
        !          1265:        VxDJmp(IFSMgr_FSDUnmountCFSD)
        !          1266:        }
        !          1267: 
        !          1268: int VXDINLINE NAKED IFSMgr_MountChildVolume(struct _VRP* vrp, DWORD drive)
        !          1269:        {
        !          1270:        VxDJmp(IFSMgr_MountChildVolume)
        !          1271:        }
        !          1272: 
        !          1273: int VXDINLINE NAKED IFSMgr_UnmountChildVolume(struct _VRP* vrp, DWORD drive)
        !          1274:        {
        !          1275:        VxDJmp(IFSMgr_UnmountChildVolume)
        !          1276:        }
        !          1277: 
        !          1278: int VXDINLINE NAKED IFSMgr_SwapDrives(struct _VRP* vrp, DWORD drive1, DWORD drive2)
        !          1279:        {
        !          1280:        VxDJmp(IFSMgr_SwapDrives)
        !          1281:        }
        !          1282: 
        !          1283: int VXDINLINE NAKED IFSMgr_FSDGetCurrentDrive(pioreq pir)
        !          1284:        {
        !          1285:        VxDJmp(IFSMgr_FSDGetCurrentDrive)
        !          1286:        }
        !          1287: 
        !          1288: int VXDINLINE NAKED _GetMappedErr(UINT Function, UINT ExtErr)
        !          1289:        {
        !          1290:        VxDJmp(_GetMappedErr)
        !          1291:        }
        !          1292: 
        !          1293: int VXDINLINE NAKED IFSMgr_GetLockState(DWORD drive, PDWORD pLockType, PDWORD pLockFlags, PDWORD pLockOwner)
        !          1294:        {
        !          1295:        VxDJmp(IFSMgr_GetLockState)
        !          1296:        }
        !          1297: 
        !          1298: BOOL VXDINLINE Query_PhysLock(DWORD unit)
        !          1299:        {
        !          1300:        _asm mov eax, unit
        !          1301:        VxDCall(Query_PhysLock)
        !          1302:        _asm sbb eax, eax                       ; CF set if process doesn't own volume lock, so return is -1 if unowned, 0 if owned
        !          1303:        }
        !          1304: 
        !          1305: VOID VXDINLINE NAKED IFSMgr_printf(const char* pfstr, ...)
        !          1306:        {
        !          1307:        VxDJmp(IFSMgr_printf)
        !          1308:        }
        !          1309: 
        !          1310: #ifdef DEBUG
        !          1311: #define IFSASSERT(x) if (!(x)) IFSMgr_AssertFailed(#x, __FILE__, __LINE__)
        !          1312: VOID VXDINLINE NAKED IFSMgr_AssertFailed(const char* msg, const char* pfname, DWORD line)
        !          1313:        {
        !          1314:        VxDJmp(IFSMgr_AssertFailed)
        !          1315:        }
        !          1316: VOID VXDINLINE NAKED IFSMgr_LogEntry(const char* name, DWORD info1, DWORD info2, int sdepth, DWORD mask)
        !          1317:        {
        !          1318:        VxDJmp(IFSMgr_LogEntry)
        !          1319:        }
        !          1320: DWORD VXDINLINE NAKED IFSMgr_DebugMenu(PVOID pm)
        !          1321:        {
        !          1322:        VxDJmp(IFSMgr_DebugMenu)
        !          1323:        }
        !          1324: DWORD VXDINLINE NAKED IFSMgr_DebugVars()
        !          1325:        {
        !          1326:        VxDJmp(IFSMgr_DebugVars)
        !          1327:        }
        !          1328: int VXDINLINE NAKED IFSMgr_GetDebugString(const char* prompt, char* buffer, UINT length)
        !          1329:        {
        !          1330:        VxDJmp(IFSMgr_GetDebugString)
        !          1331:        }
        !          1332: int VXDINLINE NAKED IFSMgr_GetDebugHexNum(const char* prompt, PDWORD phexval)
        !          1333:        {
        !          1334:        VxDJmp(IFSMgr_GetDebugHexNum)
        !          1335:        }
        !          1336: DWORD VXDINLINE NAKED IFSMgr_DbgSetFileHandleLimit(DWORD MaxHandles)
        !          1337:        {
        !          1338:        VxDJmp(IFSMgr_DbgSetFileHandleLimit)
        !          1339:        }
        !          1340: #else
        !          1341: #define IFSASSERT(x)
        !          1342: #define IFSMgr_Assert_Failed(a1, a2, a3)
        !          1343: #define IFSMgr_LogEntry(a1, a2, a3, a4, a5)
        !          1344: #define IFSMgr_DebugMenu(a1) NULL
        !          1345: #define IFSMgr_DebugVars() NULL
        !          1346: #define IFSMgr_GetDebugString(a1, a2, a3) 0
        !          1347: #define IFSMgr_GetDebugHexNum(a1, a2) 0
        !          1348: #define IFSMgr_DbgSetFileHandleLimit(a1) a1
        !          1349: #endif
        !          1350: 
        !          1351: #endif /* Not_VxD */
        !          1352: 

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