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

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

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