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

Last change on this file since 9653 was 9653, checked in by sandervl, 23 years ago

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