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

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

Fix: preparing support for HandleManager on kernel objects
File size: 20.8 KB
Line 
1/* $Id: hmopen32.cpp,v 1.3 1999-06-17 21:52:01 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 pHMHandleData->hWinHandle = hFile;
536
537 return(hFile);
538}
539
540
541/*****************************************************************************
542 * Name : DWORD HMDeviceOpen32Class::UnlockFile
543 * Purpose : file locking
544 * Parameters: PHMHANDLEDATA pHMHandleData
545 * DWORD arg2
546 * DWORD arg3
547 * DWORD arg4
548 * DWORD arg5
549 * Variables :
550 * Result : API returncode
551 * Remark :
552 * Status :
553 *
554 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
555 *****************************************************************************/
556
557DWORD HMDeviceOpen32Class::UnlockFile(PHMHANDLEDATA pHMHandleData,
558 DWORD arg2,
559 DWORD arg3,
560 DWORD arg4,
561 DWORD arg5)
562{
563 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
564 lpHMDeviceName,
565 pHMHandleData,
566 arg2,
567 arg3,
568 arg4,
569 arg5));
570
571 return O32_UnlockFile(pHMHandleData->hWinHandle,
572 arg2,
573 arg3,
574 arg4,
575 arg5);
576}
577
578
579
580/*****************************************************************************
581 * Name : DWORD HMDeviceOpen32Class::UnlockFileEx
582 * Purpose : file locking
583 * Parameters: PHMHANDLEDATA pHMHandleData
584 * DWORD dwFlags
585 * DWORD dwReserved
586 * DWORD nNumberOfBytesToLockLow
587 * DWORD nNumberOfBytesToLockHigh
588 * LPOVERLAPPED lpOverlapped
589 * Variables :
590 * Result : API returncode
591 * Remark :
592 * Status :
593 *
594 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
595 *****************************************************************************/
596
597DWORD HMDeviceOpen32Class::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
598 DWORD dwFlags,
599 DWORD dwReserved,
600 DWORD nNumberOfBytesToLockLow,
601 DWORD nNumberOfBytesToLockHigh,
602 LPOVERLAPPED lpOverlapped)
603{
604
605 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
606 lpHMDeviceName,
607 pHMHandleData,
608 dwFlags,
609 dwReserved,
610 nNumberOfBytesToLockLow,
611 nNumberOfBytesToLockHigh,
612 lpOverlapped));
613
614 return(O32_UnlockFile(pHMHandleData->hWinHandle,
615 lpOverlapped->Offset,
616 lpOverlapped->OffsetHigh,
617 nNumberOfBytesToLockLow,
618 nNumberOfBytesToLockHigh));
619}
Note: See TracBrowser for help on using the repository browser.