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

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

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