source: trunk/src/kernel32/hmopen32.cpp@ 1716

Last change on this file since 1716 was 1713, checked in by sandervl, 26 years ago

device driver handlemanager class added
File size: 28.9 KB
Line 
1/* $Id: hmopen32.cpp,v 1.11 1999-11-12 14:57:15 sandervl Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Win32 Unified Handle Manager for OS/2
6 */
7
8
9/*****************************************************************************
10 * Remark *
11 *****************************************************************************
12 */
13
14//#define DEBUG_LOCAL
15
16#ifdef DEBUG_LOCAL
17# define dprintfl(a) dprintf(a)
18#else
19inline void ignore_dprintf(...){}
20# define dprintfl(a) ignore_dprintf(a)
21#endif
22
23/*****************************************************************************
24 * Includes *
25 *****************************************************************************/
26
27#include <os2win.h>
28#include <string.h>
29#include "HandleManager.h"
30#include "HMOpen32.h"
31
32
33/*****************************************************************************
34 * Defines *
35 *****************************************************************************/
36
37
38/*****************************************************************************
39 * Structures *
40 *****************************************************************************/
41
42/*****************************************************************************
43 * Name : HMDeviceOpen32Class::_DeviceRequest
44 * Purpose : entry method for special request functions
45 * Parameters: ULONG ulRequestCode
46 * various parameters as required
47 * Variables :
48 * Result :
49 * Remark : the standard behaviour is to return an error code for non-
50 * existant request codes
51 * Status :
52 *
53 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
54 *****************************************************************************/
55DWORD HMDeviceOpen32Class::_DeviceRequest (PHMHANDLEDATA pHMHandleData,
56 ULONG ulRequestCode,
57 ULONG arg1,
58 ULONG arg2,
59 ULONG arg3,
60 ULONG arg4)
61{
62 dprintfl(("KERNEL32: HandleManager::Open32::_DeviceRequest %s(%08x,%08x) - stub?\n",
63 lpHMDeviceName,
64 pHMHandleData,
65 ulRequestCode));
66
67 return(ERROR_INVALID_FUNCTION);
68}
69
70
71/*****************************************************************************
72 * Name : HMDeviceHandler::DuplicateHandle
73 * Purpose : dummy version
74 * Parameters:
75 * various parameters as required
76 * Variables :
77 * Result :
78 * Remark : the standard behaviour is to return an error code for non-
79 * existant request codes
80 * Status :
81 *
82 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
83 *****************************************************************************/
84BOOL HMDeviceOpen32Class::DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,
85 PHMHANDLEDATA pHMSrcHandle,
86 HANDLE destprocess,
87 PHANDLE desthandle,
88 DWORD fdwAccess,
89 BOOL fInherit,
90 DWORD fdwOptions)
91{
92 BOOL rc;
93
94 dprintf(("KERNEL32:HandleManager::Open32::DuplicateHandle %s(%08x,%08x,%08x,%08x,%08x)\n",
95 lpHMDeviceName,
96 pHMHandleData,
97 srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle));
98
99#if 1
100 rc = O32_DuplicateHandle(srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle, fdwAccess, fInherit, fdwOptions);
101
102 if(rc == TRUE) {
103 pHMHandleData->hHMHandle = *desthandle;
104 return (NO_ERROR);
105 }
106 else return(O32_GetLastError());
107#else
108 rc = OSLibDosDupHandle(pHMSrcHandle->hHMHandle, desthandle);
109 if(rc == NO_ERROR)
110 {
111 pHMHandleData->hHMHandle = *desthandle;
112 return (NO_ERROR);
113 }
114 else
115 {
116 dprintfl(("KERNEL32: HandleManager::Open32::DuplicateHandle Error %d\n",rc));
117 O32_SetLastError(rc);
118 return(rc);
119 }
120#endif
121}
122
123/*****************************************************************************
124 * Name : DWORD HMDeviceOpen32Class::CreateFile
125 * Purpose : this is called from the handle manager if a CreateFile() is
126 * performed on a handle
127 * Parameters: LPCSTR lpFileName name of the file / device
128 * PHMHANDLEDATA pHMHandleData data of the NEW handle
129 * PVOID lpSecurityAttributes ignored
130 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
131 * Variables :
132 * Result :
133 * Remark :
134 * Status : NO_ERROR - API succeeded
135 * other - what is to be set in SetLastError
136 *
137 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
138 *****************************************************************************/
139
140DWORD HMDeviceOpen32Class::CreateFile (LPCSTR lpFileName,
141 PHMHANDLEDATA pHMHandleData,
142 PVOID lpSecurityAttributes,
143 PHMHANDLEDATA pHMHandleDataTemplate)
144{
145 HFILE hFile;
146 HFILE hTemplate;
147
148 dprintfl(("KERNEL32: HandleManager::Open32::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
149 lpHMDeviceName,
150 lpFileName,
151 pHMHandleData,
152 lpSecurityAttributes,
153 pHMHandleDataTemplate));
154
155 if (strncmp(lpFileName, // "support" for local unc names
156 "\\\\.\\",
157 4) == 0)
158 {
159 lpFileName+=4;
160 }
161
162 // create from template
163 if (pHMHandleDataTemplate != NULL)
164 hTemplate = pHMHandleDataTemplate->hHMHandle;
165 else
166 hTemplate = 0;
167
168#if 1
169 hFile = O32_CreateFile(lpFileName,
170 pHMHandleData->dwAccess,
171 pHMHandleData->dwShare,
172 //(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
173 NULL,
174 pHMHandleData->dwCreation,
175 pHMHandleData->dwFlags,
176 hTemplate);
177 if (hFile != INVALID_HANDLE_ERROR)
178 {
179 pHMHandleData->hHMHandle = hFile;
180 return (NO_ERROR);
181 }
182 else
183 return(O32_GetLastError());
184#else
185
186 rc = OSLibDosCreate((char *)lpFileName,
187 pHMHandleData->dwAccess,
188 pHMHandleData->dwShare,
189 //(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
190 NULL,
191 pHMHandleData->dwCreation,
192 pHMHandleData->dwFlags,
193 hTemplate, &hFile);
194 if(rc)
195 {
196 dprintfl(("KERNEL32: HandleManager::Open32::CreateFile Error %d\n",rc));
197 O32_SetLastError(rc);
198 return(rc);
199 }
200 else
201 {
202 pHMHandleData->hHMHandle = hFile;
203 return (NO_ERROR);
204 }
205#endif
206}
207
208
209/*****************************************************************************
210 * Name : DWORD HMDeviceOpen32Class::CloseHandle
211 * Purpose : close the handle
212 * Parameters: PHMHANDLEDATA pHMHandleData
213 * Variables :
214 * Result : API returncode
215 * Remark :
216 * Status :
217 *
218 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
219 *****************************************************************************/
220
221DWORD HMDeviceOpen32Class::CloseHandle(PHMHANDLEDATA pHMHandleData)
222{
223 BOOL bRC;
224
225 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle(%08x)\n",
226 pHMHandleData->hHMHandle));
227
228#if 1
229 bRC = O32_CloseHandle(pHMHandleData->hHMHandle);
230
231 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle returned %08xh\n",
232 bRC));
233
234 return (DWORD)bRC;
235#else
236 bRC = OSLibDosClose(pHMHandleData->hHMHandle);
237 if(bRC)
238 {
239 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle Error %d\n",bRC));
240 O32_SetLastError(bRC);
241 return TRUE; // MUTEX Problem
242 return FALSE;
243 }
244 else
245 {
246 return TRUE;
247 }
248#endif
249}
250
251
252/*****************************************************************************
253 * Name : DWORD HMDeviceOpen32Class::ReadFile
254 * Purpose : read data from handle / device
255 * Parameters: PHMHANDLEDATA pHMHandleData,
256 * LPCVOID lpBuffer,
257 * DWORD nNumberOfBytesToRead,
258 * LPDWORD lpNumberOfBytesRead,
259 * LPOVERLAPPED lpOverlapped
260 * Variables :
261 * Result : API returncode
262 * Remark :
263 * Status :
264 *
265 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
266 *****************************************************************************/
267
268DWORD HMDeviceOpen32Class::ReadFile(PHMHANDLEDATA pHMHandleData,
269 LPCVOID lpBuffer,
270 DWORD nNumberOfBytesToRead,
271 LPDWORD lpNumberOfBytesRead,
272 LPOVERLAPPED lpOverlapped)
273{
274 BOOL bRC;
275
276 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
277 lpHMDeviceName,
278 pHMHandleData,
279 lpBuffer,
280 nNumberOfBytesToRead,
281 lpNumberOfBytesRead,
282 lpOverlapped));
283
284#if 1
285 bRC = O32_ReadFile(pHMHandleData->hHMHandle,
286 (PVOID)lpBuffer,
287 nNumberOfBytesToRead,
288 lpNumberOfBytesRead,
289 lpOverlapped);
290
291 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh\n",
292 bRC));
293
294 return (DWORD)bRC;
295#else
296 rc = OSLibDosRead(pHMHandleData->hHMHandle,
297 (PVOID) lpBuffer,
298 nNumberOfBytesToRead,
299 lpNumberOfBytesRead);
300 if(rc)
301 {
302 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile Error %d\n",rc));
303 O32_SetLastError(rc);
304 return FALSE;
305 }
306 else
307 {
308 return TRUE;
309 }
310#endif
311}
312
313
314/*****************************************************************************
315 * Name : DWORD HMDeviceOpen32Class::WriteFile
316 * Purpose : write data to handle / device
317 * Parameters: PHMHANDLEDATA pHMHandleData,
318 * LPCVOID lpBuffer,
319 * DWORD nNumberOfBytesToWrite,
320 * LPDWORD lpNumberOfBytesWritten,
321 * LPOVERLAPPED lpOverlapped
322 * Variables :
323 * Result : API returncode
324 * Remark :
325 * Status :
326 *
327 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
328 *****************************************************************************/
329
330DWORD HMDeviceOpen32Class::WriteFile(PHMHANDLEDATA pHMHandleData,
331 LPCVOID lpBuffer,
332 DWORD nNumberOfBytesToWrite,
333 LPDWORD lpNumberOfBytesWritten,
334 LPOVERLAPPED lpOverlapped)
335{
336 BOOL bRC;
337
338 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
339 lpHMDeviceName,
340 pHMHandleData,
341 lpBuffer,
342 nNumberOfBytesToWrite,
343 lpNumberOfBytesWritten,
344 lpOverlapped));
345
346#if 1
347 bRC = O32_WriteFile(pHMHandleData->hHMHandle,
348 lpBuffer,
349 nNumberOfBytesToWrite,
350 lpNumberOfBytesWritten,
351 lpOverlapped);
352
353 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile returned %08xh\n",
354 bRC));
355
356 return (DWORD)bRC;
357#else
358 rc = OSLibDosWrite(pHMHandleData->hHMHandle,
359 (PVOID) lpBuffer,
360 nNumberOfBytesToWrite,
361 lpNumberOfBytesWritten);
362 if(rc)
363 {
364 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile Error %d\n",rc));
365 O32_SetLastError(rc);
366 return FALSE;
367 }
368 else
369 {
370 return TRUE;
371 }
372#endif
373}
374
375
376/*****************************************************************************
377 * Name : DWORD HMDeviceOpen32Class::GetFileType
378 * Purpose : determine the handle type
379 * Parameters: PHMHANDLEDATA pHMHandleData
380 * Variables :
381 * Result : API returncode
382 * Remark :
383 * Status :
384 *
385 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
386 *****************************************************************************/
387
388DWORD HMDeviceOpen32Class::GetFileType(PHMHANDLEDATA pHMHandleData)
389{
390 dprintfl(("KERNEL32: HandleManager::Open32::GetFileType %s(%08x)\n",
391 lpHMDeviceName,
392 pHMHandleData));
393
394#if 1
395 return O32_GetFileType(pHMHandleData->hHMHandle);
396#else
397 // TODO: FILE_TYPE_DISK
398 return FILE_TYPE_CHAR;
399#endif
400}
401
402
403/*****************************************************************************
404 * Name : DWORD HMDeviceOpen32Class::GetFileInformationByHandle
405 * Purpose : determine the handle type
406 * Parameters: PHMHANDLEDATA pHMHandleData
407 * BY_HANDLE_FILE_INFORMATION* pHFI
408 * Variables :
409 * Result : API returncode
410 * Remark :
411 * Status :
412 *
413 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
414 *****************************************************************************/
415
416DWORD HMDeviceOpen32Class::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
417 BY_HANDLE_FILE_INFORMATION* pHFI)
418{
419 dprintfl(("KERNEL32: HandleManager::Open32::GetFileInformationByHandle %s(%08xh,%08xh)\n",
420 lpHMDeviceName,
421 pHMHandleData,
422 pHFI));
423
424 return O32_GetFileInformationByHandle(pHMHandleData->hHMHandle,
425 pHFI);
426}
427
428
429/*****************************************************************************
430 * Name : BOOL HMDeviceOpen32Class::SetEndOfFile
431 * Purpose : set end of file marker
432 * Parameters: PHMHANDLEDATA pHMHandleData
433 * Variables :
434 * Result : API returncode
435 * Remark :
436 * Status :
437 *
438 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
439 *****************************************************************************/
440
441BOOL HMDeviceOpen32Class::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
442{
443 dprintfl(("KERNEL32: HandleManager::Open32::SetEndOfFile %s(%08xh)\n",
444 lpHMDeviceName,
445 pHMHandleData));
446
447 return O32_SetEndOfFile(pHMHandleData->hHMHandle);
448}
449
450
451/*****************************************************************************
452 * Name : BOOL HMDeviceOpen32Class::SetFileTime
453 * Purpose : set file time
454 * Parameters: PHMHANDLEDATA pHMHandleData
455 * PFILETIME pFT1
456 * PFILETIME pFT2
457 * PFILETIME pFT3
458 * Variables :
459 * Result : API returncode
460 * Remark :
461 * Status :
462 *
463 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
464 *****************************************************************************/
465
466BOOL HMDeviceOpen32Class::SetFileTime(PHMHANDLEDATA pHMHandleData,
467 LPFILETIME pFT1,
468 LPFILETIME pFT2,
469 LPFILETIME pFT3)
470{
471 dprintfl(("KERNEL32: HandleManager::Open32::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
472 lpHMDeviceName,
473 pHMHandleData,
474 pFT1,
475 pFT2,
476 pFT3));
477
478 return O32_SetFileTime(pHMHandleData->hHMHandle,
479 pFT1,
480 pFT2,
481 pFT3);
482}
483
484
485/*****************************************************************************
486 * Name : DWORD HMDeviceOpen32Class::GetFileSize
487 * Purpose : set file time
488 * Parameters: PHMHANDLEDATA pHMHandleData
489 * PDWORD pSize
490 * Variables :
491 * Result : API returncode
492 * Remark :
493 * Status :
494 *
495 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
496 *****************************************************************************/
497
498DWORD HMDeviceOpen32Class::GetFileSize(PHMHANDLEDATA pHMHandleData,
499 PDWORD pSize)
500{
501 dprintfl(("KERNEL32: HandleManager::Open32::GetFileSize %s(%08xh,%08xh)\n",
502 lpHMDeviceName,
503 pHMHandleData,
504 pSize));
505
506#if 1
507 return O32_GetFileSize(pHMHandleData->hHMHandle,
508 pSize);
509#else
510 size = OSLibDosGetFileSize(pHMHandleData->hHMHandle);
511 if(pSize)
512 *pSize = size;
513 return size;
514#endif
515}
516
517
518/*****************************************************************************
519 * Name : DWORD HMDeviceOpen32Class::SetFilePointer
520 * Purpose : set file pointer
521 * Parameters: PHMHANDLEDATA pHMHandleData
522 * LONG lDistanceToMove
523 * PLONG lpDistanceToMoveHigh
524 * DWORD dwMoveMethod
525 * Variables :
526 * Result : API returncode
527 * Remark :
528 * Status :
529 *
530 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
531 *****************************************************************************/
532
533DWORD HMDeviceOpen32Class::SetFilePointer(PHMHANDLEDATA pHMHandleData,
534 LONG lDistanceToMove,
535 PLONG lpDistanceToMoveHigh,
536 DWORD dwMoveMethod)
537{
538 dprintfl(("KERNEL32: HandleManager::Open32::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
539 lpHMDeviceName,
540 pHMHandleData,
541 lDistanceToMove,
542 lpDistanceToMoveHigh,
543 dwMoveMethod));
544
545#if 1
546 return O32_SetFilePointer(pHMHandleData->hHMHandle,
547 lDistanceToMove,
548 lpDistanceToMoveHigh,
549 dwMoveMethod);
550#else
551
552 if(lpDistanceToMoveHigh)
553 *lpDistanceToMoveHigh = 0;
554 pos = OSLibDosSetFilePtr2(pHMHandleData->hHMHandle, lDistanceToMove, dwMoveMethod);
555 return pos;
556#endif
557}
558
559
560/*****************************************************************************
561 * Name : DWORD HMDeviceOpen32Class::LockFile
562 * Purpose : file locking
563 * Parameters: PHMHANDLEDATA pHMHandleData
564 * DWORD arg2
565 * DWORD arg3
566 * DWORD arg4
567 * DWORD arg5
568 * Variables :
569 * Result : API returncode
570 * Remark :
571 * Status :
572 *
573 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
574 *****************************************************************************/
575
576DWORD HMDeviceOpen32Class::LockFile(PHMHANDLEDATA pHMHandleData,
577 DWORD arg2,
578 DWORD arg3,
579 DWORD arg4,
580 DWORD arg5)
581{
582 dprintfl(("KERNEL32: HandleManager::Open32::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
583 lpHMDeviceName,
584 pHMHandleData,
585 arg2,
586 arg3,
587 arg4,
588 arg5));
589
590 return O32_LockFile(pHMHandleData->hHMHandle,
591 arg2,
592 arg3,
593 arg4,
594 arg5);
595}
596
597
598
599/*****************************************************************************
600 * Name : DWORD HMDeviceOpen32Class::LockFileEx
601 * Purpose : file locking
602 * Parameters: PHMHANDLEDATA pHMHandleData
603 * DWORD dwFlags
604 * DWORD dwReserved
605 * DWORD nNumberOfBytesToLockLow
606 * DWORD nNumberOfBytesToLockHigh
607 * LPOVERLAPPED lpOverlapped
608 * Variables :
609 * Result : API returncode
610 * Remark :
611 * Status :
612 *
613 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
614 *****************************************************************************/
615
616DWORD HMDeviceOpen32Class::LockFileEx(PHMHANDLEDATA pHMHandleData,
617 DWORD dwFlags,
618 DWORD dwReserved,
619 DWORD nNumberOfBytesToLockLow,
620 DWORD nNumberOfBytesToLockHigh,
621 LPOVERLAPPED lpOverlapped)
622{
623
624 dprintfl(("KERNEL32: HandleManager::Open32::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
625 lpHMDeviceName,
626 pHMHandleData,
627 dwFlags,
628 dwReserved,
629 nNumberOfBytesToLockLow,
630 nNumberOfBytesToLockHigh,
631 lpOverlapped));
632
633
634 return(O32_LockFile(pHMHandleData->hHMHandle,
635 lpOverlapped->Offset,
636 lpOverlapped->OffsetHigh,
637 nNumberOfBytesToLockLow,
638 nNumberOfBytesToLockHigh));
639}
640
641
642/*****************************************************************************
643 * Name : DWORD HMDeviceOpen32Class::OpenFile
644 * Purpose : this is called from the handle manager if a OpenFile() is
645 * performed on a handle
646 * Parameters: LPCSTR lpFileName name of the file / device
647 * PHMHANDLEDATA pHMHandleData data of the NEW handle
648 * PVOID lpSecurityAttributes ignored
649 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
650 * Variables :
651 * Result :
652 * Remark :
653 * Status : NO_ERROR - API succeeded
654 * other - what is to be set in SetLastError
655 *
656 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
657 *****************************************************************************/
658
659DWORD HMDeviceOpen32Class::OpenFile (LPCSTR lpFileName,
660 PHMHANDLEDATA pHMHandleData,
661 OFSTRUCT *pOFStruct,
662 UINT arg3)
663{
664 HFILE hFile;
665 FILETIME filetime;
666 WORD filedatetime[2];
667
668 dprintfl(("KERNEL32: HandleManager::Open32::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
669 lpHMDeviceName,
670 lpFileName,
671 pHMHandleData,
672 pOFStruct,
673 arg3));
674
675 if (strcmp(lpFileName, // "support" for local unc names
676 "\\\\.\\") == 0)
677 lpFileName+=4;
678
679 // filling OFSTRUCT
680 pOFStruct->cBytes = sizeof(OFSTRUCT);
681 pOFStruct->nErrCode = 0;
682
683 hFile = O32_OpenFile(lpFileName,
684 pOFStruct,
685 arg3);
686 if (hFile != INVALID_HANDLE_ERROR)
687 {
688 pHMHandleData->hHMHandle = hFile;
689
690 GetFileTime(hFile,
691 NULL,
692 NULL,
693 &filetime );
694 FileTimeToDosDateTime(&filetime,
695 &filedatetime[0],
696 &filedatetime[1] );
697 memcpy(pOFStruct->reserved,
698 filedatetime,
699 sizeof(pOFStruct->reserved) );
700
701 return (NO_ERROR);
702 }
703
704 // error branch
705 pOFStruct->nErrCode = O32_GetLastError();
706 dprintf(("KERNEL32: HandleManager::Open32::OpenFile Error %08xh\n",
707 pOFStruct->nErrCode));
708
709 // return != NO_ERROR => error code
710 return(hFile);
711}
712
713
714/*****************************************************************************
715 * Name : DWORD HMDeviceOpen32Class::UnlockFile
716 * Purpose : file locking
717 * Parameters: PHMHANDLEDATA pHMHandleData
718 * DWORD arg2
719 * DWORD arg3
720 * DWORD arg4
721 * DWORD arg5
722 * Variables :
723 * Result : API returncode
724 * Remark :
725 * Status :
726 *
727 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
728 *****************************************************************************/
729
730DWORD HMDeviceOpen32Class::UnlockFile(PHMHANDLEDATA pHMHandleData,
731 DWORD arg2,
732 DWORD arg3,
733 DWORD arg4,
734 DWORD arg5)
735{
736 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
737 lpHMDeviceName,
738 pHMHandleData,
739 arg2,
740 arg3,
741 arg4,
742 arg5));
743
744 return O32_UnlockFile(pHMHandleData->hHMHandle,
745 arg2,
746 arg3,
747 arg4,
748 arg5);
749}
750
751
752
753/*****************************************************************************
754 * Name : DWORD HMDeviceOpen32Class::UnlockFileEx
755 * Purpose : file locking
756 * Parameters: PHMHANDLEDATA pHMHandleData
757 * DWORD dwFlags
758 * DWORD dwReserved
759 * DWORD nNumberOfBytesToLockLow
760 * DWORD nNumberOfBytesToLockHigh
761 * LPOVERLAPPED lpOverlapped
762 * Variables :
763 * Result : API returncode
764 * Remark :
765 * Status :
766 *
767 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
768 *****************************************************************************/
769
770DWORD HMDeviceOpen32Class::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
771 DWORD dwFlags,
772 DWORD dwReserved,
773 DWORD nNumberOfBytesToLockLow,
774 DWORD nNumberOfBytesToLockHigh,
775 LPOVERLAPPED lpOverlapped)
776{
777
778 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
779 lpHMDeviceName,
780 pHMHandleData,
781 dwFlags,
782 dwReserved,
783 nNumberOfBytesToLockLow,
784 nNumberOfBytesToLockHigh,
785 lpOverlapped));
786
787 return(O32_UnlockFile(pHMHandleData->hHMHandle,
788 lpOverlapped->Offset,
789 lpOverlapped->OffsetHigh,
790 nNumberOfBytesToLockLow,
791 nNumberOfBytesToLockHigh));
792}
793
794
795/*****************************************************************************
796 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObject
797 * Purpose : object synchronization
798 * Parameters: PHMHANDLEDATA pHMHandleData
799 * DWORD dwTimeout
800 * Variables :
801 * Result : API returncode
802 * Remark :
803 * Status :
804 *
805 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
806 *****************************************************************************/
807
808DWORD HMDeviceOpen32Class::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
809 DWORD dwTimeout)
810{
811 dprintfl(("KERNEL32: HandleManager::Open32::WaitForSingleObject(%08xh,%08h)\n",
812 pHMHandleData->hHMHandle,
813 dwTimeout));
814
815 return (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
816 dwTimeout));
817}
818
819
820/*****************************************************************************
821 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObjectEx
822 * Purpose : object synchronization
823 * Parameters: PHMHANDLEDATA pHMHandleData
824 * DWORD dwTimeout
825 * BOOL fAlertable
826 * Variables :
827 * Result : API returncode
828 * Remark :
829 * Status :
830 *
831 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
832 *****************************************************************************/
833
834DWORD HMDeviceOpen32Class::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
835 DWORD dwTimeout,
836 BOOL fAlertable)
837{
838 dprintfl(("KERNEL32: HandleManager::Open32::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
839 pHMHandleData->hHMHandle,
840 dwTimeout,
841 fAlertable));
842
843 //@@@PH: WARNING mapped to WaitForSingleObject simply. fAlertable missing!
844 return (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
845 dwTimeout));
846}
847
848
849/*****************************************************************************
850 * Name : DWORD HMDeviceOpen32Class::FlushFileBuffers
851 * Purpose : flush the buffers of a file
852 * Parameters: PHMHANDLEDATA pHMHandleData
853 * Variables :
854 * Result : API returncode
855 * Remark :
856 * Status :
857 *
858 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
859 *****************************************************************************/
860
861BOOL HMDeviceOpen32Class::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
862{
863 dprintfl(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
864 pHMHandleData->hHMHandle));
865
866 return(O32_FlushFileBuffers(pHMHandleData->hHMHandle));
867}
868
869
870/*****************************************************************************
871 * Name : DWORD HMDeviceOpen32Class::GetOverlappedResult
872 * Purpose : asynchronus I/O
873 * Parameters: PHMHANDLEDATA pHMHandleData
874 * LPOVERLAPPED arg2
875 * LPDWORD arg3
876 * BOOL arg4
877 * Variables :
878 * Result : API returncode
879 * Remark :
880 * Status :
881 *
882 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
883 *****************************************************************************/
884
885BOOL HMDeviceOpen32Class::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
886 LPOVERLAPPED arg2,
887 LPDWORD arg3,
888 BOOL arg4)
889{
890 dprintfl(("KERNEL32: HandleManager::Open32::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
891 pHMHandleData->hHMHandle,
892 arg2,
893 arg3,
894 arg4));
895
896 return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
897 arg2,
898 arg3,
899 arg4));
900}
901
Note: See TracBrowser for help on using the repository browser.