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

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

DT: GetFileTime & SetFileTime fixes; need to convert between UTC and local file time
File size: 35.2 KB
Line 
1/* $Id: hmfile.cpp,v 1.37 2002-12-19 12:55:27 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 SetLastError(ERROR_SUCCESS);
354 return TRUE;
355 }
356 dprintf(("ERROR: DuplicateHandle; CreateFile %s failed -> trying DosDupHandle instead!",
357 srcfileinfo->lpszFileName));
358 //SvL: IE5 setup opens file with DENYREADWRITE, so CreateFile can't
359 // be used for duplicating the handle; try DosDupHandle instead
360 }
361
362 if(!(fdwOptions & DUPLICATE_SAME_ACCESS) && fdwAccess != pHMSrcHandle->dwAccess) {
363 dprintf(("WARNING: DuplicateHandle; app wants different access permission; Not supported!! (%x, %x)", fdwAccess, pHMSrcHandle->dwAccess));
364 }
365
366 rc = OSLibDosDupHandle(pHMSrcHandle->hHMHandle,
367 desthandle);
368 if (rc)
369 {
370 dprintf(("ERROR: DulicateHandle: OSLibDosDupHandle(%s) failed = %u\n",
371 rc,
372 srcfileinfo->lpszFileName));
373 SetLastError(rc);
374 return FALSE; // ERROR
375 }
376 else {
377 SetLastError(ERROR_SUCCESS);
378 pHMHandleData->hHMHandle = *desthandle;
379 return TRUE; // OK
380 }
381 }
382 else
383 {
384 dprintf(("ERROR: DuplicateHandle; invalid parameter!!"));
385 SetLastError(ERROR_INVALID_PARAMETER);
386 return FALSE;
387 }
388}
389
390/*****************************************************************************
391 * Name : BOOL HMDeviceFileClass::CloseHandle
392 * Purpose : close the handle
393 * Parameters: PHMHANDLEDATA pHMHandleData
394 * Variables :
395 * Result : API returncode
396 * Remark :
397 * Status :
398 *
399 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
400 *****************************************************************************/
401
402BOOL HMDeviceFileClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
403{
404 HMFileInfo *fileInfo = (HMFileInfo *)pHMHandleData->dwUserData;
405 BOOL bRC;
406
407 dprintfl(("KERNEL32: HMDeviceFileClass::CloseHandle(%08x)\n",
408 pHMHandleData->hHMHandle));
409
410 bRC = OSLibDosClose(pHMHandleData->hHMHandle);
411
412 if(pHMHandleData->dwFlags & FILE_FLAG_DELETE_ON_CLOSE) {
413 //TODO: should only do this after all handles have been closed
414 if(fileInfo) {
415 DeleteFileA(fileInfo->lpszFileName);
416 }
417 }
418 if(fileInfo) {
419 delete fileInfo;
420 }
421 dprintf(("KERNEL32: HMDeviceFileClass::CloseHandle returned %08xh\n",
422 bRC));
423
424 return (DWORD)bRC;
425}
426
427
428/*****************************************************************************
429 * Name : BOOL HMDeviceFileClass::ReadFile
430 * Purpose : read data from handle / device
431 * Parameters: PHMHANDLEDATA pHMHandleData,
432 * LPCVOID lpBuffer,
433 * DWORD nNumberOfBytesToRead,
434 * LPDWORD lpNumberOfBytesRead,
435 * LPOVERLAPPED lpOverlapped
436 * Variables :
437 * Result : Boolean
438 * Remark :
439 * Status :
440 *
441 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
442 *****************************************************************************/
443
444BOOL HMDeviceFileClass::ReadFile(PHMHANDLEDATA pHMHandleData,
445 LPCVOID lpBuffer,
446 DWORD nNumberOfBytesToRead,
447 LPDWORD lpNumberOfBytesRead,
448 LPOVERLAPPED lpOverlapped,
449 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
450{
451 LPVOID lpRealBuf;
452 Win32MemMap *map;
453 DWORD offset, bytesread;
454 BOOL bRC;
455
456 dprintfl(("KERNEL32: HMDeviceFileClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
457 lpHMDeviceName,
458 pHMHandleData,
459 lpBuffer,
460 nNumberOfBytesToRead,
461 lpNumberOfBytesRead,
462 lpOverlapped));
463
464 //SvL: It's legal for this pointer to be NULL
465 if(lpNumberOfBytesRead)
466 *lpNumberOfBytesRead = 0;
467 else
468 lpNumberOfBytesRead = &bytesread;
469
470 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
471 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
472 SetLastError(ERROR_INVALID_PARAMETER);
473 return FALSE;
474 }
475 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
476 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
477 }
478 if(lpCompletionRoutine) {
479 dprintf(("!WARNING!: lpCompletionRoutine not supported -> fall back to sync IO"));
480 }
481
482 //SvL: DosRead doesn't like writing to memory addresses returned by
483 // DosAliasMem -> search for original memory mapped pointer and use
484 // that one + commit pages if not already present
485 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_WRITE);
486 if(map) {
487 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
488 DWORD nrpages = nNumberOfBytesToRead/4096;
489 if(offset & 0xfff)
490 nrpages++;
491 if(nNumberOfBytesToRead & 0xfff)
492 nrpages++;
493
494 map->commitPage(offset & ~0xfff, TRUE, nrpages);
495 }
496 else lpRealBuf = (LPVOID)lpBuffer;
497
498 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
499 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
500 }
501// else {
502 bRC = OSLibDosRead(pHMHandleData->hHMHandle,
503 (PVOID)lpRealBuf,
504 nNumberOfBytesToRead,
505 lpNumberOfBytesRead);
506// }
507
508 if(bRC == 0) {
509 dprintf(("KERNEL32: HMDeviceFileClass::ReadFile returned %08xh %x\n",
510 bRC, GetLastError()));
511 dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
512 }
513
514 return bRC;
515}
516
517
518/*****************************************************************************
519 * Name : BOOL HMDeviceFileClass::WriteFile
520 * Purpose : write data to handle / device
521 * Parameters: PHMHANDLEDATA pHMHandleData,
522 * LPCVOID lpBuffer,
523 * DWORD nNumberOfBytesToWrite,
524 * LPDWORD lpNumberOfBytesWritten,
525 * LPOVERLAPPED lpOverlapped
526 * Variables :
527 * Result : Boolean
528 * Remark :
529 * Status :
530 *
531 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
532 *****************************************************************************/
533
534BOOL HMDeviceFileClass::WriteFile(PHMHANDLEDATA pHMHandleData,
535 LPCVOID lpBuffer,
536 DWORD nNumberOfBytesToWrite,
537 LPDWORD lpNumberOfBytesWritten,
538 LPOVERLAPPED lpOverlapped,
539 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
540{
541 LPVOID lpRealBuf;
542 Win32MemMap *map;
543 DWORD offset, byteswritten;
544 BOOL bRC;
545
546 dprintfl(("KERNEL32: HMDeviceFileClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
547 lpHMDeviceName,
548 pHMHandleData,
549 lpBuffer,
550 nNumberOfBytesToWrite,
551 lpNumberOfBytesWritten,
552 lpOverlapped));
553
554 //SvL: It's legal for this pointer to be NULL
555 if(lpNumberOfBytesWritten)
556 *lpNumberOfBytesWritten = 0;
557 else
558 lpNumberOfBytesWritten = &byteswritten;
559
560 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
561 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
562 SetLastError(ERROR_INVALID_PARAMETER);
563 return FALSE;
564 }
565 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
566 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
567 }
568
569 //SvL: DosWrite doesn't like reading from memory addresses returned by
570 // DosAliasMem -> search for original memory mapped pointer and use
571 // that one + commit pages if not already present
572 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_READ);
573 if(map) {
574 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
575 DWORD nrpages = nNumberOfBytesToWrite/4096;
576 if(offset & 0xfff)
577 nrpages++;
578 if(nNumberOfBytesToWrite & 0xfff)
579 nrpages++;
580
581 map->commitPage(offset & ~0xfff, TRUE, nrpages);
582 }
583 else lpRealBuf = (LPVOID)lpBuffer;
584
585 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
586 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
587 }
588// else {
589 bRC = OSLibDosWrite(pHMHandleData->hHMHandle,
590 (PVOID)lpRealBuf,
591 nNumberOfBytesToWrite,
592 lpNumberOfBytesWritten);
593// }
594
595 dprintf(("KERNEL32: HMDeviceFileClass::WriteFile returned %08xh\n",
596 bRC));
597
598 return bRC;
599}
600
601
602/*****************************************************************************
603 * Name : DWORD HMDeviceFileClass::GetFileType
604 * Purpose : determine the handle type
605 * Parameters: PHMHANDLEDATA pHMHandleData
606 * Variables :
607 * Result : API returncode
608 * Remark :
609 * Status :
610 *
611 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
612 *****************************************************************************/
613
614DWORD HMDeviceFileClass::GetFileType(PHMHANDLEDATA pHMHandleData)
615{
616 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileType %s(%08x)\n",
617 lpHMDeviceName,
618 pHMHandleData));
619
620 return FILE_TYPE_DISK;
621}
622
623
624/*****************************************************************************
625 * Name : DWORD HMDeviceFileClass::GetFileInformationByHandle
626 * Purpose : determine the handle type
627 * Parameters: PHMHANDLEDATA pHMHandleData
628 * BY_HANDLE_FILE_INFORMATION* pHFI
629 * Variables :
630 * Result : API returncode
631 * Remark :
632 * Status :
633 *
634 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
635 *****************************************************************************/
636
637DWORD HMDeviceFileClass::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
638 BY_HANDLE_FILE_INFORMATION* pHFI)
639{
640 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileInformationByHandle %s(%08xh,%08xh)\n",
641 lpHMDeviceName, pHMHandleData, pHFI));
642
643 if(OSLibDosGetFileInformationByHandle(pHMHandleData->hHMHandle,
644 pHFI))
645 {
646 return TRUE;
647 }
648 dprintf(("GetFileInformationByHandle failed with error %d", GetLastError()));
649 return FALSE;
650
651}
652
653
654/*****************************************************************************
655 * Name : BOOL HMDeviceFileClass::SetEndOfFile
656 * Purpose : set end of file marker
657 * Parameters: PHMHANDLEDATA pHMHandleData
658 * Variables :
659 * Result : API returncode
660 * Remark :
661 * Status :
662 *
663 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
664 *****************************************************************************/
665
666BOOL HMDeviceFileClass::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
667{
668 dprintfl(("KERNEL32: HMDeviceFileClass::SetEndOfFile %s(%08xh)\n",
669 lpHMDeviceName,
670 pHMHandleData));
671
672 if(OSLibDosSetEndOfFile(pHMHandleData->hHMHandle)) {
673 return TRUE;
674 }
675 dprintf(("SetEndOfFile failed with error %d", GetLastError()));
676 return FALSE;
677}
678
679//******************************************************************************
680/*****************************************************************************
681 * Name : BOOL HMDeviceFileClass::SetFileTime
682 * Purpose : set file time
683 * Parameters: PHMHANDLEDATA pHMHandleData
684 * PFILETIME pFT1
685 * PFILETIME pFT2
686 * PFILETIME pFT3
687 * Variables :
688 * Result : API returncode
689 * Remark :
690 * Status :
691 *
692 * Author : Patrick Haller [Wed, 1999/06/17 20:44] mod. DT
693 *****************************************************************************/
694
695BOOL HMDeviceFileClass::SetFileTime(PHMHANDLEDATA pHMHandleData,
696 LPFILETIME pFT1,
697 LPFILETIME pFT2,
698 LPFILETIME pFT3)
699{
700 dprintfl(("KERNEL32: HMDeviceFileClass::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
701 lpHMDeviceName, pHMHandleData, pFT1, pFT2, pFT3));
702
703 if(OSLibDosSetFileTime(pHMHandleData->hHMHandle, pFT1, pFT2, pFT3)) return TRUE;
704
705 dprintf(("SetFileTime failed with error %d", GetLastError()));
706 return FALSE;
707}
708
709/*****************************************************************************
710 * Name : BOOL HMDeviceFileClass::GetFileTime
711 * Purpose : get file time
712 * Parameters: PHMHANDLEDATA pHMHandleData
713 * PFILETIME pFT1
714 * PFILETIME pFT2
715 * PFILETIME pFT3
716 * Variables :
717 * Result : API returncode
718 * Remark :
719 * Status :
720 *
721 * Author : SvL mod. DT
722 *****************************************************************************/
723
724BOOL HMDeviceFileClass::GetFileTime(PHMHANDLEDATA pHMHandleData,
725 LPFILETIME pFT1,
726 LPFILETIME pFT2,
727 LPFILETIME pFT3)
728{
729 if(!pFT1 && !pFT2 && !pFT3) {//TODO: does NT do this?
730 dprintf(("ERROR: GetFileTime: invalid parameter!"));
731 SetLastError(ERROR_INVALID_PARAMETER);
732 return FALSE;
733 }
734
735 if(OSLibDosGetFileTime(pHMHandleData->hHMHandle, pFT1, pFT2, pFT3)) return TRUE;
736 dprintf(("GetFileTime failed with error %d", GetLastError()));
737 return FALSE;
738}
739
740/*****************************************************************************
741 * Name : DWORD HMDeviceFileClass::GetFileSize
742 * Purpose : set file time
743 * Parameters: PHMHANDLEDATA pHMHandleData
744 * PDWORD pSize
745 * Variables :
746 * Result : API returncode
747 * Remark :
748 * Status :
749 *
750 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
751 *****************************************************************************/
752
753DWORD HMDeviceFileClass::GetFileSize(PHMHANDLEDATA pHMHandleData,
754 PDWORD lpdwFileSizeHigh)
755{
756 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileSize %s(%08xh,%08xh)\n",
757 lpHMDeviceName,
758 pHMHandleData,
759 lpdwFileSizeHigh));
760
761 if(lpdwFileSizeHigh)
762 *lpdwFileSizeHigh = 0;
763
764 return OSLibDosGetFileSize(pHMHandleData->hHMHandle, lpdwFileSizeHigh);
765}
766
767/*****************************************************************************
768 * Name : DWORD HMDeviceFileClass::SetFilePointer
769 * Purpose : set file pointer
770 * Parameters: PHMHANDLEDATA pHMHandleData
771 * LONG lDistanceToMove
772 * PLONG lpDistanceToMoveHigh
773 * DWORD dwMoveMethod
774 * Variables :
775 * Result : API returncode
776 * Remark :
777 * Status :
778 *
779 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
780 *****************************************************************************/
781
782DWORD HMDeviceFileClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
783 LONG lDistanceToMove,
784 PLONG lpDistanceToMoveHigh,
785 DWORD dwMoveMethod)
786{
787 DWORD ret;
788
789 dprintfl(("KERNEL32: HMDeviceFileClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
790 lpHMDeviceName,
791 pHMHandleData,
792 lDistanceToMove,
793 lpDistanceToMoveHigh,
794 dwMoveMethod));
795
796 ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
797 lDistanceToMove,
798 (DWORD *)lpDistanceToMoveHigh,
799 dwMoveMethod);
800
801 if(ret == -1) {
802 dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
803 }
804 return ret;
805}
806
807
808/*****************************************************************************
809 * Name : DWORD HMDeviceFileClass::LockFile
810 * Purpose : file locking
811 * Parameters: PHMHANDLEDATA pHMHandleData
812 * DWORD arg2
813 * DWORD arg3
814 * DWORD arg4
815 * DWORD arg5
816 * Variables :
817 * Result : API returncode
818 * Remark :
819 * Status :
820 *
821 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
822 *****************************************************************************/
823
824BOOL HMDeviceFileClass::LockFile(PHMHANDLEDATA pHMHandleData,
825 DWORD dwFileOffsetLow,
826 DWORD dwFileOffsetHigh,
827 DWORD cbLockLow,
828 DWORD cbLockHigh)
829{
830 dprintfl(("KERNEL32: HMDeviceFileClass::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
831 lpHMDeviceName,
832 pHMHandleData,
833 dwFileOffsetLow,
834 dwFileOffsetHigh,
835 cbLockLow,
836 cbLockHigh));
837
838 return OSLibDosLockFile(pHMHandleData->hHMHandle,
839 LOCKFILE_EXCLUSIVE_LOCK,
840 dwFileOffsetLow,
841 dwFileOffsetHigh,
842 cbLockLow,
843 cbLockHigh,
844 NULL);
845}
846
847/*****************************************************************************
848 * Name : DWORD HMDeviceFileClass::LockFileEx
849 * Purpose : file locking
850 * Parameters: PHMHANDLEDATA pHMHandleData
851 * DWORD dwFlags
852 * DWORD dwReserved
853 * DWORD nNumberOfBytesToLockLow
854 * DWORD nNumberOfBytesToLockHigh
855 * LPOVERLAPPED lpOverlapped
856 * Variables :
857 * Result : API returncode
858 * Remark :
859 * Status :
860 *
861 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
862 *****************************************************************************/
863
864BOOL HMDeviceFileClass::LockFileEx(PHMHANDLEDATA pHMHandleData,
865 DWORD dwFlags,
866 DWORD dwReserved,
867 DWORD nNumberOfBytesToLockLow,
868 DWORD nNumberOfBytesToLockHigh,
869 LPOVERLAPPED lpOverlapped)
870{
871
872 dprintfl(("KERNEL32: HMDeviceFileClass::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented!",
873 lpHMDeviceName,
874 pHMHandleData,
875 dwFlags,
876 dwReserved,
877 nNumberOfBytesToLockLow,
878 nNumberOfBytesToLockHigh,
879 lpOverlapped));
880
881
882 return(OSLibDosLockFile(pHMHandleData->hHMHandle,
883 dwFlags,
884 lpOverlapped->Offset,
885 lpOverlapped->OffsetHigh,
886 nNumberOfBytesToLockLow,
887 nNumberOfBytesToLockHigh,
888 lpOverlapped));
889}
890
891
892/*****************************************************************************
893 * Name : DWORD HMDeviceFileClass::UnlockFile
894 * Purpose : file locking
895 * Parameters: PHMHANDLEDATA pHMHandleData
896 * DWORD arg2
897 * DWORD arg3
898 * DWORD arg4
899 * DWORD arg5
900 * Variables :
901 * Result : API returncode
902 * Remark :
903 * Status :
904 *
905 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
906 *****************************************************************************/
907
908BOOL HMDeviceFileClass::UnlockFile(PHMHANDLEDATA pHMHandleData,
909 DWORD dwFileOffsetLow,
910 DWORD dwFileOffsetHigh,
911 DWORD cbLockLow,
912 DWORD cbLockHigh)
913{
914 dprintfl(("KERNEL32: HMDeviceFileClass::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
915 lpHMDeviceName,
916 pHMHandleData,
917 dwFileOffsetLow,
918 dwFileOffsetHigh,
919 cbLockLow,
920 cbLockHigh));
921
922 return OSLibDosUnlockFile(pHMHandleData->hHMHandle,
923 dwFileOffsetLow,
924 dwFileOffsetHigh,
925 cbLockLow,
926 cbLockHigh,
927 NULL);
928}
929
930
931
932/*****************************************************************************
933 * Name : DWORD HMDeviceFileClass::UnlockFileEx
934 * Purpose : file locking
935 * Parameters: PHMHANDLEDATA pHMHandleData
936 * DWORD dwFlags
937 * DWORD dwReserved
938 * DWORD nNumberOfBytesToLockLow
939 * DWORD nNumberOfBytesToLockHigh
940 * LPOVERLAPPED lpOverlapped
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::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
950 DWORD dwReserved,
951 DWORD nNumberOfBytesToLockLow,
952 DWORD nNumberOfBytesToLockHigh,
953 LPOVERLAPPED lpOverlapped)
954{
955
956 dprintfl(("KERNEL32: HMDeviceFileClass::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented!",
957 lpHMDeviceName,
958 pHMHandleData,
959 dwReserved,
960 nNumberOfBytesToLockLow,
961 nNumberOfBytesToLockHigh,
962 lpOverlapped));
963
964
965 return(OSLibDosUnlockFile(pHMHandleData->hHMHandle,
966 lpOverlapped->Offset,
967 lpOverlapped->OffsetHigh,
968 nNumberOfBytesToLockLow,
969 nNumberOfBytesToLockHigh,
970 lpOverlapped));
971}
972
973
974/*****************************************************************************
975 * Name : DWORD HMDeviceFileClass::FlushFileBuffers
976 * Purpose : flush the buffers of a file
977 * Parameters: PHMHANDLEDATA pHMHandleData
978 * Variables :
979 * Result : API returncode
980 * Remark :
981 * Status :
982 *
983 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
984 *****************************************************************************/
985
986BOOL HMDeviceFileClass::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
987{
988 dprintfl(("KERNEL32: HMDeviceFileClass:FlushFileBuffers(%08xh)\n",
989 pHMHandleData->hHMHandle));
990
991 return(OSLibDosFlushFileBuffers(pHMHandleData->hHMHandle));
992}
993
994
995/*****************************************************************************
996 * Name : DWORD HMDeviceFileClass::GetOverlappedResult
997 * Purpose : asynchronus I/O
998 * Parameters: PHMHANDLEDATA pHMHandleData
999 * LPOVERLAPPED arg2
1000 * LPDWORD arg3
1001 * BOOL arg4
1002 * Variables :
1003 * Result : API returncode
1004 * Remark :
1005 * Status :
1006 *
1007 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1008 *****************************************************************************/
1009
1010BOOL HMDeviceFileClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
1011 LPOVERLAPPED arg2,
1012 LPDWORD arg3,
1013 BOOL arg4)
1014{
1015 dprintfl(("KERNEL32-WARNING: HMDeviceFileClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) STUB!!",
1016 pHMHandleData->hHMHandle,
1017 arg2,
1018 arg3,
1019 arg4));
1020
1021 return FALSE;
1022// return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
1023// arg2,
1024// arg3,
1025// arg4));
1026}
1027//******************************************************************************
1028//******************************************************************************
1029HMFileInfo::HMFileInfo(LPSTR lpszFileName, PVOID lpSecurityAttributes)
1030{
1031 this->lpszFileName = (LPSTR)malloc(strlen(lpszFileName)+1);
1032 if(!this->lpszFileName) {
1033 DebugInt3();
1034 }
1035 strcpy(this->lpszFileName, lpszFileName);
1036 this->lpSecurityAttributes = lpSecurityAttributes;
1037}
1038//******************************************************************************
1039//******************************************************************************
1040HMFileInfo::~HMFileInfo()
1041{
1042 if(lpszFileName) {
1043 free(lpszFileName);
1044 lpszFileName = NULL;
1045 }
1046}
1047//******************************************************************************
1048//******************************************************************************
Note: See TracBrowser for help on using the repository browser.