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

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

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