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

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

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