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

Last change on this file since 7434 was 7293, checked in by sandervl, 24 years ago

CreateFile for named pipes fix
File size: 11.8 KB
Line 
1/* $Id: hmnpipe.cpp,v 1.3 2001-11-07 15:35:37 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 <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 (LPCSTR lpFileName,
131 PHMHANDLEDATA pHMHandleData,
132 PVOID lpSecurityAttributes,
133 PHMHANDLEDATA pHMHandleDataTemplate)
134{
135 pHMHandleData->hHMHandle = OSLibDosOpenPipe(lpFileName,
136 pHMHandleData->dwAccess,
137 pHMHandleData->dwShare,
138 (LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
139 pHMHandleData->dwCreation,
140 pHMHandleData->dwFlags);
141 if(pHMHandleData->hHMHandle == -1) {
142 return GetLastError();
143 }
144 return ERROR_SUCCESS;
145}
146
147/*****************************************************************************
148 * Name : DWORD HMDeviceNamedPipeClass::CloseHandle
149 * Purpose : close the handle
150 * Parameters: PHMHANDLEDATA pHMHandleData
151 * Variables :
152 * Result : API returncode
153 * Remark :
154 * Status :
155 *
156 * Author : SvL
157 *****************************************************************************/
158
159BOOL HMDeviceNamedPipeClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
160{
161 dprintf(("KERNEL32: HMDeviceNamedPipeClass::CloseHandle(%08x)", pHMHandleData->hHMHandle));
162
163 return OSLibDosClose(pHMHandleData->hHMHandle);
164}
165//******************************************************************************
166//******************************************************************************
167BOOL HMDeviceNamedPipeClass::CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
168 PHMHANDLEDATA pHMHandleDataWrite,
169 LPSECURITY_ATTRIBUTES lpsa,
170 DWORD cbPipe)
171{
172 pHMHandleDataRead->dwInternalType = HMTYPE_PIPE;
173 pHMHandleDataWrite->dwInternalType = HMTYPE_PIPE;
174
175 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::CreatePipe"));
176
177 if(!OSLibDosCreatePipe(&pHMHandleDataRead->hHMHandle,
178 &pHMHandleDataWrite->hHMHandle,
179 lpsa,
180 cbPipe))
181 return TRUE;
182 else
183 return(FALSE);
184}
185
186
187//******************************************************************************
188//******************************************************************************
189BOOL HMDeviceNamedPipeClass::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
190 LPOVERLAPPED lpOverlapped)
191{
192 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::ConnectNamedPipe %s(%08x) [%08x]\n",
193 lpHMDeviceName, pHMHandleData,lpOverlapped));
194
195 return OSLibDosConnectNamedPipe(pHMHandleData->hHMHandle,lpOverlapped);
196}
197
198//******************************************************************************
199//******************************************************************************
200BOOL HMDeviceNamedPipeClass::DisconnectNamedPipe(PHMHANDLEDATA pHMHandleData)
201{
202 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::DisconnectNamedPipe %s(%08x)\n",
203 lpHMDeviceName, pHMHandleData));
204
205 return OSLibDosDisconnectNamedPipe(pHMHandleData->hHMHandle);
206}
207
208//******************************************************************************
209//******************************************************************************
210BOOL HMDeviceNamedPipeClass::GetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
211 LPDWORD lpState,
212 LPDWORD lpCurInstances,
213 LPDWORD lpMaxCollectionCount,
214 LPDWORD lpCollectDataTimeout,
215 LPTSTR lpUserName,
216 DWORD nMaxUserNameSize)
217{
218 dprintf(("KERNEL32: HMDeviceNamedPipeClass::GetNamedPipeHandleStateA (%s) (%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) NIY\n",
219 lpHMDeviceName,
220 lpState,
221 lpCurInstances,
222 lpMaxCollectionCount,
223 lpCollectDataTimeout,
224 lpUserName,
225 nMaxUserNameSize));
226
227 return (FALSE);
228}
229
230//******************************************************************************
231//******************************************************************************
232BOOL HMDeviceNamedPipeClass::GetNamedPipeInfo(PHMHANDLEDATA pHMHandleData,
233 LPDWORD lpFlags,
234 LPDWORD lpOutBufferSize,
235 LPDWORD lpInBufferSize,
236 LPDWORD lpMaxInstances)
237{
238
239 dprintf(("KERNEL32: HMDeviceNamedPipeClass::GetNamedPipeInfo (%s) (%08xh,%08xh,%08xh,%08xh) NIY\n",
240 lpHMDeviceName,
241 lpFlags,
242 lpOutBufferSize,
243 lpInBufferSize,
244 lpMaxInstances));
245
246 return (FALSE);
247}
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
272BOOL HMDeviceNamedPipeClass::SetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
273 LPDWORD lpdwMode,
274 LPDWORD lpcbMaxCollect,
275 LPDWORD lpdwCollectDataTimeout)
276{
277 BOOL ret;
278
279 dprintf(("KERNEL32: HMDeviceNamedPipeClass::SetNamedPipeInfo (%s) (%08xh,%08xh,%08xh)",
280 lpdwMode,lpcbMaxCollect,lpdwCollectDataTimeout));
281
282 if(lpdwMode) {
283 ret = OSLibSetNamedPipeState(pHMHandleData->hHMHandle, *lpdwMode);
284 }
285 if(lpcbMaxCollect || lpdwCollectDataTimeout) {
286 dprintf(("WARNING: Not supported -> lpcbMaxCollect & lpdwCollectDataTimeout"));
287 }
288 return ret;
289}
290
291
292BOOL HMDeviceNamedPipeClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
293 LPOVERLAPPED arg2,
294 LPDWORD arg3,
295 BOOL arg4)
296{
297 return (FALSE);
298}
Note: See TracBrowser for help on using the repository browser.