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

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

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