?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rpcrt4: Fix a typo in rpcrt4_conn_tcp_read.
[wine/multimedia.git] / dlls / rpcrt4 / rpc_transport.c
blobe4d12c334650ed9be8513639b78e87d7e13da72a
1 /*
2 * RPC transport layer
3 *
4 * Copyright 2001 Ove Kåven, TransGaming Technologies
5 * Copyright 2003 Mike Hearn
6 * Copyright 2004 Filip Navara
7 * Copyright 2006 Mike McCormack
8 * Copyright 2006 Damjan Jovanovic
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 *
24 */
25
26 #include "config.h"
27
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <assert.h>
32 #include <errno.h>
33
34 #ifdef HAVE_UNISTD_H
35 # include <unistd.h>
36 #endif
37 #include <fcntl.h>
38 #include <stdlib.h>
39 #include <sys/types.h>
40 #ifdef HAVE_SYS_SOCKET_H
41 # include <sys/socket.h>
42 #endif
43 #ifdef HAVE_NETINET_IN_H
44 # include <netinet/in.h>
45 #endif
46 #ifdef HAVE_NETINET_TCP_H
47 # include <netinet/tcp.h>
48 #endif
49 #ifdef HAVE_ARPA_INET_H
50 # include <arpa/inet.h>
51 #endif
52 #ifdef HAVE_NETDB_H
53 #include <netdb.h>
54 #endif
55 #ifdef HAVE_SYS_POLL_H
56 #include <sys/poll.h>
57 #endif
58
59 #include "windef.h"
60 #include "winbase.h"
61 #include "winnls.h"
62 #include "winerror.h"
63 #include "winternl.h"
64 #include "wine/unicode.h"
65
66 #include "rpc.h"
67 #include "rpcndr.h"
68
69 #include "wine/debug.h"
70
71 #include "rpc_binding.h"
72 #include "rpc_message.h"
73 #include "rpc_server.h"
74 #include "epm_towers.h"
75
76 #ifndef SOL_TCP
77 # define SOL_TCP IPPROTO_TCP
78 #endif
79
80 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
81
82 static CRITICAL_SECTION assoc_list_cs;
83 static CRITICAL_SECTION_DEBUG assoc_list_cs_debug =
84 {
85 0, 0, &assoc_list_cs,
86 { &assoc_list_cs_debug.ProcessLocksList, &assoc_list_cs_debug.ProcessLocksList },
87 0, 0, { (DWORD_PTR)(__FILE__ ": assoc_list_cs") }
88 };
89 static CRITICAL_SECTION assoc_list_cs = { &assoc_list_cs_debug, -1, 0, 0, 0, 0 };
90
91 static struct list assoc_list = LIST_INIT(assoc_list);
92
93 /**** ncacn_np support ****/
94
95 typedef struct _RpcConnection_np
96 {
97 RpcConnection common;
98 HANDLE pipe;
99 OVERLAPPED ovl;
100 BOOL listening;
101 } RpcConnection_np;
102
103 static RpcConnection *rpcrt4_conn_np_alloc(void)
104 {
105 RpcConnection_np *npc = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_np));
106 if (npc)
107 {
108 npc->pipe = NULL;
109 memset(&npc->ovl, 0, sizeof(npc->ovl));
110 npc->listening = FALSE;
111 }
112 return &npc->common;
113 }
114
115 static RPC_STATUS rpcrt4_conn_listen_pipe(RpcConnection_np *npc)
116 {
117 if (npc->listening)
118 return RPC_S_OK;
119
120 npc->listening = TRUE;
121 if (ConnectNamedPipe(npc->pipe, &npc->ovl))
122 return RPC_S_OK;
123
124 if (GetLastError() == ERROR_PIPE_CONNECTED) {
125 SetEvent(npc->ovl.hEvent);
126 return RPC_S_OK;
127 }
128 if (GetLastError() == ERROR_IO_PENDING) {
129 /* will be completed in rpcrt4_protseq_np_wait_for_new_connection */
130 return RPC_S_OK;
131 }
132 npc->listening = FALSE;
133 WARN("Couldn't ConnectNamedPipe (error was %d)\n", GetLastError());
134 return RPC_S_OUT_OF_RESOURCES;
135 }
136
137 static RPC_STATUS rpcrt4_conn_create_pipe(RpcConnection *Connection, LPCSTR pname)
138 {
139 RpcConnection_np *npc = (RpcConnection_np *) Connection;
140 TRACE("listening on %s\n", pname);
141
142 npc->pipe = CreateNamedPipeA(pname, PIPE_ACCESS_DUPLEX,
143 PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
144 PIPE_UNLIMITED_INSTANCES,
145 RPC_MAX_PACKET_SIZE, RPC_MAX_PACKET_SIZE, 5000, NULL);
146 if (npc->pipe == INVALID_HANDLE_VALUE) {
147 WARN("CreateNamedPipe failed with error %d\n", GetLastError());
148 if (GetLastError() == ERROR_FILE_EXISTS)
149 return RPC_S_DUPLICATE_ENDPOINT;
150 else
151 return RPC_S_CANT_CREATE_ENDPOINT;
152 }
153
154 memset(&npc->ovl, 0, sizeof(npc->ovl));
155 npc->ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
156
157 /* Note: we don't call ConnectNamedPipe here because it must be done in the
158 * server thread as the thread must be alertable */
159 return RPC_S_OK;
160 }
161
162 static RPC_STATUS rpcrt4_conn_open_pipe(RpcConnection *Connection, LPCSTR pname, BOOL wait)
163 {
164 RpcConnection_np *npc = (RpcConnection_np *) Connection;
165 HANDLE pipe;
166 DWORD err, dwMode;
167
168 TRACE("connecting to %s\n", pname);
169
170 while (TRUE) {
171 DWORD dwFlags = 0;
172 if (Connection->QOS)
173 {
174 dwFlags = SECURITY_SQOS_PRESENT;
175 switch (Connection->QOS->qos->ImpersonationType)
176 {
177 case RPC_C_IMP_LEVEL_DEFAULT:
178 /* FIXME: what to do here? */
179 break;
180 case RPC_C_IMP_LEVEL_ANONYMOUS:
181 dwFlags |= SECURITY_ANONYMOUS;
182 break;
183 case RPC_C_IMP_LEVEL_IDENTIFY:
184 dwFlags |= SECURITY_IDENTIFICATION;
185 break;
186 case RPC_C_IMP_LEVEL_IMPERSONATE:
187 dwFlags |= SECURITY_IMPERSONATION;
188 break;
189 case RPC_C_IMP_LEVEL_DELEGATE:
190 dwFlags |= SECURITY_DELEGATION;
191 break;
192 }
193 if (Connection->QOS->qos->IdentityTracking == RPC_C_QOS_IDENTIFY_DYNAMIC)
194 dwFlags |= SECURITY_CONTEXT_TRACKING;
195 }
196 pipe = CreateFileA(pname, GENERIC_READ|GENERIC_WRITE, 0, NULL,
197 OPEN_EXISTING, dwFlags, 0);
198 if (pipe != INVALID_HANDLE_VALUE) break;
199 err = GetLastError();
200 if (err == ERROR_PIPE_BUSY) {
201 TRACE("connection failed, error=%x\n", err);
202 return RPC_S_SERVER_TOO_BUSY;
203 }
204 if (!wait)
205 return RPC_S_SERVER_UNAVAILABLE;
206 if (!WaitNamedPipeA(pname, NMPWAIT_WAIT_FOREVER)) {
207 err = GetLastError();
208 WARN("connection failed, error=%x\n", err);
209 return RPC_S_SERVER_UNAVAILABLE;
210 }
211 }
212
213 /* success */
214 memset(&npc->ovl, 0, sizeof(npc->ovl));
215 /* pipe is connected; change to message-read mode. */
216 dwMode = PIPE_READMODE_MESSAGE;
217 SetNamedPipeHandleState(pipe, &dwMode, NULL, NULL);
218 npc->ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
219 npc->pipe = pipe;
220
221 return RPC_S_OK;
222 }
223
224 static RPC_STATUS rpcrt4_ncalrpc_open(RpcConnection* Connection)
225 {
226 RpcConnection_np *npc = (RpcConnection_np *) Connection;
227 static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
228 RPC_STATUS r;
229 LPSTR pname;
230
231 /* already connected? */
232 if (npc->pipe)
233 return RPC_S_OK;
234
235 /* protseq=ncalrpc: supposed to use NT LPC ports,
236 * but we'll implement it with named pipes for now */
237 pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
238 strcat(strcpy(pname, prefix), Connection->Endpoint);
239 r = rpcrt4_conn_open_pipe(Connection, pname, TRUE);
240 I_RpcFree(pname);
241
242 return r;
243 }
244
245 static RPC_STATUS rpcrt4_protseq_ncalrpc_open_endpoint(RpcServerProtseq* protseq, LPSTR endpoint)
246 {
247 static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
248 RPC_STATUS r;
249 LPSTR pname;
250 RpcConnection *Connection;
251
252 r = RPCRT4_CreateConnection(&Connection, TRUE, protseq->Protseq, NULL,
253 endpoint, NULL, NULL, NULL);
254 if (r != RPC_S_OK)
255 return r;
256
257 /* protseq=ncalrpc: supposed to use NT LPC ports,
258 * but we'll implement it with named pipes for now */
259 pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
260 strcat(strcpy(pname, prefix), Connection->Endpoint);
261 r = rpcrt4_conn_create_pipe(Connection, pname);
262 I_RpcFree(pname);
263
264 EnterCriticalSection(&protseq->cs);
265 Connection->Next = protseq->conn;
266 protseq->conn = Connection;
267 LeaveCriticalSection(&protseq->cs);
268
269 return r;
270 }
271
272 static RPC_STATUS rpcrt4_ncacn_np_open(RpcConnection* Connection)
273 {
274 RpcConnection_np *npc = (RpcConnection_np *) Connection;
275 static const char prefix[] = "\\\\.";
276 RPC_STATUS r;
277 LPSTR pname;
278
279 /* already connected? */
280 if (npc->pipe)
281 return RPC_S_OK;
282
283 /* protseq=ncacn_np: named pipes */
284 pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
285 strcat(strcpy(pname, prefix), Connection->Endpoint);
286 r = rpcrt4_conn_open_pipe(Connection, pname, FALSE);
287 I_RpcFree(pname);
288
289 return r;
290 }
291
292 static RPC_STATUS rpcrt4_protseq_ncacn_np_open_endpoint(RpcServerProtseq *protseq, LPSTR endpoint)
293 {
294 static const char prefix[] = "\\\\.";
295 RPC_STATUS r;
296 LPSTR pname;
297 RpcConnection *Connection;
298
299 r = RPCRT4_CreateConnection(&Connection, TRUE, protseq->Protseq, NULL,
300 endpoint, NULL, NULL, NULL);
301 if (r != RPC_S_OK)
302 return r;
303
304 /* protseq=ncacn_np: named pipes */
305 pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
306 strcat(strcpy(pname, prefix), Connection->Endpoint);
307 r = rpcrt4_conn_create_pipe(Connection, pname);
308 I_RpcFree(pname);
309
310 EnterCriticalSection(&protseq->cs);
311 Connection->Next = protseq->conn;
312 protseq->conn = Connection;
313 LeaveCriticalSection(&protseq->cs);
314
315 return r;
316 }
317
318 static void rpcrt4_conn_np_handoff(RpcConnection_np *old_npc, RpcConnection_np *new_npc)
319 {
320 /* because of the way named pipes work, we'll transfer the connected pipe
321 * to the child, then reopen the server binding to continue listening */
322
323 new_npc->pipe = old_npc->pipe;
324 new_npc->ovl = old_npc->ovl;
325 old_npc->pipe = 0;
326 memset(&old_npc->ovl, 0, sizeof(old_npc->ovl));
327 old_npc->listening = FALSE;
328 }
329
330 static RPC_STATUS rpcrt4_ncacn_np_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
331 {
332 RPC_STATUS status;
333 LPSTR pname;
334 static const char prefix[] = "\\\\.";
335
336 rpcrt4_conn_np_handoff((RpcConnection_np *)old_conn, (RpcConnection_np *)new_conn);
337
338 pname = I_RpcAllocate(strlen(prefix) + strlen(old_conn->Endpoint) + 1);
339 strcat(strcpy(pname, prefix), old_conn->Endpoint);
340 status = rpcrt4_conn_create_pipe(old_conn, pname);
341 I_RpcFree(pname);
342
343 return status;
344 }
345
346 static RPC_STATUS rpcrt4_ncalrpc_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
347 {
348 RPC_STATUS status;
349 LPSTR pname;
350 static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
351
352 TRACE("%s\n", old_conn->Endpoint);
353
354 rpcrt4_conn_np_handoff((RpcConnection_np *)old_conn, (RpcConnection_np *)new_conn);
355
356 pname = I_RpcAllocate(strlen(prefix) + strlen(old_conn->Endpoint) + 1);
357 strcat(strcpy(pname, prefix), old_conn->Endpoint);
358 status = rpcrt4_conn_create_pipe(old_conn, pname);
359 I_RpcFree(pname);
360
361 return status;
362 }
363
364 static int rpcrt4_conn_np_read(RpcConnection *Connection,
365 void *buffer, unsigned int count)
366 {
367 RpcConnection_np *npc = (RpcConnection_np *) Connection;
368 char *buf = buffer;
369 BOOL ret = TRUE;
370 unsigned int bytes_left = count;
371
372 while (bytes_left)
373 {
374 DWORD bytes_read;
375 ret = ReadFile(npc->pipe, buf, bytes_left, &bytes_read, NULL);
376 if (!ret || !bytes_read)
377 break;
378 bytes_left -= bytes_read;
379 buf += bytes_read;
380 }
381 return ret ? count : -1;
382 }
383
384 static int rpcrt4_conn_np_write(RpcConnection *Connection,
385 const void *buffer, unsigned int count)
386 {
387 RpcConnection_np *npc = (RpcConnection_np *) Connection;
388 const char *buf = buffer;
389 BOOL ret = TRUE;
390 unsigned int bytes_left = count;
391
392 while (bytes_left)
393 {
394 DWORD bytes_written;
395 ret = WriteFile(npc->pipe, buf, count, &bytes_written, NULL);
396 if (!ret || !bytes_written)
397 break;
398 bytes_left -= bytes_written;
399 buf += bytes_written;
400 }
401 return ret ? count : -1;
402 }
403
404 static int rpcrt4_conn_np_close(RpcConnection *Connection)
405 {
406 RpcConnection_np *npc = (RpcConnection_np *) Connection;
407 if (npc->pipe) {
408 FlushFileBuffers(npc->pipe);
409 CloseHandle(npc->pipe);
410 npc->pipe = 0;
411 }
412 if (npc->ovl.hEvent) {
413 CloseHandle(npc->ovl.hEvent);
414 npc->ovl.hEvent = 0;
415 }
416 return 0;
417 }
418
419 static void rpcrt4_conn_np_cancel_call(RpcConnection *Connection)
420 {
421 /* FIXME: implement when named pipe writes use overlapped I/O */
422 }
423
424 static size_t rpcrt4_ncacn_np_get_top_of_tower(unsigned char *tower_data,
425 const char *networkaddr,
426 const char *endpoint)
427 {
428 twr_empty_floor_t *smb_floor;
429 twr_empty_floor_t *nb_floor;
430 size_t size;
431 size_t networkaddr_size;
432 size_t endpoint_size;
433
434 TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
435
436 networkaddr_size = strlen(networkaddr) + 1;
437 endpoint_size = strlen(endpoint) + 1;
438 size = sizeof(*smb_floor) + endpoint_size + sizeof(*nb_floor) + networkaddr_size;
439
440 if (!tower_data)
441 return size;
442
443 smb_floor = (twr_empty_floor_t *)tower_data;
444
445 tower_data += sizeof(*smb_floor);
446
447 smb_floor->count_lhs = sizeof(smb_floor->protid);
448 smb_floor->protid = EPM_PROTOCOL_SMB;
449 smb_floor->count_rhs = endpoint_size;
450
451 memcpy(tower_data, endpoint, endpoint_size);
452 tower_data += endpoint_size;
453
454 nb_floor = (twr_empty_floor_t *)tower_data;
455
456 tower_data += sizeof(*nb_floor);
457
458 nb_floor->count_lhs = sizeof(nb_floor->protid);
459 nb_floor->protid = EPM_PROTOCOL_NETBIOS;
460 nb_floor->count_rhs = networkaddr_size;
461
462 memcpy(tower_data, networkaddr, networkaddr_size);
463 tower_data += networkaddr_size;
464
465 return size;
466 }
467
468 static RPC_STATUS rpcrt4_ncacn_np_parse_top_of_tower(const unsigned char *tower_data,
469 size_t tower_size,
470 char **networkaddr,
471 char **endpoint)
472 {
473 const twr_empty_floor_t *smb_floor = (const twr_empty_floor_t *)tower_data;
474 const twr_empty_floor_t *nb_floor;
475
476 TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
477
478 if (tower_size < sizeof(*smb_floor))
479 return EPT_S_NOT_REGISTERED;
480
481 tower_data += sizeof(*smb_floor);
482 tower_size -= sizeof(*smb_floor);
483
484 if ((smb_floor->count_lhs != sizeof(smb_floor->protid)) ||
485 (smb_floor->protid != EPM_PROTOCOL_SMB) ||
486 (smb_floor->count_rhs > tower_size))
487 return EPT_S_NOT_REGISTERED;
488
489 if (endpoint)
490 {
491 *endpoint = I_RpcAllocate(smb_floor->count_rhs);
492 if (!*endpoint)
493 return RPC_S_OUT_OF_RESOURCES;
494 memcpy(*endpoint, tower_data, smb_floor->count_rhs);
495 }
496 tower_data += smb_floor->count_rhs;
497 tower_size -= smb_floor->count_rhs;
498
499 if (tower_size < sizeof(*nb_floor))
500 return EPT_S_NOT_REGISTERED;
501
502 nb_floor = (const twr_empty_floor_t *)tower_data;
503
504 tower_data += sizeof(*nb_floor);
505 tower_size -= sizeof(*nb_floor);
506
507 if ((nb_floor->count_lhs != sizeof(nb_floor->protid)) ||
508 (nb_floor->protid != EPM_PROTOCOL_NETBIOS) ||
509 (nb_floor->count_rhs > tower_size))
510 return EPT_S_NOT_REGISTERED;
511
512 if (networkaddr)
513 {
514 *networkaddr = I_RpcAllocate(nb_floor->count_rhs);
515 if (!*networkaddr)
516 {
517 if (endpoint)
518 {
519 I_RpcFree(*endpoint);
520 *endpoint = NULL;
521 }
522 return RPC_S_OUT_OF_RESOURCES;
523 }
524 memcpy(*networkaddr, tower_data, nb_floor->count_rhs);
525 }
526
527 return RPC_S_OK;
528 }
529
530 typedef struct _RpcServerProtseq_np
531 {
532 RpcServerProtseq common;
533 HANDLE mgr_event;
534 } RpcServerProtseq_np;
535
536 static RpcServerProtseq *rpcrt4_protseq_np_alloc(void)
537 {
538 RpcServerProtseq_np *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps));
539 if (ps)
540 ps->mgr_event = CreateEventW(NULL, FALSE, FALSE, NULL);
541 return &ps->common;
542 }
543
544 static void rpcrt4_protseq_np_signal_state_changed(RpcServerProtseq *protseq)
545 {
546 RpcServerProtseq_np *npps = CONTAINING_RECORD(protseq, RpcServerProtseq_np, common);
547 SetEvent(npps->mgr_event);
548 }
549
550 static void *rpcrt4_protseq_np_get_wait_array(RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
551 {
552 HANDLE *objs = prev_array;
553 RpcConnection_np *conn;
554 RpcServerProtseq_np *npps = CONTAINING_RECORD(protseq, RpcServerProtseq_np, common);
555
556 EnterCriticalSection(&protseq->cs);
557
558 /* open and count connections */
559 *count = 1;
560 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
561 while (conn) {
562 rpcrt4_conn_listen_pipe(conn);
563 if (conn->ovl.hEvent)
564 (*count)++;
565 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
566 }
567
568 /* make array of connections */
569 if (objs)
570 objs = HeapReAlloc(GetProcessHeap(), 0, objs, *count*sizeof(HANDLE));
571 else
572 objs = HeapAlloc(GetProcessHeap(), 0, *count*sizeof(HANDLE));
573 if (!objs)
574 {
575 ERR("couldn't allocate objs\n");
576 LeaveCriticalSection(&protseq->cs);
577 return NULL;
578 }
579
580 objs[0] = npps->mgr_event;
581 *count = 1;
582 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
583 while (conn) {
584 if ((objs[*count] = conn->ovl.hEvent))
585 (*count)++;
586 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
587 }
588 LeaveCriticalSection(&protseq->cs);
589 return objs;
590 }
591
592 static void rpcrt4_protseq_np_free_wait_array(RpcServerProtseq *protseq, void *array)
593 {
594 HeapFree(GetProcessHeap(), 0, array);
595 }
596
597 static int rpcrt4_protseq_np_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array)
598 {
599 HANDLE b_handle;
600 HANDLE *objs = wait_array;
601 DWORD res;
602 RpcConnection *cconn;
603 RpcConnection_np *conn;
604
605 if (!objs)
606 return -1;
607
608 do
609 {
610 /* an alertable wait isn't strictly necessary, but due to our
611 * overlapped I/O implementation in Wine we need to free some memory
612 * by the file user APC being called, even if no completion routine was
613 * specified at the time of starting the async operation */
614 res = WaitForMultipleObjectsEx(count, objs, FALSE, INFINITE, TRUE);
615 } while (res == WAIT_IO_COMPLETION);
616
617 if (res == WAIT_OBJECT_0)
618 return 0;
619 else if (res == WAIT_FAILED)
620 {
621 ERR("wait failed with error %d\n", GetLastError());
622 return -1;
623 }
624 else
625 {
626 b_handle = objs[res - WAIT_OBJECT_0];
627 /* find which connection got a RPC */
628 EnterCriticalSection(&protseq->cs);
629 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
630 while (conn) {
631 if (b_handle == conn->ovl.hEvent) break;
632 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
633 }
634 cconn = NULL;
635 if (conn)
636 RPCRT4_SpawnConnection(&cconn, &conn->common);
637 else
638 ERR("failed to locate connection for handle %p\n", b_handle);
639 LeaveCriticalSection(&protseq->cs);
640 if (cconn)
641 {
642 RPCRT4_new_client(cconn);
643 return 1;
644 }
645 else return -1;
646 }
647 }
648
649 static size_t rpcrt4_ncalrpc_get_top_of_tower(unsigned char *tower_data,
650 const char *networkaddr,
651 const char *endpoint)
652 {
653 twr_empty_floor_t *pipe_floor;
654 size_t size;
655 size_t endpoint_size;
656
657 TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
658
659 endpoint_size = strlen(networkaddr) + 1;
660 size = sizeof(*pipe_floor) + endpoint_size;
661
662 if (!tower_data)
663 return size;
664
665 pipe_floor = (twr_empty_floor_t *)tower_data;
666
667 tower_data += sizeof(*pipe_floor);
668
669 pipe_floor->count_lhs = sizeof(pipe_floor->protid);
670 pipe_floor->protid = EPM_PROTOCOL_SMB;
671 pipe_floor->count_rhs = endpoint_size;
672
673 memcpy(tower_data, endpoint, endpoint_size);
674 tower_data += endpoint_size;
675
676 return size;
677 }
678
679 static RPC_STATUS rpcrt4_ncalrpc_parse_top_of_tower(const unsigned char *tower_data,
680 size_t tower_size,
681 char **networkaddr,
682 char **endpoint)
683 {
684 const twr_empty_floor_t *pipe_floor = (const twr_empty_floor_t *)tower_data;
685
686 TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
687
688 *networkaddr = NULL;
689 *endpoint = NULL;
690
691 if (tower_size < sizeof(*pipe_floor))
692 return EPT_S_NOT_REGISTERED;
693
694 tower_data += sizeof(*pipe_floor);
695 tower_size -= sizeof(*pipe_floor);
696
697 if ((pipe_floor->count_lhs != sizeof(pipe_floor->protid)) ||
698 (pipe_floor->protid != EPM_PROTOCOL_SMB) ||
699 (pipe_floor->count_rhs > tower_size))
700 return EPT_S_NOT_REGISTERED;
701
702 if (endpoint)
703 {
704 *endpoint = I_RpcAllocate(pipe_floor->count_rhs);
705 if (!*endpoint)
706 return RPC_S_OUT_OF_RESOURCES;
707 memcpy(*endpoint, tower_data, pipe_floor->count_rhs);
708 }
709
710 return RPC_S_OK;
711 }
712
713 /**** ncacn_ip_tcp support ****/
714
715 typedef struct _RpcConnection_tcp
716 {
717 RpcConnection common;
718 int sock;
719 int cancel_fds[2];
720 } RpcConnection_tcp;
721
722 static RpcConnection *rpcrt4_conn_tcp_alloc(void)
723 {
724 RpcConnection_tcp *tcpc;
725 tcpc = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_tcp));
726 if (tcpc == NULL)
727 return NULL;
728 tcpc->sock = -1;
729 if (socketpair(PF_UNIX, SOCK_STREAM, 0, tcpc->cancel_fds) < 0)
730 {
731 ERR("socketpair() failed: %s\n", strerror(errno));
732 HeapFree(GetProcessHeap(), 0, tcpc);
733 return NULL;
734 }
735 return &tcpc->common;
736 }
737
738 static RPC_STATUS rpcrt4_ncacn_ip_tcp_open(RpcConnection* Connection)
739 {
740 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
741 int sock;
742 int ret;
743 struct addrinfo *ai;
744 struct addrinfo *ai_cur;
745 struct addrinfo hints;
746
747 TRACE("(%s, %s)\n", Connection->NetworkAddr, Connection->Endpoint);
748
749 if (tcpc->sock != -1)
750 return RPC_S_OK;
751
752 hints.ai_flags = 0;
753 hints.ai_family = PF_UNSPEC;
754 hints.ai_socktype = SOCK_STREAM;
755 hints.ai_protocol = IPPROTO_TCP;
756 hints.ai_addrlen = 0;
757 hints.ai_addr = NULL;
758 hints.ai_canonname = NULL;
759 hints.ai_next = NULL;
760
761 ret = getaddrinfo(Connection->NetworkAddr, Connection->Endpoint, &hints, &ai);
762 if (ret)
763 {
764 ERR("getaddrinfo for %s:%s failed: %s\n", Connection->NetworkAddr,
765 Connection->Endpoint, gai_strerror(ret));
766 return RPC_S_SERVER_UNAVAILABLE;
767 }
768
769 for (ai_cur = ai; ai_cur; ai_cur = ai_cur->ai_next)
770 {
771 int val;
772
773 if (TRACE_ON(rpc))
774 {
775 char host[256];
776 char service[256];
777 getnameinfo(ai_cur->ai_addr, ai_cur->ai_addrlen,
778 host, sizeof(host), service, sizeof(service),
779 NI_NUMERICHOST | NI_NUMERICSERV);
780 TRACE("trying %s:%s\n", host, service);
781 }
782
783 sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol);
784 if (sock == -1)
785 {
786 WARN("socket() failed: %s\n", strerror(errno));
787 continue;
788 }
789
790 if (0>connect(sock, ai_cur->ai_addr, ai_cur->ai_addrlen))
791 {
792 WARN("connect() failed: %s\n", strerror(errno));
793 close(sock);
794 continue;
795 }
796
797 /* RPC depends on having minimal latency so disable the Nagle algorithm */
798 val = 1;
799 setsockopt(sock, SOL_TCP, TCP_NODELAY, &val, sizeof(val));
800 fcntl(sock, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
801
802 tcpc->sock = sock;
803
804 freeaddrinfo(ai);
805 TRACE("connected\n");
806 return RPC_S_OK;
807 }
808
809 freeaddrinfo(ai);
810 ERR("couldn't connect to %s:%s\n", Connection->NetworkAddr, Connection->Endpoint);
811 return RPC_S_SERVER_UNAVAILABLE;
812 }
813
814 static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *protseq, LPSTR endpoint)
815 {
816 RPC_STATUS status = RPC_S_CANT_CREATE_ENDPOINT;
817 int sock;
818 int ret;
819 struct addrinfo *ai;
820 struct addrinfo *ai_cur;
821 struct addrinfo hints;
822 RpcConnection *first_connection = NULL;
823
824 TRACE("(%p, %s)\n", protseq, endpoint);
825
826 hints.ai_flags = AI_PASSIVE /* for non-localhost addresses */;
827 hints.ai_family = PF_UNSPEC;
828 hints.ai_socktype = SOCK_STREAM;
829 hints.ai_protocol = IPPROTO_TCP;
830 hints.ai_addrlen = 0;
831 hints.ai_addr = NULL;
832 hints.ai_canonname = NULL;
833 hints.ai_next = NULL;
834
835 ret = getaddrinfo(NULL, endpoint, &hints, &ai);
836 if (ret)
837 {
838 ERR("getaddrinfo for port %s failed: %s\n", endpoint,
839 gai_strerror(ret));
840 if ((ret == EAI_SERVICE) || (ret == EAI_NONAME))
841 return RPC_S_INVALID_ENDPOINT_FORMAT;
842 return RPC_S_CANT_CREATE_ENDPOINT;
843 }
844
845 for (ai_cur = ai; ai_cur; ai_cur = ai_cur->ai_next)
846 {
847 RpcConnection_tcp *tcpc;
848 RPC_STATUS create_status;
849
850 if (TRACE_ON(rpc))
851 {
852 char host[256];
853 char service[256];
854 getnameinfo(ai_cur->ai_addr, ai_cur->ai_addrlen,
855 host, sizeof(host), service, sizeof(service),
856 NI_NUMERICHOST | NI_NUMERICSERV);
857 TRACE("trying %s:%s\n", host, service);
858 }
859
860 sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol);
861 if (sock == -1)
862 {
863 WARN("socket() failed: %s\n", strerror(errno));
864 status = RPC_S_CANT_CREATE_ENDPOINT;
865 continue;
866 }
867
868 ret = bind(sock, ai_cur->ai_addr, ai_cur->ai_addrlen);
869 if (ret < 0)
870 {
871 WARN("bind failed: %s\n", strerror(errno));
872 close(sock);
873 if (errno == EADDRINUSE)
874 status = RPC_S_DUPLICATE_ENDPOINT;
875 else
876 status = RPC_S_CANT_CREATE_ENDPOINT;
877 continue;
878 }
879 create_status = RPCRT4_CreateConnection((RpcConnection **)&tcpc, TRUE,
880 protseq->Protseq, NULL,
881 endpoint, NULL, NULL, NULL);
882 if (create_status != RPC_S_OK)
883 {
884 close(sock);
885 status = create_status;
886 continue;
887 }
888
889 tcpc->sock = sock;
890 ret = listen(sock, protseq->MaxCalls);
891 if (ret < 0)
892 {
893 WARN("listen failed: %s\n", strerror(errno));
894 RPCRT4_DestroyConnection(&tcpc->common);
895 status = RPC_S_OUT_OF_RESOURCES;
896 continue;
897 }
898 /* need a non-blocking socket, otherwise accept() has a potential
899 * race-condition (poll() says it is readable, connection drops,
900 * and accept() blocks until the next connection comes...)
901 */
902 ret = fcntl(sock, F_SETFL, O_NONBLOCK);
903 if (ret < 0)
904 {
905 WARN("couldn't make socket non-blocking, error %d\n", ret);
906 RPCRT4_DestroyConnection(&tcpc->common);
907 status = RPC_S_OUT_OF_RESOURCES;
908 continue;
909 }
910
911 tcpc->common.Next = first_connection;
912 first_connection = &tcpc->common;
913 }
914
915 freeaddrinfo(ai);
916
917 /* if at least one connection was created for an endpoint then
918 * return success */
919 if (first_connection)
920 {
921 RpcConnection *conn;
922
923 /* find last element in list */
924 for (conn = first_connection; conn->Next; conn = conn->Next)
925 ;
926
927 EnterCriticalSection(&protseq->cs);
928 conn->Next = protseq->conn;
929 protseq->conn = first_connection;
930 LeaveCriticalSection(&protseq->cs);
931
932 TRACE("listening on %s\n", endpoint);
933 return RPC_S_OK;
934 }
935
936 ERR("couldn't listen on port %s\n", endpoint);
937 return status;
938 }
939
940 static RPC_STATUS rpcrt4_conn_tcp_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
941 {
942 int ret;
943 struct sockaddr_in address;
944 socklen_t addrsize;
945 RpcConnection_tcp *server = (RpcConnection_tcp*) old_conn;
946 RpcConnection_tcp *client = (RpcConnection_tcp*) new_conn;
947
948 addrsize = sizeof(address);
949 ret = accept(server->sock, (struct sockaddr*) &address, &addrsize);
950 if (ret < 0)
951 {
952 ERR("Failed to accept a TCP connection: error %d\n", ret);
953 return RPC_S_OUT_OF_RESOURCES;
954 }
955 /* reset to blocking behaviour */
956 fcntl(ret, F_SETFL, 0);
957 client->sock = ret;
958 TRACE("Accepted a new TCP connection\n");
959 return RPC_S_OK;
960 }
961
962 static int rpcrt4_conn_tcp_read(RpcConnection *Connection,
963 void *buffer, unsigned int count)
964 {
965 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
966 int bytes_read = 0;
967 do
968 {
969 int r = recv(tcpc->sock, (char *)buffer + bytes_read, count - bytes_read, 0);
970 if (r >= 0)
971 bytes_read += r;
972 else if (errno != EAGAIN)
973 return -1;
974 else
975 {
976 struct pollfd pfds[2];
977 pfds[0].fd = tcpc->sock;
978 pfds[0].events = POLLIN;
979 pfds[1].fd = tcpc->cancel_fds[0];
980 pfds[1].events = POLLIN;
981 if (poll(pfds, 2, -1 /* infinite */) == -1 && errno != EINTR)
982 {
983 ERR("poll() failed: %s\n", strerror(errno));
984 return -1;
985 }
986 if (pfds[1].revents & POLLIN) /* canceled */
987 {
988 char dummy;
989 read(pfds[1].fd, &dummy, sizeof(dummy));
990 return -1;
991 }
992 }
993 } while (bytes_read != count);
994 TRACE("%d %p %u -> %d\n", tcpc->sock, buffer, count, bytes_read);
995 return bytes_read;
996 }
997
998 static int rpcrt4_conn_tcp_write(RpcConnection *Connection,
999 const void *buffer, unsigned int count)
1000 {
1001 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1002 int bytes_written = 0;
1003 do
1004 {
1005 int r = write(tcpc->sock, (const char *)buffer + bytes_written, count - bytes_written);
1006 if (r >= 0)
1007 bytes_written += r;
1008 else if (errno != EAGAIN)
1009 return -1;
1010 else
1011 {
1012 struct pollfd pfd;
1013 pfd.fd = tcpc->sock;
1014 pfd.events = POLLOUT;
1015 if (poll(&pfd, 1, -1 /* infinite */) == -1 && errno != EINTR)
1016 {
1017 ERR("poll() failed: %s\n", strerror(errno));
1018 return -1;
1019 }
1020 }
1021 } while (bytes_written != count);
1022 TRACE("%d %p %u -> %d\n", tcpc->sock, buffer, count, bytes_written);
1023 return bytes_written;
1024 }
1025
1026 static int rpcrt4_conn_tcp_close(RpcConnection *Connection)
1027 {
1028 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1029
1030 TRACE("%d\n", tcpc->sock);
1031
1032 if (tcpc->sock != -1)
1033 close(tcpc->sock);
1034 tcpc->sock = -1;
1035 close(tcpc->cancel_fds[0]);
1036 close(tcpc->cancel_fds[1]);
1037 return 0;
1038 }
1039
1040 static void rpcrt4_conn_tcp_cancel_call(RpcConnection *Connection)
1041 {
1042 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1043 char dummy = 1;
1044
1045 TRACE("%p\n", Connection);
1046
1047 write(tcpc->cancel_fds[1], &dummy, 1);
1048 }
1049
1050 static size_t rpcrt4_ncacn_ip_tcp_get_top_of_tower(unsigned char *tower_data,
1051 const char *networkaddr,
1052 const char *endpoint)
1053 {
1054 twr_tcp_floor_t *tcp_floor;
1055 twr_ipv4_floor_t *ipv4_floor;
1056 struct addrinfo *ai;
1057 struct addrinfo hints;
1058 int ret;
1059 size_t size = sizeof(*tcp_floor) + sizeof(*ipv4_floor);
1060
1061 TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
1062
1063 if (!tower_data)
1064 return size;
1065
1066 tcp_floor = (twr_tcp_floor_t *)tower_data;
1067 tower_data += sizeof(*tcp_floor);
1068
1069 ipv4_floor = (twr_ipv4_floor_t *)tower_data;
1070
1071 tcp_floor->count_lhs = sizeof(tcp_floor->protid);
1072 tcp_floor->protid = EPM_PROTOCOL_TCP;
1073 tcp_floor->count_rhs = sizeof(tcp_floor->port);
1074
1075 ipv4_floor->count_lhs = sizeof(ipv4_floor->protid);
1076 ipv4_floor->protid = EPM_PROTOCOL_IP;
1077 ipv4_floor->count_rhs = sizeof(ipv4_floor->ipv4addr);
1078
1079 hints.ai_flags = AI_NUMERICHOST;
1080 /* FIXME: only support IPv4 at the moment. how is IPv6 represented by the EPM? */
1081 hints.ai_family = PF_INET;
1082 hints.ai_socktype = SOCK_STREAM;
1083 hints.ai_protocol = IPPROTO_TCP;
1084 hints.ai_addrlen = 0;
1085 hints.ai_addr = NULL;
1086 hints.ai_canonname = NULL;
1087 hints.ai_next = NULL;
1088
1089 ret = getaddrinfo(networkaddr, endpoint, &hints, &ai);
1090 if (ret)
1091 {
1092 ret = getaddrinfo("0.0.0.0", endpoint, &hints, &ai);
1093 if (ret)
1094 {
1095 ERR("getaddrinfo failed: %s\n", gai_strerror(ret));
1096 return 0;
1097 }
1098 }
1099
1100 if (ai->ai_family == PF_INET)
1101 {
1102 const struct sockaddr_in *sin = (const struct sockaddr_in *)ai->ai_addr;
1103 tcp_floor->port = sin->sin_port;
1104 ipv4_floor->ipv4addr = sin->sin_addr.s_addr;
1105 }
1106 else
1107 {
1108 ERR("unexpected protocol family %d\n", ai->ai_family);
1109 return 0;
1110 }
1111
1112 freeaddrinfo(ai);
1113
1114 return size;
1115 }
1116
1117 static RPC_STATUS rpcrt4_ncacn_ip_tcp_parse_top_of_tower(const unsigned char *tower_data,
1118 size_t tower_size,
1119 char **networkaddr,
1120 char **endpoint)
1121 {
1122 const twr_tcp_floor_t *tcp_floor = (const twr_tcp_floor_t *)tower_data;
1123 const twr_ipv4_floor_t *ipv4_floor;
1124 struct in_addr in_addr;
1125
1126 TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
1127
1128 if (tower_size < sizeof(*tcp_floor))
1129 return EPT_S_NOT_REGISTERED;
1130
1131 tower_data += sizeof(*tcp_floor);
1132 tower_size -= sizeof(*tcp_floor);
1133
1134 if (tower_size < sizeof(*ipv4_floor))
1135 return EPT_S_NOT_REGISTERED;
1136
1137 ipv4_floor = (const twr_ipv4_floor_t *)tower_data;
1138
1139 if ((tcp_floor->count_lhs != sizeof(tcp_floor->protid)) ||
1140 (tcp_floor->protid != EPM_PROTOCOL_TCP) ||
1141 (tcp_floor->count_rhs != sizeof(tcp_floor->port)) ||
1142 (ipv4_floor->count_lhs != sizeof(ipv4_floor->protid)) ||
1143 (ipv4_floor->protid != EPM_PROTOCOL_IP) ||
1144 (ipv4_floor->count_rhs != sizeof(ipv4_floor->ipv4addr)))
1145 return EPT_S_NOT_REGISTERED;
1146
1147 if (endpoint)
1148 {
1149 *endpoint = I_RpcAllocate(6 /* sizeof("65535") + 1 */);
1150 if (!*endpoint)
1151 return RPC_S_OUT_OF_RESOURCES;
1152 sprintf(*endpoint, "%u", ntohs(tcp_floor->port));
1153 }
1154
1155 if (networkaddr)
1156 {
1157 *networkaddr = I_RpcAllocate(INET_ADDRSTRLEN);
1158 if (!*networkaddr)
1159 {
1160 if (endpoint)
1161 {
1162 I_RpcFree(*endpoint);
1163 *endpoint = NULL;
1164 }
1165 return RPC_S_OUT_OF_RESOURCES;
1166 }
1167 in_addr.s_addr = ipv4_floor->ipv4addr;
1168 if (!inet_ntop(AF_INET, &in_addr, *networkaddr, INET_ADDRSTRLEN))
1169 {
1170 ERR("inet_ntop: %s\n", strerror(errno));
1171 I_RpcFree(*networkaddr);
1172 *networkaddr = NULL;
1173 if (endpoint)
1174 {
1175 I_RpcFree(*endpoint);
1176 *endpoint = NULL;
1177 }
1178 return EPT_S_NOT_REGISTERED;
1179 }
1180 }
1181
1182 return RPC_S_OK;
1183 }
1184
1185 typedef struct _RpcServerProtseq_sock
1186 {
1187 RpcServerProtseq common;
1188 int mgr_event_rcv;
1189 int mgr_event_snd;
1190 } RpcServerProtseq_sock;
1191
1192 static RpcServerProtseq *rpcrt4_protseq_sock_alloc(void)
1193 {
1194 RpcServerProtseq_sock *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps));
1195 if (ps)
1196 {
1197 int fds[2];
1198 if (!socketpair(PF_UNIX, SOCK_DGRAM, 0, fds))
1199 {
1200 fcntl(fds[0], F_SETFL, O_NONBLOCK);
1201 fcntl(fds[1], F_SETFL, O_NONBLOCK);
1202 ps->mgr_event_rcv = fds[0];
1203 ps->mgr_event_snd = fds[1];
1204 }
1205 else
1206 {
1207 ERR("socketpair failed with error %s\n", strerror(errno));
1208 HeapFree(GetProcessHeap(), 0, ps);
1209 return NULL;
1210 }
1211 }
1212 return &ps->common;
1213 }
1214
1215 static void rpcrt4_protseq_sock_signal_state_changed(RpcServerProtseq *protseq)
1216 {
1217 RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common);
1218 char dummy = 1;
1219 write(sockps->mgr_event_snd, &dummy, sizeof(dummy));
1220 }
1221
1222 static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
1223 {
1224 struct pollfd *poll_info = prev_array;
1225 RpcConnection_tcp *conn;
1226 RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common);
1227
1228 EnterCriticalSection(&protseq->cs);
1229
1230 /* open and count connections */
1231 *count = 1;
1232 conn = (RpcConnection_tcp *)protseq->conn;
1233 while (conn) {
1234 if (conn->sock != -1)
1235 (*count)++;
1236 conn = (RpcConnection_tcp *)conn->common.Next;
1237 }
1238
1239 /* make array of connections */
1240 if (poll_info)
1241 poll_info = HeapReAlloc(GetProcessHeap(), 0, poll_info, *count*sizeof(*poll_info));
1242 else
1243 poll_info = HeapAlloc(GetProcessHeap(), 0, *count*sizeof(*poll_info));
1244 if (!poll_info)
1245 {
1246 ERR("couldn't allocate poll_info\n");
1247 LeaveCriticalSection(&protseq->cs);
1248 return NULL;
1249 }
1250
1251 poll_info[0].fd = sockps->mgr_event_rcv;
1252 poll_info[0].events = POLLIN;
1253 *count = 1;
1254 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1255 while (conn) {
1256 if (conn->sock != -1)
1257 {
1258 poll_info[*count].fd = conn->sock;
1259 poll_info[*count].events = POLLIN;
1260 (*count)++;
1261 }
1262 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1263 }
1264 LeaveCriticalSection(&protseq->cs);
1265 return poll_info;
1266 }
1267
1268 static void rpcrt4_protseq_sock_free_wait_array(RpcServerProtseq *protseq, void *array)
1269 {
1270 HeapFree(GetProcessHeap(), 0, array);
1271 }
1272
1273 static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array)
1274 {
1275 struct pollfd *poll_info = wait_array;
1276 int ret, i;
1277 RpcConnection *cconn;
1278 RpcConnection_tcp *conn;
1279
1280 if (!poll_info)
1281 return -1;
1282
1283 ret = poll(poll_info, count, -1);
1284 if (ret < 0)
1285 {
1286 ERR("poll failed with error %d\n", ret);
1287 return -1;
1288 }
1289
1290 for (i = 0; i < count; i++)
1291 if (poll_info[i].revents & POLLIN)
1292 {
1293 /* RPC server event */
1294 if (i == 0)
1295 {
1296 char dummy;
1297 read(poll_info[0].fd, &dummy, sizeof(dummy));
1298 return 0;
1299 }
1300
1301 /* find which connection got a RPC */
1302 EnterCriticalSection(&protseq->cs);
1303 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1304 while (conn) {
1305 if (poll_info[i].fd == conn->sock) break;
1306 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1307 }
1308 cconn = NULL;
1309 if (conn)
1310 RPCRT4_SpawnConnection(&cconn, &conn->common);
1311 else
1312 ERR("failed to locate connection for fd %d\n", poll_info[i].fd);
1313 LeaveCriticalSection(&protseq->cs);
1314 if (cconn)
1315 RPCRT4_new_client(cconn);
1316 else
1317 return -1;
1318 }
1319
1320 return 1;
1321 }
1322
1323 static const struct connection_ops conn_protseq_list[] = {
1324 { "ncacn_np",
1325 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_SMB },
1326 rpcrt4_conn_np_alloc,
1327 rpcrt4_ncacn_np_open,
1328 rpcrt4_ncacn_np_handoff,
1329 rpcrt4_conn_np_read,
1330 rpcrt4_conn_np_write,
1331 rpcrt4_conn_np_close,
1332 rpcrt4_conn_np_cancel_call,
1333 rpcrt4_ncacn_np_get_top_of_tower,
1334 rpcrt4_ncacn_np_parse_top_of_tower,
1335 },
1336 { "ncalrpc",
1337 { EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_PIPE },
1338 rpcrt4_conn_np_alloc,
1339 rpcrt4_ncalrpc_open,
1340 rpcrt4_ncalrpc_handoff,
1341 rpcrt4_conn_np_read,
1342 rpcrt4_conn_np_write,
1343 rpcrt4_conn_np_close,
1344 rpcrt4_conn_np_cancel_call,
1345 rpcrt4_ncalrpc_get_top_of_tower,
1346 rpcrt4_ncalrpc_parse_top_of_tower,
1347 },
1348 { "ncacn_ip_tcp",
1349 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_TCP },
1350 rpcrt4_conn_tcp_alloc,
1351 rpcrt4_ncacn_ip_tcp_open,
1352 rpcrt4_conn_tcp_handoff,
1353 rpcrt4_conn_tcp_read,
1354 rpcrt4_conn_tcp_write,
1355 rpcrt4_conn_tcp_close,
1356 rpcrt4_conn_tcp_cancel_call,
1357 rpcrt4_ncacn_ip_tcp_get_top_of_tower,
1358 rpcrt4_ncacn_ip_tcp_parse_top_of_tower,
1359 }
1360 };
1361
1362
1363 static const struct protseq_ops protseq_list[] =
1364 {
1365 {
1366 "ncacn_np",
1367 rpcrt4_protseq_np_alloc,
1368 rpcrt4_protseq_np_signal_state_changed,
1369 rpcrt4_protseq_np_get_wait_array,
1370 rpcrt4_protseq_np_free_wait_array,
1371 rpcrt4_protseq_np_wait_for_new_connection,
1372 rpcrt4_protseq_ncacn_np_open_endpoint,
1373 },
1374 {
1375 "ncalrpc",
1376 rpcrt4_protseq_np_alloc,
1377 rpcrt4_protseq_np_signal_state_changed,
1378 rpcrt4_protseq_np_get_wait_array,
1379 rpcrt4_protseq_np_free_wait_array,
1380 rpcrt4_protseq_np_wait_for_new_connection,
1381 rpcrt4_protseq_ncalrpc_open_endpoint,
1382 },
1383 {
1384 "ncacn_ip_tcp",
1385 rpcrt4_protseq_sock_alloc,
1386 rpcrt4_protseq_sock_signal_state_changed,
1387 rpcrt4_protseq_sock_get_wait_array,
1388 rpcrt4_protseq_sock_free_wait_array,
1389 rpcrt4_protseq_sock_wait_for_new_connection,
1390 rpcrt4_protseq_ncacn_ip_tcp_open_endpoint,
1391 },
1392 };
1393
1394 #define ARRAYSIZE(a) (sizeof((a)) / sizeof((a)[0]))
1395
1396 const struct protseq_ops *rpcrt4_get_protseq_ops(const char *protseq)
1397 {
1398 int i;
1399 for(i=0; i<ARRAYSIZE(protseq_list); i++)
1400 if (!strcmp(protseq_list[i].name, protseq))
1401 return &protseq_list[i];
1402 return NULL;
1403 }
1404
1405 static const struct connection_ops *rpcrt4_get_conn_protseq_ops(const char *protseq)
1406 {
1407 int i;
1408 for(i=0; i<ARRAYSIZE(conn_protseq_list); i++)
1409 if (!strcmp(conn_protseq_list[i].name, protseq))
1410 return &conn_protseq_list[i];
1411 return NULL;
1412 }
1413
1414 /**** interface to rest of code ****/
1415
1416 RPC_STATUS RPCRT4_OpenClientConnection(RpcConnection* Connection)
1417 {
1418 TRACE("(Connection == ^%p)\n", Connection);
1419
1420 assert(!Connection->server);
1421 return Connection->ops->open_connection_client(Connection);
1422 }
1423
1424 RPC_STATUS RPCRT4_CloseConnection(RpcConnection* Connection)
1425 {
1426 TRACE("(Connection == ^%p)\n", Connection);
1427 if (SecIsValidHandle(&Connection->ctx))
1428 {
1429 DeleteSecurityContext(&Connection->ctx);
1430 SecInvalidateHandle(&Connection->ctx);
1431 }
1432 rpcrt4_conn_close(Connection);
1433 return RPC_S_OK;
1434 }
1435
1436 RPC_STATUS RPCRT4_CreateConnection(RpcConnection** Connection, BOOL server,
1437 LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint,
1438 LPCWSTR NetworkOptions, RpcAuthInfo* AuthInfo, RpcQualityOfService *QOS)
1439 {
1440 const struct connection_ops *ops;
1441 RpcConnection* NewConnection;
1442
1443 ops = rpcrt4_get_conn_protseq_ops(Protseq);
1444 if (!ops)
1445 {
1446 FIXME("not supported for protseq %s\n", Protseq);
1447 return RPC_S_PROTSEQ_NOT_SUPPORTED;
1448 }
1449
1450 NewConnection = ops->alloc();
1451 NewConnection->Next = NULL;
1452 NewConnection->server = server;
1453 NewConnection->ops = ops;
1454 NewConnection->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
1455 NewConnection->Endpoint = RPCRT4_strdupA(Endpoint);
1456 NewConnection->NetworkOptions = RPCRT4_strdupW(NetworkOptions);
1457 NewConnection->MaxTransmissionSize = RPC_MAX_PACKET_SIZE;
1458 memset(&NewConnection->ActiveInterface, 0, sizeof(NewConnection->ActiveInterface));
1459 NewConnection->NextCallId = 1;
1460
1461 SecInvalidateHandle(&NewConnection->ctx);
1462 memset(&NewConnection->exp, 0, sizeof(NewConnection->exp));
1463 NewConnection->attr = 0;
1464 if (AuthInfo) RpcAuthInfo_AddRef(AuthInfo);
1465 NewConnection->AuthInfo = AuthInfo;
1466 NewConnection->encryption_auth_len = 0;
1467 NewConnection->signature_auth_len = 0;
1468 if (QOS) RpcQualityOfService_AddRef(QOS);
1469 NewConnection->QOS = QOS;
1470
1471 list_init(&NewConnection->conn_pool_entry);
1472
1473 TRACE("connection: %p\n", NewConnection);
1474 *Connection = NewConnection;
1475
1476 return RPC_S_OK;
1477 }
1478
1479 RPC_STATUS RPCRT4_GetAssociation(LPCSTR Protseq, LPCSTR NetworkAddr,
1480 LPCSTR Endpoint, LPCWSTR NetworkOptions,
1481 RpcAssoc **assoc_out)
1482 {
1483 RpcAssoc *assoc;
1484
1485 EnterCriticalSection(&assoc_list_cs);
1486 LIST_FOR_EACH_ENTRY(assoc, &assoc_list, RpcAssoc, entry)
1487 {
1488 if (!strcmp(Protseq, assoc->Protseq) &&
1489 !strcmp(NetworkAddr, assoc->NetworkAddr) &&
1490 !strcmp(Endpoint, assoc->Endpoint) &&
1491 ((!assoc->NetworkOptions && !NetworkOptions) || !strcmpW(NetworkOptions, assoc->NetworkOptions)))
1492 {
1493 assoc->refs++;
1494 *assoc_out = assoc;
1495 LeaveCriticalSection(&assoc_list_cs);
1496 TRACE("using existing assoc %p\n", assoc);
1497 return RPC_S_OK;
1498 }
1499 }
1500
1501 assoc = HeapAlloc(GetProcessHeap(), 0, sizeof(*assoc));
1502 if (!assoc)
1503 {
1504 LeaveCriticalSection(&assoc_list_cs);
1505 return RPC_S_OUT_OF_RESOURCES;
1506 }
1507 assoc->refs = 1;
1508 list_init(&assoc->connection_pool);
1509 InitializeCriticalSection(&assoc->cs);
1510 assoc->Protseq = RPCRT4_strdupA(Protseq);
1511 assoc->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
1512 assoc->Endpoint = RPCRT4_strdupA(Endpoint);
1513 assoc->NetworkOptions = NetworkOptions ? RPCRT4_strdupW(NetworkOptions) : NULL;
1514 assoc->assoc_group_id = 0;
1515 list_add_head(&assoc_list, &assoc->entry);
1516 *assoc_out = assoc;
1517
1518 LeaveCriticalSection(&assoc_list_cs);
1519
1520 TRACE("new assoc %p\n", assoc);
1521
1522 return RPC_S_OK;
1523 }
1524
1525 ULONG RpcAssoc_Release(RpcAssoc *assoc)
1526 {
1527 ULONG refs;
1528
1529 EnterCriticalSection(&assoc_list_cs);
1530 refs = --assoc->refs;
1531 if (!refs)
1532 list_remove(&assoc->entry);
1533 LeaveCriticalSection(&assoc_list_cs);
1534
1535 if (!refs)
1536 {
1537 RpcConnection *Connection, *cursor2;
1538
1539 TRACE("destroying assoc %p\n", assoc);
1540
1541 LIST_FOR_EACH_ENTRY_SAFE(Connection, cursor2, &assoc->connection_pool, RpcConnection, conn_pool_entry)
1542 {
1543 list_remove(&Connection->conn_pool_entry);
1544 RPCRT4_DestroyConnection(Connection);
1545 }
1546
1547 HeapFree(GetProcessHeap(), 0, assoc->NetworkOptions);
1548 HeapFree(GetProcessHeap(), 0, assoc->Endpoint);
1549 HeapFree(GetProcessHeap(), 0, assoc->NetworkAddr);
1550 HeapFree(GetProcessHeap(), 0, assoc->Protseq);
1551
1552 DeleteCriticalSection(&assoc->cs);
1553
1554 HeapFree(GetProcessHeap(), 0, assoc);
1555 }
1556
1557 return refs;
1558 }
1559
1560 #define ROUND_UP(value, alignment) (((value) + ((alignment) - 1)) & ~((alignment)-1))
1561
1562 static RPC_STATUS RpcAssoc_BindConnection(const RpcAssoc *assoc, RpcConnection *conn,
1563 const RPC_SYNTAX_IDENTIFIER *InterfaceId,
1564 const RPC_SYNTAX_IDENTIFIER *TransferSyntax)
1565 {
1566 RpcPktHdr *hdr;
1567 RpcPktHdr *response_hdr;
1568 RPC_MESSAGE msg;
1569 RPC_STATUS status;
1570
1571 TRACE("sending bind request to server\n");
1572
1573 hdr = RPCRT4_BuildBindHeader(NDR_LOCAL_DATA_REPRESENTATION,
1574 RPC_MAX_PACKET_SIZE, RPC_MAX_PACKET_SIZE,
1575 assoc->assoc_group_id,
1576 InterfaceId, TransferSyntax);
1577
1578 status = RPCRT4_Send(conn, hdr, NULL, 0);
1579 RPCRT4_FreeHeader(hdr);
1580 if (status != RPC_S_OK)
1581 return status;
1582
1583 status = RPCRT4_Receive(conn, &response_hdr, &msg);
1584 if (status != RPC_S_OK)
1585 {
1586 ERR("receive failed\n");
1587 return status;
1588 }
1589
1590 switch (response_hdr->common.ptype)
1591 {
1592 case PKT_BIND_ACK:
1593 {
1594 RpcAddressString *server_address = msg.Buffer;
1595 if ((msg.BufferLength >= FIELD_OFFSET(RpcAddressString, string[0])) ||
1596 (msg.BufferLength >= ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4)))
1597 {
1598 unsigned short remaining = msg.BufferLength -
1599 ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4);
1600 RpcResults *results = (RpcResults*)((ULONG_PTR)server_address +
1601 ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4));
1602 if ((results->num_results == 1) && (remaining >= sizeof(*results)))
1603 {
1604 switch (results->results[0].result)
1605 {
1606 case RESULT_ACCEPT:
1607 conn->assoc_group_id = response_hdr->bind_ack.assoc_gid;
1608 conn->MaxTransmissionSize = response_hdr->bind_ack.max_tsize;
1609 conn->ActiveInterface = *InterfaceId;
1610 break;
1611 case RESULT_PROVIDER_REJECTION:
1612 switch (results->results[0].reason)
1613 {
1614 case REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED:
1615 ERR("syntax %s, %d.%d not supported\n",
1616 debugstr_guid(&InterfaceId->SyntaxGUID),
1617 InterfaceId->SyntaxVersion.MajorVersion,
1618 InterfaceId->SyntaxVersion.MinorVersion);
1619 status = RPC_S_UNKNOWN_IF;
1620 break;
1621 case REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED:
1622 ERR("transfer syntax not supported\n");
1623 status = RPC_S_SERVER_UNAVAILABLE;
1624 break;
1625 case REASON_NONE:
1626 default:
1627 status = RPC_S_CALL_FAILED_DNE;
1628 }
1629 break;
1630 case RESULT_USER_REJECTION:
1631 default:
1632 ERR("rejection result %d\n", results->results[0].result);
1633 status = RPC_S_CALL_FAILED_DNE;
1634 }
1635 }
1636 else
1637 {
1638 ERR("incorrect results size\n");
1639 status = RPC_S_CALL_FAILED_DNE;
1640 }
1641 }
1642 else
1643 {
1644 ERR("bind ack packet too small (%d)\n", msg.BufferLength);
1645 status = RPC_S_PROTOCOL_ERROR;
1646 }
1647 break;
1648 }
1649 case PKT_BIND_NACK:
1650 switch (response_hdr->bind_nack.reject_reason)
1651 {
1652 case REJECT_LOCAL_LIMIT_EXCEEDED:
1653 case REJECT_TEMPORARY_CONGESTION:
1654 ERR("server too busy\n");
1655 status = RPC_S_SERVER_TOO_BUSY;
1656 break;
1657 case REJECT_PROTOCOL_VERSION_NOT_SUPPORTED:
1658 ERR("protocol version not supported\n");
1659 status = RPC_S_PROTOCOL_ERROR;
1660 break;
1661 case REJECT_UNKNOWN_AUTHN_SERVICE:
1662 ERR("unknown authentication service\n");
1663 status = RPC_S_UNKNOWN_AUTHN_SERVICE;
1664 break;
1665 case REJECT_INVALID_CHECKSUM:
1666 ERR("invalid checksum\n");
1667 status = ERROR_ACCESS_DENIED;
1668 break;
1669 default:
1670 ERR("rejected bind for reason %d\n", response_hdr->bind_nack.reject_reason);
1671 status = RPC_S_CALL_FAILED_DNE;
1672 }
1673 break;
1674 default:
1675 ERR("wrong packet type received %d\n", response_hdr->common.ptype);
1676 status = RPC_S_PROTOCOL_ERROR;
1677 break;
1678 }
1679
1680 I_RpcFreeBuffer(&msg);
1681 RPCRT4_FreeHeader(response_hdr);
1682 return status;
1683 }
1684
1685 static RpcConnection *RpcAssoc_GetIdleConnection(RpcAssoc *assoc,
1686 const RPC_SYNTAX_IDENTIFIER *InterfaceId,
1687 const RPC_SYNTAX_IDENTIFIER *TransferSyntax, const RpcAuthInfo *AuthInfo,
1688 const RpcQualityOfService *QOS)
1689 {
1690 RpcConnection *Connection;
1691 EnterCriticalSection(&assoc->cs);
1692 /* try to find a compatible connection from the connection pool */
1693 LIST_FOR_EACH_ENTRY(Connection, &assoc->connection_pool, RpcConnection, conn_pool_entry)
1694 {
1695 if (!memcmp(&Connection->ActiveInterface, InterfaceId,
1696 sizeof(RPC_SYNTAX_IDENTIFIER)) &&
1697 RpcAuthInfo_IsEqual(Connection->AuthInfo, AuthInfo) &&
1698 RpcQualityOfService_IsEqual(Connection->QOS, QOS))
1699 {
1700 list_remove(&Connection->conn_pool_entry);
1701 LeaveCriticalSection(&assoc->cs);
1702 TRACE("got connection from pool %p\n", Connection);
1703 return Connection;
1704 }
1705 }
1706
1707 LeaveCriticalSection(&assoc->cs);
1708 return NULL;
1709 }
1710
1711 RPC_STATUS RpcAssoc_GetClientConnection(RpcAssoc *assoc,
1712 const RPC_SYNTAX_IDENTIFIER *InterfaceId,
1713 const RPC_SYNTAX_IDENTIFIER *TransferSyntax, RpcAuthInfo *AuthInfo,
1714 RpcQualityOfService *QOS, RpcConnection **Connection)
1715 {
1716 RpcConnection *NewConnection;
1717 RPC_STATUS status;
1718
1719 *Connection = RpcAssoc_GetIdleConnection(assoc, InterfaceId, TransferSyntax, AuthInfo, QOS);
1720 if (*Connection)
1721 return RPC_S_OK;
1722
1723 /* create a new connection */
1724 status = RPCRT4_CreateConnection(&NewConnection, FALSE /* is this a server connection? */,
1725 assoc->Protseq, assoc->NetworkAddr,
1726 assoc->Endpoint, assoc->NetworkOptions,
1727 AuthInfo, QOS);
1728 if (status != RPC_S_OK)
1729 return status;
1730
1731 status = RPCRT4_OpenClientConnection(NewConnection);
1732 if (status != RPC_S_OK)
1733 {
1734 RPCRT4_DestroyConnection(NewConnection);
1735 return status;
1736 }
1737
1738 status = RpcAssoc_BindConnection(assoc, NewConnection, InterfaceId, TransferSyntax);
1739 if (status != RPC_S_OK)
1740 {
1741 RPCRT4_DestroyConnection(NewConnection);
1742 return status;
1743 }
1744
1745 *Connection = NewConnection;
1746
1747 return RPC_S_OK;
1748 }
1749
1750 void RpcAssoc_ReleaseIdleConnection(RpcAssoc *assoc, RpcConnection *Connection)
1751 {
1752 assert(!Connection->server);
1753 EnterCriticalSection(&assoc->cs);
1754 if (!assoc->assoc_group_id) assoc->assoc_group_id = Connection->assoc_group_id;
1755 list_add_head(&assoc->connection_pool, &Connection->conn_pool_entry);
1756 LeaveCriticalSection(&assoc->cs);
1757 }
1758
1759
1760 RPC_STATUS RPCRT4_SpawnConnection(RpcConnection** Connection, RpcConnection* OldConnection)
1761 {
1762 RPC_STATUS err;
1763
1764 err = RPCRT4_CreateConnection(Connection, OldConnection->server,
1765 rpcrt4_conn_get_name(OldConnection),
1766 OldConnection->NetworkAddr,
1767 OldConnection->Endpoint, NULL,
1768 OldConnection->AuthInfo, OldConnection->QOS);
1769 if (err == RPC_S_OK)
1770 rpcrt4_conn_handoff(OldConnection, *Connection);
1771 return err;
1772 }
1773
1774 RPC_STATUS RPCRT4_DestroyConnection(RpcConnection* Connection)
1775 {
1776 TRACE("connection: %p\n", Connection);
1777
1778 RPCRT4_CloseConnection(Connection);
1779 RPCRT4_strfree(Connection->Endpoint);
1780 RPCRT4_strfree(Connection->NetworkAddr);
1781 HeapFree(GetProcessHeap(), 0, Connection->NetworkOptions);
1782 if (Connection->AuthInfo) RpcAuthInfo_Release(Connection->AuthInfo);
1783 if (Connection->QOS) RpcQualityOfService_Release(Connection->QOS);
1784 HeapFree(GetProcessHeap(), 0, Connection);
1785 return RPC_S_OK;
1786 }
1787
1788 RPC_STATUS RpcTransport_GetTopOfTower(unsigned char *tower_data,
1789 size_t *tower_size,
1790 const char *protseq,
1791 const char *networkaddr,
1792 const char *endpoint)
1793 {
1794 twr_empty_floor_t *protocol_floor;
1795 const struct connection_ops *protseq_ops = rpcrt4_get_conn_protseq_ops(protseq);
1796
1797 *tower_size = 0;
1798
1799 if (!protseq_ops)
1800 return RPC_S_INVALID_RPC_PROTSEQ;
1801
1802 if (!tower_data)
1803 {
1804 *tower_size = sizeof(*protocol_floor);
1805 *tower_size += protseq_ops->get_top_of_tower(NULL, networkaddr, endpoint);
1806 return RPC_S_OK;
1807 }
1808
1809 protocol_floor = (twr_empty_floor_t *)tower_data;
1810 protocol_floor->count_lhs = sizeof(protocol_floor->protid);
1811 protocol_floor->protid = protseq_ops->epm_protocols[0];
1812 protocol_floor->count_rhs = 0;
1813
1814 tower_data += sizeof(*protocol_floor);
1815
1816 *tower_size = protseq_ops->get_top_of_tower(tower_data, networkaddr, endpoint);
1817 if (!*tower_size)
1818 return EPT_S_NOT_REGISTERED;
1819
1820 *tower_size += sizeof(*protocol_floor);
1821
1822 return RPC_S_OK;
1823 }
1824
1825 RPC_STATUS RpcTransport_ParseTopOfTower(const unsigned char *tower_data,
1826 size_t tower_size,
1827 char **protseq,
1828 char **networkaddr,
1829 char **endpoint)
1830 {
1831 const twr_empty_floor_t *protocol_floor;
1832 const twr_empty_floor_t *floor4;
1833 const struct connection_ops *protseq_ops = NULL;
1834 RPC_STATUS status;
1835 int i;
1836
1837 if (tower_size < sizeof(*protocol_floor))
1838 return EPT_S_NOT_REGISTERED;
1839
1840 protocol_floor = (const twr_empty_floor_t *)tower_data;
1841 tower_data += sizeof(*protocol_floor);
1842 tower_size -= sizeof(*protocol_floor);
1843 if ((protocol_floor->count_lhs != sizeof(protocol_floor->protid)) ||
1844 (protocol_floor->count_rhs > tower_size))
1845 return EPT_S_NOT_REGISTERED;
1846 tower_data += protocol_floor->count_rhs;
1847 tower_size -= protocol_floor->count_rhs;
1848
1849 floor4 = (const twr_empty_floor_t *)tower_data;
1850 if ((tower_size < sizeof(*floor4)) ||
1851 (floor4->count_lhs != sizeof(floor4->protid)))
1852 return EPT_S_NOT_REGISTERED;
1853
1854 for(i = 0; i < ARRAYSIZE(conn_protseq_list); i++)
1855 if ((protocol_floor->protid == conn_protseq_list[i].epm_protocols[0]) &&
1856 (floor4->protid == conn_protseq_list[i].epm_protocols[1]))
1857 {
1858 protseq_ops = &conn_protseq_list[i];
1859 break;
1860 }
1861
1862 if (!protseq_ops)
1863 return EPT_S_NOT_REGISTERED;
1864
1865 status = protseq_ops->parse_top_of_tower(tower_data, tower_size, networkaddr, endpoint);
1866
1867 if ((status == RPC_S_OK) && protseq)
1868 {
1869 *protseq = I_RpcAllocate(strlen(protseq_ops->name) + 1);
1870 strcpy(*protseq, protseq_ops->name);
1871 }
1872
1873 return status;
1874 }
1875
1876 /***********************************************************************
1877 * RpcNetworkIsProtseqValidW (RPCRT4.@)
1878 *
1879 * Checks if the given protocol sequence is known by the RPC system.
1880 * If it is, returns RPC_S_OK, otherwise RPC_S_PROTSEQ_NOT_SUPPORTED.
1881 *
1882 */
1883 RPC_STATUS WINAPI RpcNetworkIsProtseqValidW(RPC_WSTR protseq)
1884 {
1885 char ps[0x10];
1886
1887 WideCharToMultiByte(CP_ACP, 0, protseq, -1,
1888 ps, sizeof ps, NULL, NULL);
1889 if (rpcrt4_get_conn_protseq_ops(ps))
1890 return RPC_S_OK;
1891
1892 FIXME("Unknown protseq %s\n", debugstr_w(protseq));
1893
1894 return RPC_S_INVALID_RPC_PROTSEQ;
1895 }
1896
1897 /***********************************************************************
1898 * RpcNetworkIsProtseqValidA (RPCRT4.@)
1899 */
1900 RPC_STATUS WINAPI RpcNetworkIsProtseqValidA(RPC_CSTR protseq)
1901 {
1902 UNICODE_STRING protseqW;
1903
1904 if (RtlCreateUnicodeStringFromAsciiz(&protseqW, (char*)protseq))
1905 {
1906 RPC_STATUS ret = RpcNetworkIsProtseqValidW(protseqW.Buffer);
1907 RtlFreeUnicodeString(&protseqW);
1908 return ret;
1909 }
1910 return RPC_S_OUT_OF_MEMORY;
1911 }
Maarten's multimedia branch