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

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

disk fix
File size: 11.9 KB
Line 
1/* $Id: hmnpipe.cpp,v 1.6 2001-11-29 13:38:51 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 (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 return GetLastError();
144 }
145 return ERROR_SUCCESS;
146}
147
148/*****************************************************************************
149 * Name : DWORD HMDeviceNamedPipeClass::CloseHandle
150 * Purpose : close the handle
151 * Parameters: PHMHANDLEDATA pHMHandleData
152 * Variables :
153 * Result : API returncode
154 * Remark :
155 * Status :
156 *
157 * Author : SvL
158 *****************************************************************************/
159
160BOOL HMDeviceNamedPipeClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
161{
162 dprintf(("KERNEL32: HMDeviceNamedPipeClass::CloseHandle(%08x)", pHMHandleData->hHMHandle));
163
164 return OSLibDosClose(pHMHandleData->hHMHandle);
165}
166//******************************************************************************
167//******************************************************************************
168BOOL HMDeviceNamedPipeClass::CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
169 PHMHANDLEDATA pHMHandleDataWrite,
170 LPSECURITY_ATTRIBUTES lpsa,
171 DWORD cbPipe)
172{
173 pHMHandleDataRead->dwInternalType = HMTYPE_PIPE;
174 pHMHandleDataWrite->dwInternalType = HMTYPE_PIPE;
175
176 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::CreatePipe"));
177
178 if(!OSLibDosCreatePipe(&pHMHandleDataRead->hHMHandle,
179 &pHMHandleDataWrite->hHMHandle,
180 lpsa,
181 cbPipe))
182 return TRUE;
183 else
184 return(FALSE);
185}
186
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//******************************************************************************
251//******************************************************************************
252DWORD HMDeviceNamedPipeClass::TransactNamedPipe(PHMHANDLEDATA pHMHandleData,
253 LPVOID lpvWriteBuf,
254 DWORD cbWriteBuf,
255 LPVOID lpvReadBuf,
256 DWORD cbReadBuf,
257 LPDWORD lpcbRead,
258 LPOVERLAPPED lpo)
259{
260
261 dprintfl(("KERNEL32: HMDeviceNamedPipeClass::TransactNamedPipe %s(%08x) - [%08x,%08x,%08x,%08x,%08x,%08x]\n",
262 lpHMDeviceName, pHMHandleData,lpvWriteBuf,cbWriteBuf,lpvReadBuf,cbReadBuf,lpcbRead,lpo));
263
264 return(OSLibDosTransactNamedPipe( pHMHandleData->hHMHandle,
265 lpvWriteBuf,
266 cbWriteBuf,
267 lpvReadBuf,
268 cbReadBuf,
269 lpcbRead,
270 lpo));
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}
Note: See TracBrowser for help on using the repository browser.