e16b4dbb3585f5f82a38cd522a9928790eafa89e
[openafs.git] / src / WINNT / afsrdr / user / RDRPipe.c
1 /*
2  * Copyright (c) 2008 Secure Endpoints, Inc.
3  * Copyright (c) 2009-2011 Your File System, Inc.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * - Redistributions of source code must retain the above copyright notice,
10  *   this list of conditions and the following disclaimer.
11  * - Redistributions in binary form must reproduce the above copyright notice,
12  *   this list of conditions and the following disclaimer in the documentation
13  *   and/or other materials provided with the distribution.
14  * - Neither the name of Secure Endpoints Inc. nor the names of its contributors
15  *   may be used to endorse or promote products derived from this software without
16  *   specific prior written permission from Secure Endpoints, Inc. and
17  *   Your File System, Inc.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
22  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
23  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include <afsconfig.h>
33 #include <afs/param.h>
34 #include <ntstatus.h>
35 #define WIN32_NO_STATUS
36 #include <roken.h>
37
38 #include <afs/stds.h>
39
40 #include <windows.h>
41 #include <stdlib.h>
42 #include <malloc.h>
43 #include <string.h>
44 #include <stdio.h>
45 #include <time.h>
46 #include <strsafe.h>
47
48 #include <osi.h>
49
50 #include "afsd.h"
51
52 #include "cm_rpc.h"
53 #include "afs/afsrpc.h"
54 #include "afs/auth.h"
55
56 #include "msrpc.h"
57 #define RDR_PIPE_PRIVATE
58 #include "RDRPipe.h"
59 #include "smb.h"
60 #include "cm_nls.h"
61
62 static RDR_pipe_t * RDR_allPipes = NULL, *RDR_allPipesLast = NULL;
63 static osi_rwlock_t  RDR_globalPipeLock;
64 static wchar_t       RDR_UNCName[64]=L"AFS";
65
66 void
67 RDR_InitPipe(void)
68 {
69     lock_InitializeRWLock(&RDR_globalPipeLock, "RDR global pipe lock", LOCK_HIERARCHY_RDR_GLOBAL);
70 }
71
72 RDR_pipe_t *
73 RDR_FindPipe(ULONG index, int locked)
74 {
75     RDR_pipe_t *pipep;
76
77     if ( !locked)
78         lock_ObtainRead(&RDR_globalPipeLock);
79     for ( pipep=RDR_allPipes; pipep; pipep=pipep->next) {
80         if (pipep->index == index)
81             break;
82     }
83     if ( !locked)
84         lock_ReleaseRead(&RDR_globalPipeLock);
85     return pipep;
86 }
87
88 /* called to make a fid structure into an Pipe fid structure */
89 DWORD
90 RDR_SetupPipe( ULONG index, cm_fid_t *parentFid, cm_fid_t *rootFid,
91                WCHAR     *Name, DWORD      NameLength,
92                cm_user_t *userp)
93 {
94     RDR_pipe_t *pipep;
95     cm_req_t req;
96     DWORD status;
97     char name[MAX_PATH];
98
99     cm_InitReq(&req);
100
101     lock_ObtainWrite(&RDR_globalPipeLock);
102     pipep = RDR_FindPipe(index, TRUE);
103
104     if (pipep) {
105         /* we are reusing a previous pipe */
106         if (cm_FidCmp(&pipep->parentFid, parentFid)) {
107             pipep->parentFid = *parentFid;
108             if (pipep->parentScp) {
109                 cm_ReleaseSCache(pipep->parentScp);
110                 pipep->parentScp = NULL;
111             }
112             cm_GetSCache(parentFid, NULL, &pipep->parentScp, userp, &req);
113             pipep->rootFid = *rootFid;
114         }
115     } else {
116         /* need to allocate a new one */
117         pipep = malloc(sizeof(*pipep));
118         if (pipep == NULL) {
119             status = STATUS_NO_MEMORY;
120             goto done;
121         }
122         memset(pipep, 0, sizeof(*pipep));
123         if (RDR_allPipes == NULL)
124             RDR_allPipes = RDR_allPipesLast = pipep;
125         else {
126             pipep->prev = RDR_allPipesLast;
127             RDR_allPipesLast->next = pipep;
128             RDR_allPipesLast = pipep;
129         }
130         pipep->index = index;
131         if (parentFid->cell == 0) {
132             pipep->parentFid = cm_data.rootFid;
133             pipep->parentScp = cm_RootSCachep(userp, &req);
134             cm_HoldSCache(pipep->parentScp);
135         } else {
136             pipep->parentFid = *parentFid;
137             cm_GetSCache(parentFid, NULL, &pipep->parentScp, userp, &req);
138         }
139         if (rootFid->cell == 0) {
140             pipep->rootFid = cm_data.rootFid;
141         } else {
142             pipep->rootFid = *rootFid;
143         }
144     }
145
146     StringCbCopyNW( pipep->name, sizeof(pipep->name), Name, NameLength);
147     cm_Utf16ToUtf8( pipep->name, -1, name, sizeof(name));
148
149     status = MSRPC_InitConn(&pipep->rpc_conn, name);
150     if (status == STATUS_SUCCESS) {
151         pipep->flags |= RDR_PIPEFLAG_MESSAGE_MODE;
152         pipep->devstate = RDR_DEVICESTATE_READMSGFROMPIPE |
153                           RDR_DEVICESTATE_MESSAGEMODEPIPE |
154                           RDR_DEVICESTATE_PIPECLIENTEND;
155     }
156
157   done:
158     lock_ReleaseWrite(&RDR_globalPipeLock);
159
160     return status;
161 }
162
163
164 void
165 RDR_CleanupPipe(ULONG index)
166 {
167     RDR_pipe_t *pipep;
168
169     lock_ObtainWrite(&RDR_globalPipeLock);
170     pipep = RDR_FindPipe(index, TRUE);
171
172     if (pipep) {
173         if (pipep->parentScp)
174             cm_ReleaseSCache(pipep->parentScp);
175
176         if (pipep->inAllocp)
177             free(pipep->inAllocp);
178         if (pipep->outAllocp)
179             free(pipep->outAllocp);
180
181         MSRPC_FreeConn(&pipep->rpc_conn);
182
183         if (RDR_allPipes == RDR_allPipesLast)
184             RDR_allPipes = RDR_allPipesLast = NULL;
185         else {
186             if (pipep->prev == NULL)
187                 RDR_allPipes = pipep->next;
188             else
189                 pipep->prev->next = pipep->next;
190             if (pipep->next == NULL) {
191                 RDR_allPipesLast = pipep->prev;
192                 pipep->prev->next = NULL;
193             } else
194                 pipep->next->prev = pipep->prev;
195         }
196         free(pipep);
197     }
198     lock_ReleaseWrite(&RDR_globalPipeLock);
199
200 }
201
202 DWORD
203 RDR_Pipe_Read(ULONG index, ULONG BufferLength, void *MappedBuffer,
204               ULONG *pBytesProcessed, cm_req_t *reqp, cm_user_t *userp)
205 {
206     RDR_pipe_t *pipep;
207     DWORD   code = STATUS_INVALID_PIPE_STATE;
208
209     lock_ObtainWrite(&RDR_globalPipeLock);
210     pipep = RDR_FindPipe(index, TRUE);
211
212     if (pipep) {
213         code = MSRPC_PrepareRead(&pipep->rpc_conn);
214         if (code == 0) {
215             *pBytesProcessed = MSRPC_ReadMessageLength(&pipep->rpc_conn, BufferLength);
216             code = MSRPC_ReadMessage(&pipep->rpc_conn, MappedBuffer, *pBytesProcessed);
217         }
218
219     }
220     lock_ReleaseWrite(&RDR_globalPipeLock);
221
222     return code;
223 }
224
225 DWORD
226 RDR_Pipe_Write( ULONG index, ULONG BufferLength, void *MappedBuffer,
227                 cm_req_t *reqp, cm_user_t *userp)
228 {
229     RDR_pipe_t *pipep;
230     DWORD   code = STATUS_INVALID_PIPE_STATE;
231
232     lock_ObtainWrite(&RDR_globalPipeLock);
233     pipep = RDR_FindPipe(index, TRUE);
234
235     if (pipep) {
236         code = MSRPC_WriteMessage( &pipep->rpc_conn, MappedBuffer,
237                                    BufferLength, userp);
238     }
239     lock_ReleaseWrite(&RDR_globalPipeLock);
240
241     return code;
242 }
243
244 DWORD
245 RDR_Pipe_QueryInfo( ULONG index, ULONG InfoClass,
246                     ULONG BufferLength, void *MappedBuffer,
247                     ULONG *pBytesProcessed, cm_req_t *reqp, cm_user_t *userp)
248 {
249     RDR_pipe_t *pipep;
250     DWORD   code = STATUS_INVALID_PIPE_STATE;
251     size_t      length;
252
253     lock_ObtainWrite(&RDR_globalPipeLock);
254     pipep = RDR_FindPipe(index, TRUE);
255
256     if (pipep) {
257         switch ( InfoClass ) {
258         case FileBasicInformation: {
259             FILE_BASIC_INFORMATION * fbInfo = (FILE_BASIC_INFORMATION *)MappedBuffer;
260
261             memset(fbInfo, 0, sizeof(FILE_BASIC_INFORMATION));
262             fbInfo->FileAttributes = FILE_ATTRIBUTE_NORMAL;
263             *pBytesProcessed = (DWORD)(sizeof(FILE_BASIC_INFORMATION));
264             code = STATUS_SUCCESS;
265             break;
266         }
267         case FileStandardInformation: {
268             FILE_STANDARD_INFORMATION * fsInfo = (FILE_STANDARD_INFORMATION *)MappedBuffer;
269
270             memset(fsInfo, 0, sizeof(FILE_STANDARD_INFORMATION));
271             *pBytesProcessed = (DWORD)(sizeof(FILE_STANDARD_INFORMATION));
272             code = STATUS_SUCCESS;
273             break;
274         }
275         case FileNameInformation: {
276             FILE_NAME_INFORMATION * fnInfo = (FILE_NAME_INFORMATION *)MappedBuffer;
277
278             StringCbLengthW(pipep->name, sizeof(pipep->name), &length);
279             if (BufferLength < sizeof(FILE_NAME_INFORMATION) + length) {
280                 code = STATUS_BUFFER_OVERFLOW;
281                 goto done;
282             }
283             fnInfo->FileNameLength = (DWORD)length;
284             memcpy( fnInfo->FileName, pipep->name, length);
285             *pBytesProcessed = (DWORD)(sizeof(DWORD) + length);
286             code = STATUS_SUCCESS;
287             break;
288         }
289         default:
290             code = STATUS_NOT_SUPPORTED;
291         }
292     }
293
294   done:
295     lock_ReleaseWrite(&RDR_globalPipeLock);
296
297     if (code)
298         *pBytesProcessed = 0;
299
300     return code;
301 }
302
303 DWORD
304 RDR_Pipe_SetInfo( ULONG index, ULONG InfoClass,
305                   ULONG BufferLength, void *MappedBuffer,
306                   cm_req_t *reqp, cm_user_t *userp)
307 {
308     RDR_pipe_t *pipep;
309     DWORD   code = STATUS_INVALID_PIPE_STATE;
310
311     lock_ObtainWrite(&RDR_globalPipeLock);
312     pipep = RDR_FindPipe(index, TRUE);
313
314     if (pipep) {
315         switch ( InfoClass ) {
316         case FilePipeInformation: {
317             FILE_PIPE_INFORMATION * fpInfo = (FILE_PIPE_INFORMATION *)MappedBuffer;
318
319             if (BufferLength != sizeof(FILE_PIPE_INFORMATION)) {
320                 code = STATUS_INFO_LENGTH_MISMATCH;
321                 goto done;
322             }
323
324             switch ( fpInfo->ReadMode ) {
325             case FILE_PIPE_BYTE_STREAM_MODE:
326                 pipep->flags &= ~RDR_PIPEFLAG_MESSAGE_MODE;
327                 break;
328             case FILE_PIPE_MESSAGE_MODE:
329                 pipep->flags |= RDR_PIPEFLAG_MESSAGE_MODE;
330                 break;
331             }
332             switch ( fpInfo->CompletionMode ) {
333             case FILE_PIPE_QUEUE_OPERATION:
334                 pipep->flags |= RDR_PIPEFLAG_BLOCKING;
335                 break;
336             case FILE_PIPE_COMPLETE_OPERATION:
337                 pipep->flags &= ~RDR_PIPEFLAG_BLOCKING;
338                 break;
339             }
340             code = STATUS_SUCCESS;
341             break;
342         }
343         default:
344             code = STATUS_NOT_SUPPORTED;
345         }
346     }
347   done:
348     lock_ReleaseWrite(&RDR_globalPipeLock);
349
350     return code;
351 }