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

Last change on this file since 9022 was 8685, checked in by sandervl, 23 years ago

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