source: trunk/src/kernel32/hmnpipe.cpp@ 10132

Last change on this file since 10132 was 10132, checked in by sandervl, 22 years ago

CreatePipe: create unique named pipe
File size: 17.0 KB
Line 
1/* $Id: hmnpipe.cpp,v 1.11 2003-06-02 16:25:18 sandervl Exp $ */
2/*
3 * Project Odin Software License can be found in LICENSE.TXT
4 *
5 * Win32 Named Pipes device access class
6 *
7 * Copyright 2000 Przemyslaw Dobrowolski <dobrawka@asua.org.pl>
8 *
9 * TODO: OVERLAPPED results!!!!
10 *
11 * PD: All my work for Odin I dedicate to my deceased mother.
12 *
13 */
14#include <stdio.h>
15#include <odin.h>
16#include <os2win.h>
17#include <misc.h>
18#include "HMDevice.h"
19#include "HMFile.h"
20#include "HMNPipe.h"
21#include "oslibdos.h"
22#include <string.h>
23
24#define DBG_LOCALLOG DBG_hmnpipe
25#include "dbglocal.h"
26
27#undef DEBUG_LOCAL
28//#define DEBUG_LOCAL
29
30#ifdef DEBUG_LOCAL
31# define dprintfl(a) dprintf(a)
32#else
33inline void ignore_dprintf(...){}
34# define dprintfl(a) ignore_dprintf(a)
35#endif
36
37/*****************************************************************************
38 Register PIPE device class
39 *****************************************************************************/
40HMDeviceNamedPipeClass::HMDeviceNamedPipeClass(LPCSTR lpDeviceName) : HMDeviceFileClass(lpDeviceName)
41{
42 HMDeviceRegisterEx("\\\\.\\PIPE", this, NULL);
43}
44/*****************************************************************************
45 * Name : HMDeviceNamedPipeClass::FindDevice
46 * Purpose : Checks if lpDeviceName belongs to this device class
47 * Parameters: LPCSTR lpClassDevName
48 * LPCSTR lpDeviceName
49 * int namelength
50 * Variables :
51 * Result :
52 * Remark :
53 * Status :
54 *
55 * Author : SvL
56 *****************************************************************************/
57BOOL HMDeviceNamedPipeClass::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
58{
59 if(lstrncmpiA("\\\\.\\PIPE\\", lpDeviceName, 9) == 0) {
60 return TRUE;
61 }
62 return FALSE;
63}
64//******************************************************************************
65//******************************************************************************
66BOOL HMDeviceNamedPipeClass::PeekNamedPipe(PHMHANDLEDATA pHMHandleData,
67 LPVOID lpvBuffer,
68 DWORD cbBuffer,
69 LPDWORD lpcbRead,
70 LPDWORD lpcbAvail,
71 LPDWORD lpcbMessage)
72{
73 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::PeekNamedPipe %s(%08x)\n",
74 lpHMDeviceName, pHMHandleData));
75
76 return OSLibDosPeekNamedPipe(pHMHandleData->hHMHandle,
77 lpvBuffer,
78 cbBuffer,
79 lpcbRead,
80 lpcbAvail,
81 lpcbMessage);
82}
83
84//******************************************************************************
85//******************************************************************************
86DWORD HMDeviceNamedPipeClass::CreateNamedPipe(PHMHANDLEDATA pHMHandleData,
87 LPCTSTR lpName,
88 DWORD dwOpenMode,
89 DWORD dwPipeMode,
90 DWORD nMaxInstances,
91 DWORD nOutBufferSize,
92 DWORD nInBufferSize,
93 DWORD nDefaultTimeOut,
94 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
95{
96 pHMHandleData->dwInternalType = HMTYPE_PIPE;
97
98 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::CreateNamedPipe %s\n",
99 lpName));
100
101
102 pHMHandleData->hHMHandle = OSLibDosCreateNamedPipe( lpName,
103 dwOpenMode,
104 dwPipeMode,
105 nMaxInstances,
106 nOutBufferSize,
107 nInBufferSize,
108 nDefaultTimeOut,
109 lpSecurityAttributes );
110
111
112 return (pHMHandleData->hHMHandle);
113}
114/*****************************************************************************
115 * Name : DWORD HMDeviceNamedPipeClass::CreateFile
116 * Purpose : this is called from the handle manager if a CreateFile() is
117 * performed on a handle
118 * Parameters: LPCSTR lpFileName name of the file / device
119 * PHMHANDLEDATA pHMHandleData data of the NEW handle
120 * PVOID lpSecurityAttributes ignored
121 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
122 * Variables :
123 * Result :
124 * Remark :
125 * Status : NO_ERROR - API succeeded
126 * other - what is to be set in SetLastError
127 *
128 * Author : SvL
129 *****************************************************************************/
130
131DWORD HMDeviceNamedPipeClass::CreateFile (LPCSTR lpFileName,
132 PHMHANDLEDATA pHMHandleData,
133 PVOID lpSecurityAttributes,
134 PHMHANDLEDATA pHMHandleDataTemplate)
135{
136 pHMHandleData->hHMHandle = OSLibDosOpenPipe(lpFileName,
137 pHMHandleData->dwAccess,
138 pHMHandleData->dwShare,
139 (LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
140 pHMHandleData->dwCreation,
141 pHMHandleData->dwFlags);
142 if(pHMHandleData->hHMHandle == -1) {
143 return GetLastError();
144 }
145 return ERROR_SUCCESS;
146}
147
148/*****************************************************************************
149 * Name : DWORD HMDeviceFileClass::GetFileType
150 * Purpose : determine the handle type
151 * Parameters: PHMHANDLEDATA pHMHandleData
152 * Variables :
153 * Result : API returncode
154 * Remark :
155 * Status :
156 *
157 * Author : SvL
158 *****************************************************************************/
159
160DWORD HMDeviceNamedPipeClass::GetFileType(PHMHANDLEDATA pHMHandleData)
161{
162 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::GetFileType %s(%08x)\n",
163 lpHMDeviceName,
164 pHMHandleData));
165
166 return FILE_TYPE_PIPE;
167}
168
169/*****************************************************************************
170 * Name : DWORD HMDeviceNamedPipeClass::CloseHandle
171 * Purpose : close the handle
172 * Parameters: PHMHANDLEDATA pHMHandleData
173 * Variables :
174 * Result : API returncode
175 * Remark :
176 * Status :
177 *
178 * Author : SvL
179 *****************************************************************************/
180
181BOOL HMDeviceNamedPipeClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
182{
183 dprintf(("KERNEL32: HMDeviceNamedPipeClass::CloseHandle(%08x)", pHMHandleData->hHMHandle));
184
185 OSLibDosDisconnectNamedPipe(pHMHandleData->hHMHandle);
186 return OSLibDosClose(pHMHandleData->hHMHandle);
187}
188//******************************************************************************
189//******************************************************************************
190BOOL HMDeviceNamedPipeClass::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
191 LPOVERLAPPED lpOverlapped)
192{
193 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::ConnectNamedPipe %s(%08x) [%08x]\n",
194 lpHMDeviceName, pHMHandleData,lpOverlapped));
195
196 return OSLibDosConnectNamedPipe(pHMHandleData->hHMHandle,lpOverlapped);
197}
198
199//******************************************************************************
200//******************************************************************************
201BOOL HMDeviceNamedPipeClass::DisconnectNamedPipe(PHMHANDLEDATA pHMHandleData)
202{
203 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::DisconnectNamedPipe %s(%08x)\n",
204 lpHMDeviceName, pHMHandleData));
205
206 return OSLibDosDisconnectNamedPipe(pHMHandleData->hHMHandle);
207}
208
209//******************************************************************************
210//******************************************************************************
211BOOL HMDeviceNamedPipeClass::GetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
212 LPDWORD lpState,
213 LPDWORD lpCurInstances,
214 LPDWORD lpMaxCollectionCount,
215 LPDWORD lpCollectDataTimeout,
216 LPTSTR lpUserName,
217 DWORD nMaxUserNameSize)
218{
219 dprintf(("KERNEL32: HMDeviceNamedPipeClass::GetNamedPipeHandleStateA (%s) (%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) NIY\n",
220 lpHMDeviceName,
221 lpState,
222 lpCurInstances,
223 lpMaxCollectionCount,
224 lpCollectDataTimeout,
225 lpUserName,
226 nMaxUserNameSize));
227
228 return (FALSE);
229}
230
231//******************************************************************************
232//******************************************************************************
233BOOL HMDeviceNamedPipeClass::GetNamedPipeInfo(PHMHANDLEDATA pHMHandleData,
234 LPDWORD lpFlags,
235 LPDWORD lpOutBufferSize,
236 LPDWORD lpInBufferSize,
237 LPDWORD lpMaxInstances)
238{
239
240 dprintf(("KERNEL32: HMDeviceNamedPipeClass::GetNamedPipeInfo (%s) (%08xh,%08xh,%08xh,%08xh) NIY\n",
241 lpHMDeviceName,
242 lpFlags,
243 lpOutBufferSize,
244 lpInBufferSize,
245 lpMaxInstances));
246
247 return (FALSE);
248}
249//******************************************************************************
250//******************************************************************************
251DWORD HMDeviceNamedPipeClass::TransactNamedPipe(PHMHANDLEDATA pHMHandleData,
252 LPVOID lpvWriteBuf,
253 DWORD cbWriteBuf,
254 LPVOID lpvReadBuf,
255 DWORD cbReadBuf,
256 LPDWORD lpcbRead,
257 LPOVERLAPPED lpo)
258{
259
260 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::TransactNamedPipe %s(%08x) - [%08x,%08x,%08x,%08x,%08x,%08x]\n",
261 lpHMDeviceName, pHMHandleData,lpvWriteBuf,cbWriteBuf,lpvReadBuf,cbReadBuf,lpcbRead,lpo));
262
263 return(OSLibDosTransactNamedPipe( pHMHandleData->hHMHandle,
264 lpvWriteBuf,
265 cbWriteBuf,
266 lpvReadBuf,
267 cbReadBuf,
268 lpcbRead,
269 lpo));
270}
271//******************************************************************************
272//******************************************************************************
273BOOL HMDeviceNamedPipeClass::SetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
274 LPDWORD lpdwMode,
275 LPDWORD lpcbMaxCollect,
276 LPDWORD lpdwCollectDataTimeout)
277{
278 BOOL ret;
279
280 dprintf(("KERNEL32: HMDeviceNamedPipeClass::SetNamedPipeInfo (%s) (%08xh,%08xh,%08xh)",
281 lpdwMode,lpcbMaxCollect,lpdwCollectDataTimeout));
282
283 if(lpdwMode) {
284 ret = OSLibSetNamedPipeState(pHMHandleData->hHMHandle, *lpdwMode);
285 }
286 if(lpcbMaxCollect || lpdwCollectDataTimeout) {
287 dprintf(("WARNING: Not supported -> lpcbMaxCollect & lpdwCollectDataTimeout"));
288 }
289 return ret;
290}
291//******************************************************************************
292//******************************************************************************
293BOOL HMDeviceNamedPipeClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
294 LPOVERLAPPED arg2,
295 LPDWORD arg3,
296 BOOL arg4)
297{
298 return (FALSE);
299}
300/*****************************************************************************
301 * Name : BOOL HMDeviceNamedPipeClass::ReadFile
302 * Purpose : read data from handle / device
303 * Parameters: PHMHANDLEDATA pHMHandleData,
304 * LPCVOID lpBuffer,
305 * DWORD nNumberOfBytesToRead,
306 * LPDWORD lpNumberOfBytesRead,
307 * LPOVERLAPPED lpOverlapped
308 * Variables :
309 * Result : Boolean
310 * Remark :
311 * Status :
312 *
313 * Author : SvL
314 *****************************************************************************/
315
316BOOL HMDeviceNamedPipeClass::ReadFile(PHMHANDLEDATA pHMHandleData,
317 LPCVOID lpBuffer,
318 DWORD nNumberOfBytesToRead,
319 LPDWORD lpNumberOfBytesRead,
320 LPOVERLAPPED lpOverlapped,
321 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
322{
323 DWORD bytesread;
324 BOOL bRC;
325
326 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
327 lpHMDeviceName,
328 pHMHandleData,
329 lpBuffer,
330 nNumberOfBytesToRead,
331 lpNumberOfBytesRead,
332 lpOverlapped));
333
334 //This pointer can to be NULL
335 if(lpNumberOfBytesRead)
336 *lpNumberOfBytesRead = 0;
337 else
338 lpNumberOfBytesRead = &bytesread;
339
340 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
341 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
342 SetLastError(ERROR_INVALID_PARAMETER);
343 return FALSE;
344 }
345 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
346 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
347 }
348 if(lpCompletionRoutine) {
349 dprintf(("!WARNING!: lpCompletionRoutine not supported -> fall back to sync IO"));
350 }
351
352 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
353 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
354 }
355
356 bRC = HMDeviceFileClass::ReadFile(pHMHandleData,
357 lpBuffer,
358 nNumberOfBytesToRead,
359 lpNumberOfBytesRead,
360 lpOverlapped, lpCompletionRoutine);
361
362 dprintf(("KERNEL32: HMDeviceNamedPipeClass::ReadFile returned %08xh; bytes read %d",
363 bRC, *lpNumberOfBytesRead));
364
365 return bRC;
366}
367
368
369/*****************************************************************************
370 * Name : BOOL HMDeviceNamedPipeClass::WriteFile
371 * Purpose : write data to handle / device
372 * Parameters: PHMHANDLEDATA pHMHandleData,
373 * LPCVOID lpBuffer,
374 * DWORD nNumberOfBytesToWrite,
375 * LPDWORD lpNumberOfBytesWritten,
376 * LPOVERLAPPED lpOverlapped
377 * Variables :
378 * Result : Boolean
379 * Remark :
380 * Status :
381 *
382 * Author : SvL
383 *****************************************************************************/
384
385BOOL HMDeviceNamedPipeClass::WriteFile(PHMHANDLEDATA pHMHandleData,
386 LPCVOID lpBuffer,
387 DWORD nNumberOfBytesToWrite,
388 LPDWORD lpNumberOfBytesWritten,
389 LPOVERLAPPED lpOverlapped,
390 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
391{
392 DWORD byteswritten;
393 BOOL bRC;
394
395 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
396 lpHMDeviceName,
397 pHMHandleData,
398 lpBuffer,
399 nNumberOfBytesToWrite,
400 lpNumberOfBytesWritten,
401 lpOverlapped));
402
403 //This pointer can to be NULL
404 if(lpNumberOfBytesWritten)
405 *lpNumberOfBytesWritten = 0;
406 else
407 lpNumberOfBytesWritten = &byteswritten;
408
409 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
410 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
411 SetLastError(ERROR_INVALID_PARAMETER);
412 return FALSE;
413 }
414 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
415 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
416 }
417
418 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
419 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
420 }
421 bRC = HMDeviceFileClass::WriteFile(pHMHandleData,
422 lpBuffer,
423 nNumberOfBytesToWrite,
424 lpNumberOfBytesWritten,
425 lpOverlapped, lpCompletionRoutine);
426
427 dprintf(("KERNEL32: HMDeviceNamedPipeClass::WriteFile returned %08xh; bytes written %d",
428 bRC, *lpNumberOfBytesWritten));
429
430 return bRC;
431}
432//******************************************************************************
433//******************************************************************************
Note: See TracBrowser for help on using the repository browser.