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