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

Last change on this file since 7474 was 7474, checked in by phaller, 24 years ago

Fixes in HandleManager and Device Handlers
File size: 11.9 KB
Line 
1/* $Id: hmnpipe.cpp,v 1.5 2001-11-28 23:33:37 phaller 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 <odin.h>
15#include <os2win.h>
16#include <misc.h>
17#include "HMDevice.h"
18#include "HMFile.h"
19#include "HMNPipe.h"
20#include "oslibdos.h"
21#include <string.h>
22
23#define DBG_LOCALLOG DBG_hmnpipe
24#include "dbglocal.h"
25
26#undef DEBUG_LOCAL
27//#define DEBUG_LOCAL
28
29#ifdef DEBUG_LOCAL
30# define dprintfl(a) dprintf(a)
31#else
32inline void ignore_dprintf(...){}
33# define dprintfl(a) ignore_dprintf(a)
34#endif
35
36/*****************************************************************************
37 Register PIPE device class
38 *****************************************************************************/
39HMDeviceNamedPipeClass::HMDeviceNamedPipeClass(LPCSTR lpDeviceName) : HMDeviceFileClass(lpDeviceName)
40{
41 HMDeviceRegisterEx("\\\\.\\PIPE", this, NULL);
42}
43/*****************************************************************************
44 * Name : HMDeviceNamedPipeClass::FindDevice
45 * Purpose : Checks if lpDeviceName belongs to this device class
46 * Parameters: LPCSTR lpClassDevName
47 * LPCSTR lpDeviceName
48 * int namelength
49 * Variables :
50 * Result :
51 * Remark :
52 * Status :
53 *
54 * Author : SvL
55 *****************************************************************************/
56BOOL HMDeviceNamedPipeClass::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
57{
58 if(lstrncmpiA("\\\\.\\PIPE\\", lpDeviceName, 9) == 0) {
59 return TRUE;
60 }
61 return FALSE;
62}
63//******************************************************************************
64//******************************************************************************
65BOOL HMDeviceNamedPipeClass::PeekNamedPipe(PHMHANDLEDATA pHMHandleData,
66 LPVOID lpvBuffer,
67 DWORD cbBuffer,
68 LPDWORD lpcbRead,
69 LPDWORD lpcbAvail,
70 LPDWORD lpcbMessage)
71{
72 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::PeekNamedPipe %s(%08x)\n",
73 lpHMDeviceName, pHMHandleData));
74
75 return OSLibDosPeekNamedPipe(pHMHandleData->hHMHandle,
76 lpvBuffer,
77 cbBuffer,
78 lpcbRead,
79 lpcbAvail,
80 lpcbMessage);
81}
82
83//******************************************************************************
84//******************************************************************************
85DWORD HMDeviceNamedPipeClass::CreateNamedPipe(PHMHANDLEDATA pHMHandleData,
86 LPCTSTR lpName,
87 DWORD dwOpenMode,
88 DWORD dwPipeMode,
89 DWORD nMaxInstances,
90 DWORD nOutBufferSize,
91 DWORD nInBufferSize,
92 DWORD nDefaultTimeOut,
93 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
94{
95 pHMHandleData->dwInternalType = HMTYPE_PIPE;
96
97 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::CreateNamedPipe %s\n",
98 lpName));
99
100
101 pHMHandleData->hHMHandle = OSLibDosCreateNamedPipe( lpName,
102 dwOpenMode,
103 dwPipeMode,
104 nMaxInstances,
105 nOutBufferSize,
106 nInBufferSize,
107 nDefaultTimeOut,
108 lpSecurityAttributes );
109
110
111 return (pHMHandleData->hHMHandle);
112}
113/*****************************************************************************
114 * Name : DWORD HMDeviceNamedPipeClass::CreateFile
115 * Purpose : this is called from the handle manager if a CreateFile() is
116 * performed on a handle
117 * Parameters: LPCSTR lpFileName name of the file / device
118 * PHMHANDLEDATA pHMHandleData data of the NEW handle
119 * PVOID lpSecurityAttributes ignored
120 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
121 * Variables :
122 * Result :
123 * Remark :
124 * Status : NO_ERROR - API succeeded
125 * other - what is to be set in SetLastError
126 *
127 * Author : SvL
128 *****************************************************************************/
129
130DWORD HMDeviceNamedPipeClass::CreateFile (HANDLE hHandle,
131 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 {
144 return GetLastError();
145 }
146 return ERROR_SUCCESS;
147}
148
149/*****************************************************************************
150 * Name : DWORD HMDeviceNamedPipeClass::CloseHandle
151 * Purpose : close the handle
152 * Parameters: PHMHANDLEDATA pHMHandleData
153 * Variables :
154 * Result : API returncode
155 * Remark :
156 * Status :
157 *
158 * Author : SvL
159 *****************************************************************************/
160
161BOOL HMDeviceNamedPipeClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
162{
163 dprintf(("KERNEL32: HMDeviceNamedPipeClass::CloseHandle(%08x)", pHMHandleData->hHMHandle));
164
165 return OSLibDosClose(pHMHandleData->hHMHandle);
166}
167//******************************************************************************
168//******************************************************************************
169BOOL HMDeviceNamedPipeClass::CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
170 PHMHANDLEDATA pHMHandleDataWrite,
171 LPSECURITY_ATTRIBUTES lpsa,
172 DWORD cbPipe)
173{
174 pHMHandleDataRead->dwInternalType = HMTYPE_PIPE;
175 pHMHandleDataWrite->dwInternalType = HMTYPE_PIPE;
176
177 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::CreatePipe"));
178
179 if(!OSLibDosCreatePipe(&pHMHandleDataRead->hHMHandle,
180 &pHMHandleDataWrite->hHMHandle,
181 lpsa,
182 cbPipe))
183 return TRUE;
184 else
185 return(FALSE);
186}
187
188
189//******************************************************************************
190//******************************************************************************
191BOOL HMDeviceNamedPipeClass::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
192 LPOVERLAPPED lpOverlapped)
193{
194 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::ConnectNamedPipe %s(%08x) [%08x]\n",
195 lpHMDeviceName, pHMHandleData,lpOverlapped));
196
197 return OSLibDosConnectNamedPipe(pHMHandleData->hHMHandle,lpOverlapped);
198}
199
200//******************************************************************************
201//******************************************************************************
202BOOL HMDeviceNamedPipeClass::DisconnectNamedPipe(PHMHANDLEDATA pHMHandleData)
203{
204 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::DisconnectNamedPipe %s(%08x)\n",
205 lpHMDeviceName, pHMHandleData));
206
207 return OSLibDosDisconnectNamedPipe(pHMHandleData->hHMHandle);
208}
209
210//******************************************************************************
211//******************************************************************************
212BOOL HMDeviceNamedPipeClass::GetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
213 LPDWORD lpState,
214 LPDWORD lpCurInstances,
215 LPDWORD lpMaxCollectionCount,
216 LPDWORD lpCollectDataTimeout,
217 LPTSTR lpUserName,
218 DWORD nMaxUserNameSize)
219{
220 dprintf(("KERNEL32: HMDeviceNamedPipeClass::GetNamedPipeHandleStateA (%s) (%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) NIY\n",
221 lpHMDeviceName,
222 lpState,
223 lpCurInstances,
224 lpMaxCollectionCount,
225 lpCollectDataTimeout,
226 lpUserName,
227 nMaxUserNameSize));
228
229 return (FALSE);
230}
231
232//******************************************************************************
233//******************************************************************************
234BOOL HMDeviceNamedPipeClass::GetNamedPipeInfo(PHMHANDLEDATA pHMHandleData,
235 LPDWORD lpFlags,
236 LPDWORD lpOutBufferSize,
237 LPDWORD lpInBufferSize,
238 LPDWORD lpMaxInstances)
239{
240
241 dprintf(("KERNEL32: HMDeviceNamedPipeClass::GetNamedPipeInfo (%s) (%08xh,%08xh,%08xh,%08xh) NIY\n",
242 lpHMDeviceName,
243 lpFlags,
244 lpOutBufferSize,
245 lpInBufferSize,
246 lpMaxInstances));
247
248 return (FALSE);
249}
250
251//******************************************************************************
252//******************************************************************************
253DWORD HMDeviceNamedPipeClass::TransactNamedPipe(PHMHANDLEDATA pHMHandleData,
254 LPVOID lpvWriteBuf,
255 DWORD cbWriteBuf,
256 LPVOID lpvReadBuf,
257 DWORD cbReadBuf,
258 LPDWORD lpcbRead,
259 LPOVERLAPPED lpo)
260{
261
262 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::TransactNamedPipe %s(%08x) - [%08x,%08x,%08x,%08x,%08x,%08x]\n",
263 lpHMDeviceName, pHMHandleData,lpvWriteBuf,cbWriteBuf,lpvReadBuf,cbReadBuf,lpcbRead,lpo));
264
265 return(OSLibDosTransactNamedPipe( pHMHandleData->hHMHandle,
266 lpvWriteBuf,
267 cbWriteBuf,
268 lpvReadBuf,
269 cbReadBuf,
270 lpcbRead,
271 lpo));
272}
273
274BOOL HMDeviceNamedPipeClass::SetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
275 LPDWORD lpdwMode,
276 LPDWORD lpcbMaxCollect,
277 LPDWORD lpdwCollectDataTimeout)
278{
279 BOOL ret;
280
281 dprintf(("KERNEL32: HMDeviceNamedPipeClass::SetNamedPipeInfo (%s) (%08xh,%08xh,%08xh)",
282 lpdwMode,lpcbMaxCollect,lpdwCollectDataTimeout));
283
284 if(lpdwMode) {
285 ret = OSLibSetNamedPipeState(pHMHandleData->hHMHandle, *lpdwMode);
286 }
287 if(lpcbMaxCollect || lpdwCollectDataTimeout) {
288 dprintf(("WARNING: Not supported -> lpcbMaxCollect & lpdwCollectDataTimeout"));
289 }
290 return ret;
291}
292
293
294BOOL HMDeviceNamedPipeClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
295 LPOVERLAPPED arg2,
296 LPDWORD arg3,
297 BOOL arg4)
298{
299 return (FALSE);
300}
Note: See TracBrowser for help on using the repository browser.