source: trunk/src/kernel32/hmopen32.cpp@ 241

Last change on this file since 241 was 241, checked in by phaller, 26 years ago

Fix: HandleManager::Open32::OpenFile return code
File size: 21.1 KB
Line 
1/* $Id: hmopen32.cpp,v 1.5 1999-06-29 11:02:52 phaller Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Win32 Unified Handle Manager for OS/2
6 */
7
8
9/*****************************************************************************
10 * Remark *
11 *****************************************************************************
12 */
13
14//#define DEBUG_LOCAL
15
16#ifdef DEBUG_LOCAL
17# define dprintfl(a) dprintf(a)
18#else
19inline void ignore_dprintf(...){}
20# define dprintfl(a) ignore_dprintf(a)
21#endif
22
23/*****************************************************************************
24 * Includes *
25 *****************************************************************************/
26
27#include <os2win.h>
28#include <string.h>
29#include "HandleManager.h"
30#include "HMOpen32.h"
31
32
33/*****************************************************************************
34 * Defines *
35 *****************************************************************************/
36
37
38/*****************************************************************************
39 * Structures *
40 *****************************************************************************/
41
42/*****************************************************************************
43 * Name : HMDeviceOpen32Class::_DeviceRequest
44 * Purpose : entry method for special request functions
45 * Parameters: ULONG ulRequestCode
46 * various parameters as required
47 * Variables :
48 * Result :
49 * Remark : the standard behaviour is to return an error code for non-
50 * existant request codes
51 * Status :
52 *
53 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
54 *****************************************************************************/
55DWORD HMDeviceOpen32Class::_DeviceRequest (PHMHANDLEDATA pHMHandleData,
56 ULONG ulRequestCode,
57 ULONG arg1,
58 ULONG arg2,
59 ULONG arg3,
60 ULONG arg4)
61{
62 dprintfl(("KERNEL32: HandleManager::Open32::_DeviceRequest %s(%08x,%08x) - stub?\n",
63 lpHMDeviceName,
64 pHMHandleData,
65 ulRequestCode));
66
67 return(ERROR_INVALID_FUNCTION);
68}
69
70
71/*****************************************************************************
72 * Name : DWORD HMDeviceOpen32Class::CreateFile
73 * Purpose : this is called from the handle manager if a CreateFile() is
74 * performed on a handle
75 * Parameters: LPCSTR lpFileName name of the file / device
76 * PHMHANDLEDATA pHMHandleData data of the NEW handle
77 * PVOID lpSecurityAttributes ignored
78 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
79 * Variables :
80 * Result :
81 * Remark :
82 * Status : NO_ERROR - API succeeded
83 * other - what is to be set in SetLastError
84 *
85 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
86 *****************************************************************************/
87
88DWORD HMDeviceOpen32Class::CreateFile (LPCSTR lpFileName,
89 PHMHANDLEDATA pHMHandleData,
90 PVOID lpSecurityAttributes,
91 PHMHANDLEDATA pHMHandleDataTemplate)
92{
93 HFILE hFile;
94 HFILE hTemplate;
95
96 dprintfl(("KERNEL32: HandleManager::Open32::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
97 lpHMDeviceName,
98 lpFileName,
99 pHMHandleData,
100 lpSecurityAttributes,
101 pHMHandleDataTemplate));
102
103 if (strncmp(lpFileName, // "support" for local unc names
104 "\\\\.\\",
105 4) == 0)
106 lpFileName+=4;
107
108 // create from template
109 if (pHMHandleDataTemplate != NULL)
110 hTemplate = pHMHandleDataTemplate->hWinHandle;
111 else
112 hTemplate = 0;
113
114 hFile = O32_CreateFile(lpFileName,
115 pHMHandleData->dwAccess,
116 pHMHandleData->dwShare,
117 //(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
118 NULL,
119 pHMHandleData->dwCreation,
120 pHMHandleData->dwFlags,
121 hTemplate);
122 if (hFile != INVALID_HANDLE_ERROR)
123 {
124 pHMHandleData->hWinHandle = hFile;
125 return (NO_ERROR);
126 }
127 else
128 return(O32_GetLastError());
129}
130
131
132/*****************************************************************************
133 * Name : DWORD HMDeviceOpen32Class::CloseHandle
134 * Purpose : close the handle
135 * Parameters: PHMHANDLEDATA pHMHandleData
136 * Variables :
137 * Result : API returncode
138 * Remark :
139 * Status :
140 *
141 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
142 *****************************************************************************/
143
144DWORD HMDeviceOpen32Class::CloseHandle(PHMHANDLEDATA pHMHandleData)
145{
146 BOOL bRC;
147
148 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle(%08x)\n",
149 pHMHandleData->hWinHandle));
150
151 bRC = O32_CloseHandle(pHMHandleData->hWinHandle);
152
153 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle returned %08xh\n",
154 bRC));
155
156 return (DWORD)bRC;
157}
158
159
160/*****************************************************************************
161 * Name : DWORD HMDeviceOpen32Class::ReadFile
162 * Purpose : read data from handle / device
163 * Parameters: PHMHANDLEDATA pHMHandleData,
164 * LPCVOID lpBuffer,
165 * DWORD nNumberOfBytesToRead,
166 * LPDWORD lpNumberOfBytesRead,
167 * LPOVERLAPPED lpOverlapped
168 * Variables :
169 * Result : API returncode
170 * Remark :
171 * Status :
172 *
173 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
174 *****************************************************************************/
175
176DWORD HMDeviceOpen32Class::ReadFile(PHMHANDLEDATA pHMHandleData,
177 LPCVOID lpBuffer,
178 DWORD nNumberOfBytesToRead,
179 LPDWORD lpNumberOfBytesRead,
180 LPOVERLAPPED lpOverlapped)
181{
182 BOOL bRC;
183
184 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
185 lpHMDeviceName,
186 pHMHandleData,
187 lpBuffer,
188 nNumberOfBytesToRead,
189 lpNumberOfBytesRead,
190 lpOverlapped));
191
192 bRC = O32_ReadFile(pHMHandleData->hWinHandle,
193 (PVOID)lpBuffer,
194 nNumberOfBytesToRead,
195 lpNumberOfBytesRead,
196 lpOverlapped);
197
198 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh\n",
199 bRC));
200
201 return (DWORD)bRC;
202}
203
204
205/*****************************************************************************
206 * Name : DWORD HMDeviceOpen32Class::WriteFile
207 * Purpose : write data to handle / device
208 * Parameters: PHMHANDLEDATA pHMHandleData,
209 * LPCVOID lpBuffer,
210 * DWORD nNumberOfBytesToWrite,
211 * LPDWORD lpNumberOfBytesWritten,
212 * LPOVERLAPPED lpOverlapped
213 * Variables :
214 * Result : API returncode
215 * Remark :
216 * Status :
217 *
218 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
219 *****************************************************************************/
220
221DWORD HMDeviceOpen32Class::WriteFile(PHMHANDLEDATA pHMHandleData,
222 LPCVOID lpBuffer,
223 DWORD nNumberOfBytesToWrite,
224 LPDWORD lpNumberOfBytesWritten,
225 LPOVERLAPPED lpOverlapped)
226{
227 BOOL bRC;
228
229 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
230 lpHMDeviceName,
231 pHMHandleData,
232 lpBuffer,
233 nNumberOfBytesToWrite,
234 lpNumberOfBytesWritten,
235 lpOverlapped));
236
237 bRC = O32_WriteFile(pHMHandleData->hWinHandle,
238 lpBuffer,
239 nNumberOfBytesToWrite,
240 lpNumberOfBytesWritten,
241 lpOverlapped);
242
243 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile returned %08xh\n",
244 bRC));
245
246 return (DWORD)bRC;
247}
248
249
250/*****************************************************************************
251 * Name : DWORD HMDeviceOpen32Class::GetFileType
252 * Purpose : determine the handle type
253 * Parameters: PHMHANDLEDATA pHMHandleData
254 * Variables :
255 * Result : API returncode
256 * Remark :
257 * Status :
258 *
259 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
260 *****************************************************************************/
261
262DWORD HMDeviceOpen32Class::GetFileType(PHMHANDLEDATA pHMHandleData)
263{
264 dprintfl(("KERNEL32: HandleManager::Open32::GetFileType %s(%08x)\n",
265 lpHMDeviceName,
266 pHMHandleData));
267
268 return O32_GetFileType(pHMHandleData->hWinHandle);
269}
270
271
272/*****************************************************************************
273 * Name : DWORD HMDeviceOpen32Class::GetFileInformationByHandle
274 * Purpose : determine the handle type
275 * Parameters: PHMHANDLEDATA pHMHandleData
276 * BY_HANDLE_FILE_INFORMATION* pHFI
277 * Variables :
278 * Result : API returncode
279 * Remark :
280 * Status :
281 *
282 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
283 *****************************************************************************/
284
285DWORD HMDeviceOpen32Class::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
286 BY_HANDLE_FILE_INFORMATION* pHFI)
287{
288 dprintfl(("KERNEL32: HandleManager::Open32::GetFileInformationByHandle %s(%08xh,%08xh)\n",
289 lpHMDeviceName,
290 pHMHandleData,
291 pHFI));
292
293 return O32_GetFileInformationByHandle(pHMHandleData->hWinHandle,
294 pHFI);
295}
296
297
298/*****************************************************************************
299 * Name : BOOL HMDeviceOpen32Class::SetEndOfFile
300 * Purpose : set end of file marker
301 * Parameters: PHMHANDLEDATA pHMHandleData
302 * Variables :
303 * Result : API returncode
304 * Remark :
305 * Status :
306 *
307 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
308 *****************************************************************************/
309
310BOOL HMDeviceOpen32Class::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
311{
312 dprintfl(("KERNEL32: HandleManager::Open32::SetEndOfFile %s(%08xh)\n",
313 lpHMDeviceName,
314 pHMHandleData));
315
316 return O32_SetEndOfFile(pHMHandleData->hWinHandle);
317}
318
319
320/*****************************************************************************
321 * Name : BOOL HMDeviceOpen32Class::SetFileTime
322 * Purpose : set file time
323 * Parameters: PHMHANDLEDATA pHMHandleData
324 * PFILETIME pFT1
325 * PFILETIME pFT2
326 * PFILETIME pFT3
327 * Variables :
328 * Result : API returncode
329 * Remark :
330 * Status :
331 *
332 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
333 *****************************************************************************/
334
335BOOL HMDeviceOpen32Class::SetFileTime(PHMHANDLEDATA pHMHandleData,
336 LPFILETIME pFT1,
337 LPFILETIME pFT2,
338 LPFILETIME pFT3)
339{
340 dprintfl(("KERNEL32: HandleManager::Open32::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
341 lpHMDeviceName,
342 pHMHandleData,
343 pFT1,
344 pFT2,
345 pFT3));
346
347 return O32_SetFileTime(pHMHandleData->hWinHandle,
348 pFT1,
349 pFT2,
350 pFT3);
351}
352
353
354/*****************************************************************************
355 * Name : DWORD HMDeviceOpen32Class::GetFileSize
356 * Purpose : set file time
357 * Parameters: PHMHANDLEDATA pHMHandleData
358 * PDWORD pSize
359 * Variables :
360 * Result : API returncode
361 * Remark :
362 * Status :
363 *
364 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
365 *****************************************************************************/
366
367DWORD HMDeviceOpen32Class::GetFileSize(PHMHANDLEDATA pHMHandleData,
368 PDWORD pSize)
369{
370 dprintfl(("KERNEL32: HandleManager::Open32::GetFileSize %s(%08xh,%08xh)\n",
371 lpHMDeviceName,
372 pHMHandleData,
373 pSize));
374
375 return O32_GetFileSize(pHMHandleData->hWinHandle,
376 pSize);
377}
378
379
380/*****************************************************************************
381 * Name : DWORD HMDeviceOpen32Class::SetFilePointer
382 * Purpose : set file pointer
383 * Parameters: PHMHANDLEDATA pHMHandleData
384 * LONG lDistanceToMove
385 * PLONG lpDistanceToMoveHigh
386 * DWORD dwMoveMethod
387 * Variables :
388 * Result : API returncode
389 * Remark :
390 * Status :
391 *
392 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
393 *****************************************************************************/
394
395DWORD HMDeviceOpen32Class::SetFilePointer(PHMHANDLEDATA pHMHandleData,
396 LONG lDistanceToMove,
397 PLONG lpDistanceToMoveHigh,
398 DWORD dwMoveMethod)
399{
400 dprintfl(("KERNEL32: HandleManager::Open32::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
401 lpHMDeviceName,
402 pHMHandleData,
403 lDistanceToMove,
404 lpDistanceToMoveHigh,
405 dwMoveMethod));
406
407 return O32_SetFilePointer(pHMHandleData->hWinHandle,
408 lDistanceToMove,
409 lpDistanceToMoveHigh,
410 dwMoveMethod);
411}
412
413
414/*****************************************************************************
415 * Name : DWORD HMDeviceOpen32Class::LockFile
416 * Purpose : file locking
417 * Parameters: PHMHANDLEDATA pHMHandleData
418 * DWORD arg2
419 * DWORD arg3
420 * DWORD arg4
421 * DWORD arg5
422 * Variables :
423 * Result : API returncode
424 * Remark :
425 * Status :
426 *
427 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
428 *****************************************************************************/
429
430DWORD HMDeviceOpen32Class::LockFile(PHMHANDLEDATA pHMHandleData,
431 DWORD arg2,
432 DWORD arg3,
433 DWORD arg4,
434 DWORD arg5)
435{
436 dprintfl(("KERNEL32: HandleManager::Open32::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
437 lpHMDeviceName,
438 pHMHandleData,
439 arg2,
440 arg3,
441 arg4,
442 arg5));
443
444 return O32_LockFile(pHMHandleData->hWinHandle,
445 arg2,
446 arg3,
447 arg4,
448 arg5);
449}
450
451
452
453/*****************************************************************************
454 * Name : DWORD HMDeviceOpen32Class::LockFileEx
455 * Purpose : file locking
456 * Parameters: PHMHANDLEDATA pHMHandleData
457 * DWORD dwFlags
458 * DWORD dwReserved
459 * DWORD nNumberOfBytesToLockLow
460 * DWORD nNumberOfBytesToLockHigh
461 * LPOVERLAPPED lpOverlapped
462 * Variables :
463 * Result : API returncode
464 * Remark :
465 * Status :
466 *
467 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
468 *****************************************************************************/
469
470DWORD HMDeviceOpen32Class::LockFileEx(PHMHANDLEDATA pHMHandleData,
471 DWORD dwFlags,
472 DWORD dwReserved,
473 DWORD nNumberOfBytesToLockLow,
474 DWORD nNumberOfBytesToLockHigh,
475 LPOVERLAPPED lpOverlapped)
476{
477
478 dprintfl(("KERNEL32: HandleManager::Open32::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
479 lpHMDeviceName,
480 pHMHandleData,
481 dwFlags,
482 dwReserved,
483 nNumberOfBytesToLockLow,
484 nNumberOfBytesToLockHigh,
485 lpOverlapped));
486
487
488 return(O32_LockFile(pHMHandleData->hWinHandle,
489 lpOverlapped->Offset,
490 lpOverlapped->OffsetHigh,
491 nNumberOfBytesToLockLow,
492 nNumberOfBytesToLockHigh));
493}
494
495
496/*****************************************************************************
497 * Name : DWORD HMDeviceOpen32Class::OpenFile
498 * Purpose : this is called from the handle manager if a OpenFile() is
499 * performed on a handle
500 * Parameters: LPCSTR lpFileName name of the file / device
501 * PHMHANDLEDATA pHMHandleData data of the NEW handle
502 * PVOID lpSecurityAttributes ignored
503 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
504 * Variables :
505 * Result :
506 * Remark :
507 * Status : NO_ERROR - API succeeded
508 * other - what is to be set in SetLastError
509 *
510 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
511 *****************************************************************************/
512
513DWORD HMDeviceOpen32Class::OpenFile (LPCSTR lpFileName,
514 PHMHANDLEDATA pHMHandleData,
515 OFSTRUCT *pOFStruct,
516 UINT arg3)
517{
518 HFILE hFile;
519
520 dprintfl(("KERNEL32: HandleManager::Open32::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
521 lpHMDeviceName,
522 lpFileName,
523 pHMHandleData,
524 pOFStruct,
525 arg3));
526
527 if (strcmp(lpFileName, // "support" for local unc names
528 "\\\\.\\") == 0)
529 lpFileName+=4;
530
531 hFile = O32_OpenFile(lpFileName,
532 pOFStruct,
533 arg3);
534 if (hFile != INVALID_HANDLE_ERROR)
535 {
536 pHMHandleData->hWinHandle = hFile;
537 return (NO_ERROR);
538 }
539
540 //@@@PH: Edgar Buerkle suspects wrong return value here, should be 0 in case of success
541 hFile = O32_GetLastError();
542 dprintf(("KERNEL32: HandleManager::Open32::OpenFile returns %08xh\n",
543 hFile));
544
545 return(hFile); // return error cause
546}
547
548
549/*****************************************************************************
550 * Name : DWORD HMDeviceOpen32Class::UnlockFile
551 * Purpose : file locking
552 * Parameters: PHMHANDLEDATA pHMHandleData
553 * DWORD arg2
554 * DWORD arg3
555 * DWORD arg4
556 * DWORD arg5
557 * Variables :
558 * Result : API returncode
559 * Remark :
560 * Status :
561 *
562 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
563 *****************************************************************************/
564
565DWORD HMDeviceOpen32Class::UnlockFile(PHMHANDLEDATA pHMHandleData,
566 DWORD arg2,
567 DWORD arg3,
568 DWORD arg4,
569 DWORD arg5)
570{
571 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
572 lpHMDeviceName,
573 pHMHandleData,
574 arg2,
575 arg3,
576 arg4,
577 arg5));
578
579 return O32_UnlockFile(pHMHandleData->hWinHandle,
580 arg2,
581 arg3,
582 arg4,
583 arg5);
584}
585
586
587
588/*****************************************************************************
589 * Name : DWORD HMDeviceOpen32Class::UnlockFileEx
590 * Purpose : file locking
591 * Parameters: PHMHANDLEDATA pHMHandleData
592 * DWORD dwFlags
593 * DWORD dwReserved
594 * DWORD nNumberOfBytesToLockLow
595 * DWORD nNumberOfBytesToLockHigh
596 * LPOVERLAPPED lpOverlapped
597 * Variables :
598 * Result : API returncode
599 * Remark :
600 * Status :
601 *
602 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
603 *****************************************************************************/
604
605DWORD HMDeviceOpen32Class::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
606 DWORD dwFlags,
607 DWORD dwReserved,
608 DWORD nNumberOfBytesToLockLow,
609 DWORD nNumberOfBytesToLockHigh,
610 LPOVERLAPPED lpOverlapped)
611{
612
613 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
614 lpHMDeviceName,
615 pHMHandleData,
616 dwFlags,
617 dwReserved,
618 nNumberOfBytesToLockLow,
619 nNumberOfBytesToLockHigh,
620 lpOverlapped));
621
622 return(O32_UnlockFile(pHMHandleData->hWinHandle,
623 lpOverlapped->Offset,
624 lpOverlapped->OffsetHigh,
625 nNumberOfBytesToLockLow,
626 nNumberOfBytesToLockHigh));
627}
Note: See TracBrowser for help on using the repository browser.