![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ifsmgr.inc CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / driver vxd|
Return to ifsmgr.inc CVS log | Up to [truecrypt] / truecrypt / driver vxd |
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.