source: trunk/src/kernel32/hmfile.cpp@ 3990

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

mmap + share hack
File size: 38.5 KB
Line 
1/* $Id: hmfile.cpp,v 1.14 2000-08-04 21:12:07 sandervl Exp $ */
2
3/*
4 * File IO win32 apis
5 *
6 * Copyright 1999-2000 Sander van Leeuwen
7 *
8 * Notes: (#define SHARE_WORKAROUND)
9 * - Temporary workaround for differences in share mode between
10 * OS/2 & NT (for opening the same file multiple times):
11 * NT: CreateFile with FILE_SHARE_READ
12 * CreateFile with FILE_SHARE_READ | FILE_SHARE_WRITE
13 * -> 2nd CreateFile overrides share flags of first one
14 * -> CreateFile with GENERIC_WRITE is now allowed
15 * OS2: DosOpen with OPEN_SHARE_DENYWRITE
16 * DosOpen with OPEN_SHARE_DENYNONE
17 * -> sharing violation; can't change share flags while
18 * handle returned by 1st DosOpen isn't closed
19 * --> 'Solution': always open files in FILE_SHARE_DENYNONE mode
20 * (several installation programs depend on this behaviour)
21 *
22 * - Only for CreateFile; might also be necessary for OpenFile, but I haven't
23 * seen any apps that require it (yet).
24 *
25 * Project Odin Software License can be found in LICENSE.TXT
26 *
27 */
28
29/*****************************************************************************
30 * Remark *
31 *****************************************************************************
32 */
33
34//#define DEBUG_LOCAL
35
36#ifdef DEBUG_LOCAL
37# define dprintfl(a) dprintf(a)
38#else
39inline void ignore_dprintf(...){}
40# define dprintfl(a) ignore_dprintf(a)
41#endif
42
43/*****************************************************************************
44 * Includes *
45 *****************************************************************************/
46
47#include <os2win.h>
48#include <string.h>
49#include "HandleManager.h"
50#include "HMFile.h"
51#include "mmap.h"
52#include "oslibdos.h"
53
54#define DBG_LOCALLOG DBG_hmfile
55#include "dbglocal.h"
56
57//SvL: Share violation workaround for CreateFile
58#define SHARE_WORKAROUND
59
60/*****************************************************************************
61 * Name : DWORD HMDeviceFileClass::CreateFile
62 * Purpose : this is called from the handle manager if a CreateFile() is
63 * performed on a handle
64 * Parameters: LPCSTR lpFileName name of the file / device
65 * PHMHANDLEDATA pHMHandleData data of the NEW handle
66 * PVOID lpSecurityAttributes ignored
67 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
68 * Variables :
69 * Result :
70 * Remark :
71 * Status : NO_ERROR - API succeeded
72 * other - what is to be set in SetLastError
73 *
74 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
75 *****************************************************************************/
76
77DWORD HMDeviceFileClass::CreateFile (LPCSTR lpFileName,
78 PHMHANDLEDATA pHMHandleData,
79 PVOID lpSecurityAttributes,
80 PHMHANDLEDATA pHMHandleDataTemplate)
81{
82 HFILE hFile;
83 HFILE hTemplate;
84
85 dprintfl(("KERNEL32: HMDeviceFileClass::CreateFile %s(%s,%08x,%08x,%08x)\n",
86 lpHMDeviceName,
87 lpFileName,
88 pHMHandleData,
89 lpSecurityAttributes,
90 pHMHandleDataTemplate));
91
92 if(strncmp(lpFileName, // "support" for local unc names
93 "\\\\.\\",
94 4) == 0)
95 {
96 // check the named pipes
97 if (strnicmp("\\\\.\\PIPE",lpFileName,8)==0)
98 lpFileName+=3;
99 else
100 lpFileName+=4;
101 }
102
103
104 // create from template
105 if (pHMHandleDataTemplate != NULL)
106 hTemplate = pHMHandleDataTemplate->hHMHandle;
107 else
108 hTemplate = 0;
109
110 //SvL: Open32 doesn't like this flag
111 if(pHMHandleData->dwShare & FILE_SHARE_DELETE) {
112 pHMHandleData->dwShare &= ~FILE_SHARE_DELETE;
113 }
114#ifdef SHARE_WORKAROUND
115 pHMHandleData->dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
116#endif
117 hFile = OSLibDosCreateFile((LPSTR)lpFileName,
118 pHMHandleData->dwAccess,
119 pHMHandleData->dwShare,
120 (LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
121 pHMHandleData->dwCreation,
122 pHMHandleData->dwFlags,
123 hTemplate);
124 if (hFile != INVALID_HANDLE_ERROR)
125 {
126 pHMHandleData->dwUserData = (DWORD) new HMFileInfo((LPSTR)lpFileName, lpSecurityAttributes);
127 pHMHandleData->hHMHandle = hFile;
128 return (NO_ERROR);
129 }
130 else {
131 dprintf(("CreateFile failed; error %d", GetLastError()));
132 return(GetLastError());
133 }
134}
135
136/*****************************************************************************
137 * Name : DWORD HMDeviceFileClass::OpenFile
138 * Purpose : this is called from the handle manager if a OpenFile() is
139 * performed on a handle
140 * Parameters: LPCSTR lpFileName name of the file / device
141 * PHMHANDLEDATA pHMHandleData data of the NEW handle
142 * PVOID lpSecurityAttributes ignored
143 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
144 * Variables :
145 * Result :
146 * Remark : TODO: Check if this implementation is complete and 100% correct
147 * Status : NO_ERROR - API succeeded
148 * other - what is to be set in SetLastError
149 *
150 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
151 *****************************************************************************/
152
153DWORD HMDeviceFileClass::OpenFile (LPCSTR lpszFileName,
154 PHMHANDLEDATA pHMHandleData,
155 OFSTRUCT *pOFStruct,
156 UINT fuMode)
157{
158 HFILE hFile;
159 FILETIME filetime;
160 WORD filedatetime[2];
161 char filepath[260];
162 LPSTR lpFileName = (LPSTR)lpszFileName;
163
164 SetLastError(ERROR_SUCCESS);
165
166 dprintf(("KERNEL32: HMDeviceFileClass::OpenFile %s(%s,%08x,%08x,%08x)",
167 lpHMDeviceName,
168 lpFileName,
169 pHMHandleData,
170 pOFStruct,
171 fuMode));
172
173 //Re-open using name in OFSTRUCT
174 if(fuMode & OF_REOPEN)
175 lpFileName = (LPSTR)pOFStruct->szPathName;
176 else memset(pOFStruct, 0, sizeof(OFSTRUCT));
177
178 if(strcmp(lpFileName, // "support" for local unc names
179 "\\\\.\\") == 0)
180 {
181 lpFileName+=4;
182 }
183 else
184 if(!strchr(lpFileName, ':') && !strchr(lpFileName, '\\'))
185 {
186 //filename only; search for file in following order
187 //1: dir from which the app loaded
188 //2: current dir
189 //3: windows system dir
190 //4: windows dir
191 //5: dirs in path path environment variable
192 //SearchPath does exactly that
193 LPSTR filenameinpath;
194
195 if(SearchPathA(NULL, lpFileName, NULL, sizeof(filepath), filepath, &filenameinpath) == 0
196 && !(fuMode & OF_CREATE) )
197 {
198 pOFStruct->nErrCode = ERROR_FILE_NOT_FOUND;
199 SetLastError(ERROR_FILE_NOT_FOUND);
200 return HFILE_ERROR;
201 }
202 lpFileName = filepath;
203 }
204 // filling OFSTRUCT
205 pOFStruct->cBytes = sizeof(OFSTRUCT);
206 pOFStruct->nErrCode = 0;
207 strncpy((char *)pOFStruct->szPathName, lpFileName, OFS_MAXPATHNAME);
208 pOFStruct->szPathName[OFS_MAXPATHNAME-1] = 0;
209
210 hFile = OSLibDosOpenFile((LPSTR)lpFileName, fuMode);
211
212 if(hFile != INVALID_HANDLE_ERROR)
213 {
214 //Needed for GetFileTime
215 pHMHandleData->hHMHandle = hFile;
216 GetFileTime(pHMHandleData,
217 NULL,
218 NULL,
219 &filetime );
220
221 FileTimeToDosDateTime(&filetime,
222 &filedatetime[0],
223 &filedatetime[1] );
224 memcpy(pOFStruct->reserved, filedatetime, sizeof(pOFStruct->reserved));
225
226 if(fuMode & OF_DELETE)
227 {
228 OSLibDosClose(hFile);
229 OSLibDosDelete((LPSTR)lpFileName);
230 }
231 else
232 if(fuMode & OF_EXIST)
233 {
234 OSLibDosClose(hFile);
235 hFile = HFILE_ERROR;
236 }
237 if(fuMode & OF_PARSE)
238 {
239 CHAR drive[4];
240
241 drive[0] = pOFStruct->szPathName[0];
242 drive[1] = pOFStruct->szPathName[1];
243 drive[2] = pOFStruct->szPathName[2];
244 drive[3] = 0;
245
246 pOFStruct->fFixedDisk = (GetDriveTypeA(drive) != DRIVE_REMOVABLE);
247
248 OSLibDosClose(hFile);
249 hFile = HFILE_ERROR;
250 }
251
252 if((fuMode & OF_VERIFY))
253 {
254 if(memcmp(pOFStruct->reserved, filedatetime, sizeof(pOFStruct->reserved)))
255 {
256 OSLibDosClose(hFile);
257 SetLastError(ERROR_FILE_NOT_FOUND);
258 }
259 hFile = HFILE_ERROR;
260 }
261
262 pOFStruct->nErrCode = GetLastError();
263 pHMHandleData->hHMHandle = hFile;
264
265 if(hFile != HFILE_ERROR) {
266 pHMHandleData->dwUserData = (DWORD) new HMFileInfo((LPSTR)lpFileName, NULL);
267 }
268 return (NO_ERROR);
269 }
270 else {
271 DWORD rc = GetLastError();
272
273 if(fuMode & OF_EXIST)
274 {
275 if(rc == ERROR_OPEN_FAILED) {
276 SetLastError(ERROR_FILE_NOT_FOUND);
277 }
278 }
279 //todo: OF_PROMPT handling (pop up message box)
280 }
281 // error branch
282 pOFStruct->nErrCode = GetLastError();
283 dprintf(("KERNEL32: HMDeviceFileClass::OpenFile Error %08xh\n",
284 pOFStruct->nErrCode));
285
286 // return != NO_ERROR => error code
287 return(hFile);
288}
289
290/*****************************************************************************
291 * Name : HMDeviceFileClass::DuplicateHandle
292 * Purpose :
293 * Parameters:
294 * various parameters as required
295 * Variables :
296 * Result :
297 * Remark : DUPLICATE_CLOSE_SOURCE flag handled in HMDuplicateHandle
298 *
299 * Status : partially implemented
300 *
301 * Author : SvL
302 *****************************************************************************/
303BOOL HMDeviceFileClass::DuplicateHandle(PHMHANDLEDATA pHMHandleData,
304 HANDLE srcprocess,
305 PHMHANDLEDATA pHMSrcHandle,
306 HANDLE destprocess,
307 PHANDLE desthandle,
308 DWORD fdwAccess,
309 BOOL fInherit,
310 DWORD fdwOptions,
311 DWORD fdwOdinOptions)
312{
313 HMFileInfo *srcfileinfo = (HMFileInfo *)pHMSrcHandle->dwUserData;
314 DWORD rc;
315
316 dprintf(("KERNEL32:HMDeviceFileClass::DuplicateHandle (%08x,%08x,%08x,%08x,%08x)",
317 pHMHandleData,
318 srcprocess,
319 pHMSrcHandle->hHMHandle,
320 destprocess,
321 desthandle));
322
323 //TODO: Inheritance of file handles won't work!
324
325 if(destprocess != srcprocess)
326 {
327 //TODO:!!!!
328 dprintf(("ERROR: DuplicateHandle; different processes not yet supported!!"));
329 return FALSE;
330 }
331
332 if(srcfileinfo)
333 {
334 //SvL: Special duplicatehandle option used by memory mapped class to duplicate
335 // file handle
336 // Can't use DosDupHandle or else there can be a sharing violation
337 // when an app tries to access the same file again
338 if(fdwOdinOptions)
339 {
340 if(CreateFile(srcfileinfo->lpszFileName, pHMHandleData,
341 srcfileinfo->lpSecurityAttributes, NULL) == NO_ERROR)
342 {
343 return TRUE;
344 }
345 dprintf(("ERROR: DuplicateHandle; CreateFile %s failed!",
346 srcfileinfo->lpszFileName));
347 return FALSE;
348 }
349
350 if(!(fdwOptions & DUPLICATE_SAME_ACCESS) && fdwAccess != pHMSrcHandle->dwAccess) {
351 dprintf(("WARNING: DuplicateHandle; app wants different access permission; Not supported!! (%x, %x)", fdwAccess, pHMSrcHandle->dwAccess));
352 }
353
354 rc = OSLibDosDupHandle(pHMSrcHandle->hHMHandle,
355 desthandle);
356 if (rc)
357 {
358 dprintf(("ERROR: DulicateHandle: OSLibDosDupHandle(%s) failed = %u\n",
359 rc,
360 srcfileinfo->lpszFileName));
361 SetLastError(rc);
362 return FALSE; // ERROR
363 }
364 else {
365 pHMHandleData->hHMHandle = *desthandle;
366 return TRUE; // OK
367 }
368 }
369 else
370 {
371 SetLastError(ERROR_INVALID_PARAMETER);
372 return FALSE;
373 }
374}
375
376/*****************************************************************************
377 * Name : DWORD HMDeviceFileClass::CloseHandle
378 * Purpose : close the handle
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 HMDeviceFileClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
389{
390 HMFileInfo *fileInfo = (HMFileInfo *)pHMHandleData->dwUserData;
391 BOOL bRC;
392
393 dprintfl(("KERNEL32: HMDeviceFileClass::CloseHandle(%08x)\n",
394 pHMHandleData->hHMHandle));
395
396 bRC = OSLibDosClose(pHMHandleData->hHMHandle);
397
398 if(pHMHandleData->dwFlags & FILE_FLAG_DELETE_ON_CLOSE) {
399 //TODO: should only do this after all handles have been closed
400 if(fileInfo) {
401 DeleteFileA(fileInfo->lpszFileName);
402 }
403 }
404 if(fileInfo) {
405 delete fileInfo;
406 }
407 dprintf(("KERNEL32: HMDeviceFileClass::CloseHandle returned %08xh\n",
408 bRC));
409
410 return (DWORD)bRC;
411}
412
413
414/*****************************************************************************
415 * Name : BOOL HMDeviceFileClass::ReadFile
416 * Purpose : read data from handle / device
417 * Parameters: PHMHANDLEDATA pHMHandleData,
418 * LPCVOID lpBuffer,
419 * DWORD nNumberOfBytesToRead,
420 * LPDWORD lpNumberOfBytesRead,
421 * LPOVERLAPPED lpOverlapped
422 * Variables :
423 * Result : Boolean
424 * Remark :
425 * Status :
426 *
427 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
428 *****************************************************************************/
429
430BOOL HMDeviceFileClass::ReadFile(PHMHANDLEDATA pHMHandleData,
431 LPCVOID lpBuffer,
432 DWORD nNumberOfBytesToRead,
433 LPDWORD lpNumberOfBytesRead,
434 LPOVERLAPPED lpOverlapped)
435{
436 LPVOID lpRealBuf;
437 Win32MemMap *map;
438 DWORD offset, bytesread;
439 BOOL bRC;
440
441 dprintfl(("KERNEL32: HMDeviceFileClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
442 lpHMDeviceName,
443 pHMHandleData,
444 lpBuffer,
445 nNumberOfBytesToRead,
446 lpNumberOfBytesRead,
447 lpOverlapped));
448
449 //SvL: It's legal for this pointer to be NULL
450 if(lpNumberOfBytesRead)
451 *lpNumberOfBytesRead = 0;
452 else
453 lpNumberOfBytesRead = &bytesread;
454
455 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
456 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
457 SetLastError(ERROR_INVALID_PARAMETER);
458 return FALSE;
459 }
460 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
461 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
462 }
463
464 //SvL: DosRead doesn't like writing to memory addresses returned by
465 // DosAliasMem -> search for original memory mapped pointer and use
466 // that one + commit pages if not already present
467 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_WRITE);
468 if(map) {
469 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
470 DWORD nrpages = nNumberOfBytesToRead/4096;
471 if(offset & 0xfff)
472 nrpages++;
473 if(nNumberOfBytesToRead & 0xfff)
474 nrpages++;
475
476 map->commitPage(offset & ~0xfff, TRUE, nrpages);
477 }
478 else lpRealBuf = (LPVOID)lpBuffer;
479
480 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
481 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
482 }
483// else {
484 bRC = OSLibDosRead(pHMHandleData->hHMHandle,
485 (PVOID)lpRealBuf,
486 nNumberOfBytesToRead,
487 lpNumberOfBytesRead);
488// }
489
490 if(bRC == 0) {
491 dprintf(("KERNEL32: HMDeviceFileClass::ReadFile returned %08xh %x\n",
492 bRC, GetLastError()));
493 dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
494 }
495
496 return bRC;
497}
498
499/*****************************************************************************
500 * Name : BOOL ReadFileEx
501 * Purpose : The ReadFileEx function reads data from a file asynchronously.
502 * It is designed solely for asynchronous operation, unlike the
503 * ReadFile function, which is designed for both synchronous and
504 * asynchronous operation. ReadFileEx lets an application perform
505 * other processing during a file read operation.
506 * The ReadFileEx function reports its completion status asynchronously,
507 * calling a specified completion routine when reading is completed
508 * and the calling thread is in an alertable wait state.
509 * Parameters: HANDLE hFile handle of file to read
510 * LPVOID lpBuffer address of buffer
511 * DWORD nNumberOfBytesToRead number of bytes to read
512 * LPOVERLAPPED lpOverlapped address of offset
513 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
514 * Variables :
515 * Result : TRUE / FALSE
516 * Remark :
517 * Status : UNTESTED STUB
518 *
519 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
520 *****************************************************************************/
521BOOL HMDeviceFileClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
522 LPVOID lpBuffer,
523 DWORD nNumberOfBytesToRead,
524 LPOVERLAPPED lpOverlapped,
525 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
526{
527 dprintf(("ERROR: ReadFileEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
528 pHMHandleData->hHMHandle,
529 lpBuffer,
530 nNumberOfBytesToRead,
531 lpOverlapped,
532 lpCompletionRoutine));
533 return FALSE;
534}
535
536
537/*****************************************************************************
538 * Name : BOOL HMDeviceFileClass::WriteFile
539 * Purpose : write data to handle / device
540 * Parameters: PHMHANDLEDATA pHMHandleData,
541 * LPCVOID lpBuffer,
542 * DWORD nNumberOfBytesToWrite,
543 * LPDWORD lpNumberOfBytesWritten,
544 * LPOVERLAPPED lpOverlapped
545 * Variables :
546 * Result : Boolean
547 * Remark :
548 * Status :
549 *
550 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
551 *****************************************************************************/
552
553BOOL HMDeviceFileClass::WriteFile(PHMHANDLEDATA pHMHandleData,
554 LPCVOID lpBuffer,
555 DWORD nNumberOfBytesToWrite,
556 LPDWORD lpNumberOfBytesWritten,
557 LPOVERLAPPED lpOverlapped)
558{
559 LPVOID lpRealBuf;
560 Win32MemMap *map;
561 DWORD offset, byteswritten;
562 BOOL bRC;
563
564 dprintfl(("KERNEL32: HMDeviceFileClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
565 lpHMDeviceName,
566 pHMHandleData,
567 lpBuffer,
568 nNumberOfBytesToWrite,
569 lpNumberOfBytesWritten,
570 lpOverlapped));
571
572 //SvL: It's legal for this pointer to be NULL
573 if(lpNumberOfBytesWritten)
574 *lpNumberOfBytesWritten = 0;
575 else
576 lpNumberOfBytesWritten = &byteswritten;
577
578 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
579 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
580 SetLastError(ERROR_INVALID_PARAMETER);
581 return FALSE;
582 }
583 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
584 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
585 }
586
587 //SvL: DosWrite doesn't like reading from memory addresses returned by
588 // DosAliasMem -> search for original memory mapped pointer and use
589 // that one + commit pages if not already present
590 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_READ);
591 if(map) {
592 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
593 DWORD nrpages = nNumberOfBytesToWrite/4096;
594 if(offset & 0xfff)
595 nrpages++;
596 if(nNumberOfBytesToWrite & 0xfff)
597 nrpages++;
598
599 map->commitPage(offset & ~0xfff, TRUE, nrpages);
600 }
601 else lpRealBuf = (LPVOID)lpBuffer;
602
603 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
604 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
605 }
606// else {
607 bRC = OSLibDosWrite(pHMHandleData->hHMHandle,
608 (PVOID)lpRealBuf,
609 nNumberOfBytesToWrite,
610 lpNumberOfBytesWritten);
611// }
612
613 dprintf(("KERNEL32: HMDeviceFileClass::WriteFile returned %08xh\n",
614 bRC));
615
616 return bRC;
617}
618
619/*****************************************************************************
620 * Name : BOOL WriteFileEx
621 * Purpose : The WriteFileEx function writes data to a file. It is designed
622 * solely for asynchronous operation, unlike WriteFile, which is
623 * designed for both synchronous and asynchronous operation.
624 * WriteFileEx reports its completion status asynchronously,
625 * calling a specified completion routine when writing is completed
626 * and the calling thread is in an alertable wait state.
627 * Parameters: HANDLE hFile handle of file to write
628 * LPVOID lpBuffer address of buffer
629 * DWORD nNumberOfBytesToRead number of bytes to write
630 * LPOVERLAPPED lpOverlapped address of offset
631 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
632 * Variables :
633 * Result : TRUE / FALSE
634 * Remark :
635 * Status : UNTESTED STUB
636 *
637 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
638 *****************************************************************************/
639
640BOOL HMDeviceFileClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
641 LPVOID lpBuffer,
642 DWORD nNumberOfBytesToWrite,
643 LPOVERLAPPED lpOverlapped,
644 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
645{
646 dprintf(("ERROR: WriteFileEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
647 pHMHandleData->hHMHandle,
648 lpBuffer,
649 nNumberOfBytesToWrite,
650 lpOverlapped,
651 lpCompletionRoutine));
652 return FALSE;
653}
654
655/*****************************************************************************
656 * Name : DWORD HMDeviceFileClass::GetFileType
657 * Purpose : determine the handle type
658 * Parameters: PHMHANDLEDATA pHMHandleData
659 * Variables :
660 * Result : API returncode
661 * Remark :
662 * Status :
663 *
664 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
665 *****************************************************************************/
666
667DWORD HMDeviceFileClass::GetFileType(PHMHANDLEDATA pHMHandleData)
668{
669 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileType %s(%08x)\n",
670 lpHMDeviceName,
671 pHMHandleData));
672
673 return FILE_TYPE_DISK;
674}
675
676
677/*****************************************************************************
678 * Name : DWORD HMDeviceFileClass::GetFileInformationByHandle
679 * Purpose : determine the handle type
680 * Parameters: PHMHANDLEDATA pHMHandleData
681 * BY_HANDLE_FILE_INFORMATION* pHFI
682 * Variables :
683 * Result : API returncode
684 * Remark :
685 * Status :
686 *
687 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
688 *****************************************************************************/
689
690DWORD HMDeviceFileClass::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
691 BY_HANDLE_FILE_INFORMATION* pHFI)
692{
693 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileInformationByHandle %s(%08xh,%08xh)\n",
694 lpHMDeviceName,
695 pHMHandleData,
696 pHFI));
697
698 if(OSLibDosGetFileInformationByHandle(pHMHandleData->hHMHandle,
699 pHFI))
700 {
701 return TRUE;
702 }
703 dprintf(("GetFileInformationByHandle failed with error %d", GetLastError()));
704 return FALSE;
705
706}
707
708
709/*****************************************************************************
710 * Name : BOOL HMDeviceFileClass::SetEndOfFile
711 * Purpose : set end of file marker
712 * Parameters: PHMHANDLEDATA pHMHandleData
713 * Variables :
714 * Result : API returncode
715 * Remark :
716 * Status :
717 *
718 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
719 *****************************************************************************/
720
721BOOL HMDeviceFileClass::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
722{
723 dprintfl(("KERNEL32: HMDeviceFileClass::SetEndOfFile %s(%08xh)\n",
724 lpHMDeviceName,
725 pHMHandleData));
726
727 if(OSLibDosSetEndOfFile(pHMHandleData->hHMHandle)) {
728 return TRUE;
729 }
730 dprintf(("SetEndOfFile failed with error %d", GetLastError()));
731 return FALSE;
732}
733
734
735/*****************************************************************************
736 * Name : BOOL HMDeviceFileClass::SetFileTime
737 * Purpose : set file time
738 * Parameters: PHMHANDLEDATA pHMHandleData
739 * PFILETIME pFT1
740 * PFILETIME pFT2
741 * PFILETIME pFT3
742 * Variables :
743 * Result : API returncode
744 * Remark :
745 * Status :
746 *
747 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
748 *****************************************************************************/
749
750BOOL HMDeviceFileClass::SetFileTime(PHMHANDLEDATA pHMHandleData,
751 LPFILETIME pFT1,
752 LPFILETIME pFT2,
753 LPFILETIME pFT3)
754{
755 WORD creationdate = 0, creationtime = 0;
756 WORD lastaccessdate = 0, lastaccesstime = 0;
757 WORD lastwritedate = 0, lastwritetime = 0;
758
759 dprintfl(("KERNEL32: HMDeviceFileClass::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
760 lpHMDeviceName,
761 pHMHandleData,
762 pFT1,
763 pFT2,
764 pFT3));
765
766 if(pFT1 && pFT1->dwLowDateTime && pFT1->dwHighDateTime) {
767 FileTimeToDosDateTime(pFT1, &creationdate, &creationtime);
768 }
769
770 if(pFT2 && pFT2->dwLowDateTime && pFT2->dwHighDateTime) {
771 FileTimeToDosDateTime(pFT2, &lastaccessdate, &lastaccesstime);
772 }
773
774 if(pFT3 && pFT3->dwLowDateTime && pFT3->dwHighDateTime) {
775 FileTimeToDosDateTime(pFT3, &lastwritedate, &lastwritetime);
776 }
777
778 if(OSLibDosSetFileTime(pHMHandleData->hHMHandle,
779 creationdate, creationtime,
780 lastaccessdate, lastaccesstime,
781 lastwritedate, lastwritetime))
782 {
783 return TRUE;
784 }
785 dprintf(("SetFileTime failed with error %d", GetLastError()));
786 return FALSE;
787}
788
789/*****************************************************************************
790 * Name : BOOL HMDeviceFileClass::GetFileTime
791 * Purpose : get file time
792 * Parameters: PHMHANDLEDATA pHMHandleData
793 * PFILETIME pFT1
794 * PFILETIME pFT2
795 * PFILETIME pFT3
796 * Variables :
797 * Result : API returncode
798 * Remark :
799 * Status :
800 *
801 * Author : SvL
802 *****************************************************************************/
803
804BOOL HMDeviceFileClass::GetFileTime(PHMHANDLEDATA pHMHandleData,
805 LPFILETIME pFT1,
806 LPFILETIME pFT2,
807 LPFILETIME pFT3)
808{
809 WORD creationdate, creationtime;
810 WORD lastaccessdate, lastaccesstime;
811 WORD lastwritedate, lastwritetime;
812 BOOL rc;
813
814 if(!pFT1 && !pFT2 && !pFT3) {//TODO: does NT do this?
815 SetLastError(ERROR_INVALID_PARAMETER);
816 return FALSE;
817 }
818
819 if(OSLibDosGetFileTime(pHMHandleData->hHMHandle,
820 &creationdate, &creationtime,
821 &lastaccessdate, &lastaccesstime,
822 &lastwritedate, &lastwritetime))
823 {
824 if(pFT1) {
825 DosDateTimeToFileTime(creationdate, creationtime, pFT1);
826 }
827 if(pFT2) {
828 DosDateTimeToFileTime(lastaccessdate, lastaccesstime, pFT2);
829 }
830 if(pFT3) {
831 DosDateTimeToFileTime(lastwritedate, lastwritetime, pFT3);
832 }
833 return TRUE;
834 }
835 dprintf(("GetFileTime failed with error %d", GetLastError()));
836 return FALSE;
837}
838
839/*****************************************************************************
840 * Name : DWORD HMDeviceFileClass::GetFileSize
841 * Purpose : set file time
842 * Parameters: PHMHANDLEDATA pHMHandleData
843 * PDWORD pSize
844 * Variables :
845 * Result : API returncode
846 * Remark :
847 * Status :
848 *
849 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
850 *****************************************************************************/
851
852DWORD HMDeviceFileClass::GetFileSize(PHMHANDLEDATA pHMHandleData,
853 PDWORD lpdwFileSizeHigh)
854{
855 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileSize %s(%08xh,%08xh)\n",
856 lpHMDeviceName,
857 pHMHandleData,
858 lpdwFileSizeHigh));
859
860 if(lpdwFileSizeHigh)
861 *lpdwFileSizeHigh = 0;
862
863 return OSLibDosGetFileSize(pHMHandleData->hHMHandle, lpdwFileSizeHigh);
864}
865
866/*****************************************************************************
867 * Name : DWORD HMDeviceFileClass::SetFilePointer
868 * Purpose : set file pointer
869 * Parameters: PHMHANDLEDATA pHMHandleData
870 * LONG lDistanceToMove
871 * PLONG lpDistanceToMoveHigh
872 * DWORD dwMoveMethod
873 * Variables :
874 * Result : API returncode
875 * Remark :
876 * Status :
877 *
878 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
879 *****************************************************************************/
880
881DWORD HMDeviceFileClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
882 LONG lDistanceToMove,
883 PLONG lpDistanceToMoveHigh,
884 DWORD dwMoveMethod)
885{
886 DWORD ret;
887
888 dprintfl(("KERNEL32: HMDeviceFileClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
889 lpHMDeviceName,
890 pHMHandleData,
891 lDistanceToMove,
892 lpDistanceToMoveHigh,
893 dwMoveMethod));
894
895 ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
896 lDistanceToMove,
897 (DWORD *)lpDistanceToMoveHigh,
898 dwMoveMethod);
899
900 if(ret == -1) {
901 dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
902 }
903 return ret;
904}
905
906
907/*****************************************************************************
908 * Name : DWORD HMDeviceFileClass::LockFile
909 * Purpose : file locking
910 * Parameters: PHMHANDLEDATA pHMHandleData
911 * DWORD arg2
912 * DWORD arg3
913 * DWORD arg4
914 * DWORD arg5
915 * Variables :
916 * Result : API returncode
917 * Remark :
918 * Status :
919 *
920 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
921 *****************************************************************************/
922
923BOOL HMDeviceFileClass::LockFile(PHMHANDLEDATA pHMHandleData,
924 DWORD dwFileOffsetLow,
925 DWORD dwFileOffsetHigh,
926 DWORD cbLockLow,
927 DWORD cbLockHigh)
928{
929 dprintfl(("KERNEL32: HMDeviceFileClass::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
930 lpHMDeviceName,
931 pHMHandleData,
932 dwFileOffsetLow,
933 dwFileOffsetHigh,
934 cbLockLow,
935 cbLockHigh));
936
937 return OSLibDosLockFile(pHMHandleData->hHMHandle,
938 LOCKFILE_EXCLUSIVE_LOCK,
939 dwFileOffsetLow,
940 dwFileOffsetHigh,
941 cbLockLow,
942 cbLockHigh,
943 NULL);
944}
945
946/*****************************************************************************
947 * Name : DWORD HMDeviceFileClass::LockFileEx
948 * Purpose : file locking
949 * Parameters: PHMHANDLEDATA pHMHandleData
950 * DWORD dwFlags
951 * DWORD dwReserved
952 * DWORD nNumberOfBytesToLockLow
953 * DWORD nNumberOfBytesToLockHigh
954 * LPOVERLAPPED lpOverlapped
955 * Variables :
956 * Result : API returncode
957 * Remark :
958 * Status :
959 *
960 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
961 *****************************************************************************/
962
963BOOL HMDeviceFileClass::LockFileEx(PHMHANDLEDATA pHMHandleData,
964 DWORD dwFlags,
965 DWORD dwReserved,
966 DWORD nNumberOfBytesToLockLow,
967 DWORD nNumberOfBytesToLockHigh,
968 LPOVERLAPPED lpOverlapped)
969{
970
971 dprintfl(("KERNEL32: HMDeviceFileClass::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented!",
972 lpHMDeviceName,
973 pHMHandleData,
974 dwFlags,
975 dwReserved,
976 nNumberOfBytesToLockLow,
977 nNumberOfBytesToLockHigh,
978 lpOverlapped));
979
980
981 return(OSLibDosLockFile(pHMHandleData->hHMHandle,
982 dwFlags,
983 lpOverlapped->Offset,
984 lpOverlapped->OffsetHigh,
985 nNumberOfBytesToLockLow,
986 nNumberOfBytesToLockHigh,
987 lpOverlapped));
988}
989
990
991/*****************************************************************************
992 * Name : DWORD HMDeviceFileClass::UnlockFile
993 * Purpose : file locking
994 * Parameters: PHMHANDLEDATA pHMHandleData
995 * DWORD arg2
996 * DWORD arg3
997 * DWORD arg4
998 * DWORD arg5
999 * Variables :
1000 * Result : API returncode
1001 * Remark :
1002 * Status :
1003 *
1004 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1005 *****************************************************************************/
1006
1007BOOL HMDeviceFileClass::UnlockFile(PHMHANDLEDATA pHMHandleData,
1008 DWORD dwFileOffsetLow,
1009 DWORD dwFileOffsetHigh,
1010 DWORD cbLockLow,
1011 DWORD cbLockHigh)
1012{
1013 dprintfl(("KERNEL32: HMDeviceFileClass::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1014 lpHMDeviceName,
1015 pHMHandleData,
1016 dwFileOffsetLow,
1017 dwFileOffsetHigh,
1018 cbLockLow,
1019 cbLockHigh));
1020
1021 return OSLibDosUnlockFile(pHMHandleData->hHMHandle,
1022 dwFileOffsetLow,
1023 dwFileOffsetHigh,
1024 cbLockLow,
1025 cbLockHigh,
1026 NULL);
1027}
1028
1029
1030
1031/*****************************************************************************
1032 * Name : DWORD HMDeviceFileClass::UnlockFileEx
1033 * Purpose : file locking
1034 * Parameters: PHMHANDLEDATA pHMHandleData
1035 * DWORD dwFlags
1036 * DWORD dwReserved
1037 * DWORD nNumberOfBytesToLockLow
1038 * DWORD nNumberOfBytesToLockHigh
1039 * LPOVERLAPPED lpOverlapped
1040 * Variables :
1041 * Result : API returncode
1042 * Remark :
1043 * Status :
1044 *
1045 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1046 *****************************************************************************/
1047
1048BOOL HMDeviceFileClass::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
1049 DWORD dwReserved,
1050 DWORD nNumberOfBytesToLockLow,
1051 DWORD nNumberOfBytesToLockHigh,
1052 LPOVERLAPPED lpOverlapped)
1053{
1054
1055 dprintfl(("KERNEL32: HMDeviceFileClass::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented!",
1056 lpHMDeviceName,
1057 pHMHandleData,
1058 dwReserved,
1059 nNumberOfBytesToLockLow,
1060 nNumberOfBytesToLockHigh,
1061 lpOverlapped));
1062
1063
1064 return(OSLibDosUnlockFile(pHMHandleData->hHMHandle,
1065 lpOverlapped->Offset,
1066 lpOverlapped->OffsetHigh,
1067 nNumberOfBytesToLockLow,
1068 nNumberOfBytesToLockHigh,
1069 lpOverlapped));
1070}
1071
1072
1073/*****************************************************************************
1074 * Name : DWORD HMDeviceFileClass::FlushFileBuffers
1075 * Purpose : flush the buffers of a file
1076 * Parameters: PHMHANDLEDATA pHMHandleData
1077 * Variables :
1078 * Result : API returncode
1079 * Remark :
1080 * Status :
1081 *
1082 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1083 *****************************************************************************/
1084
1085BOOL HMDeviceFileClass::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
1086{
1087 dprintfl(("KERNEL32: HMDeviceFileClass:FlushFileBuffers(%08xh)\n",
1088 pHMHandleData->hHMHandle));
1089
1090 return(OSLibDosFlushFileBuffers(pHMHandleData->hHMHandle));
1091}
1092
1093
1094/*****************************************************************************
1095 * Name : DWORD HMDeviceFileClass::GetOverlappedResult
1096 * Purpose : asynchronus I/O
1097 * Parameters: PHMHANDLEDATA pHMHandleData
1098 * LPOVERLAPPED arg2
1099 * LPDWORD arg3
1100 * BOOL arg4
1101 * Variables :
1102 * Result : API returncode
1103 * Remark :
1104 * Status :
1105 *
1106 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1107 *****************************************************************************/
1108
1109BOOL HMDeviceFileClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
1110 LPOVERLAPPED arg2,
1111 LPDWORD arg3,
1112 BOOL arg4)
1113{
1114 dprintfl(("KERNEL32-WARNING: HMDeviceFileClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) STUB!!",
1115 pHMHandleData->hHMHandle,
1116 arg2,
1117 arg3,
1118 arg4));
1119
1120 return FALSE;
1121// return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
1122// arg2,
1123// arg3,
1124// arg4));
1125}
1126//******************************************************************************
1127//******************************************************************************
1128HMFileInfo::HMFileInfo(LPSTR lpszFileName, PVOID lpSecurityAttributes)
1129{
1130 this->lpszFileName = (LPSTR)malloc(strlen(lpszFileName)+1);
1131 if(!this->lpszFileName) {
1132 DebugInt3();
1133 }
1134 strcpy(this->lpszFileName, lpszFileName);
1135 this->lpSecurityAttributes = lpSecurityAttributes;
1136}
1137//******************************************************************************
1138//******************************************************************************
1139HMFileInfo::~HMFileInfo()
1140{
1141 if(lpszFileName) {
1142 free(lpszFileName);
1143 lpszFileName = NULL;
1144 }
1145}
1146//******************************************************************************
1147//******************************************************************************
Note: See TracBrowser for help on using the repository browser.