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

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

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