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

Last change on this file since 3204 was 2973, checked in by sandervl, 26 years ago

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