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

Last change on this file since 3501 was 3501, checked in by sandervl, 25 years ago

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