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

Last change on this file since 8001 was 7550, checked in by sandervl, 24 years ago

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