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

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

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