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

Last change on this file since 7474 was 7474, checked in by phaller, 24 years ago

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