?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
notepad: Fix an error in a Chinese (Traditional) resource.
[wine/hacks.git] / dlls / rpcrt4 / rpc_transport.c
blob07a1e0401b40e84d78c86b4144d63b984bfbb8f9
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 <stdlib.h>
33 #include <sys/types.h>
34
35 #if defined(__MINGW32__) || defined (_MSC_VER)
36 # include <ws2tcpip.h>
37 # ifndef EADDRINUSE
38 # define EADDRINUSE WSAEADDRINUSE
39 # endif
40 # ifndef EAGAIN
41 # define EAGAIN WSAEWOULDBLOCK
42 # endif
43 # undef errno
44 # define errno WSAGetLastError()
45 #else
46 # include <errno.h>
47 # ifdef HAVE_UNISTD_H
48 # include <unistd.h>
49 # endif
50 # include <fcntl.h>
51 # ifdef HAVE_SYS_SOCKET_H
52 # include <sys/socket.h>
53 # endif
54 # ifdef HAVE_NETINET_IN_H
55 # include <netinet/in.h>
56 # endif
57 # ifdef HAVE_NETINET_TCP_H
58 # include <netinet/tcp.h>
59 # endif
60 # ifdef HAVE_ARPA_INET_H
61 # include <arpa/inet.h>
62 # endif
63 # ifdef HAVE_NETDB_H
64 # include <netdb.h>
65 # endif
66 # ifdef HAVE_SYS_POLL_H
67 # include <sys/poll.h>
68 # endif
69 # ifdef HAVE_SYS_FILIO_H
70 # include <sys/filio.h>
71 # endif
72 # ifdef HAVE_SYS_IOCTL_H
73 # include <sys/ioctl.h>
74 # endif
75 # define closesocket close
76 # define ioctlsocket ioctl
77 #endif /* defined(__MINGW32__) || defined (_MSC_VER) */
78
79 #include "windef.h"
80 #include "winbase.h"
81 #include "winnls.h"
82 #include "winerror.h"
83 #include "wininet.h"
84 #include "winternl.h"
85 #include "wine/unicode.h"
86
87 #include "rpc.h"
88 #include "rpcndr.h"
89
90 #include "wine/debug.h"
91
92 #include "rpc_binding.h"
93 #include "rpc_assoc.h"
94 #include "rpc_message.h"
95 #include "rpc_server.h"
96 #include "epm_towers.h"
97
98 #ifndef SOL_TCP
99 # define SOL_TCP IPPROTO_TCP
100 #endif
101
102 #define DEFAULT_NCACN_HTTP_TIMEOUT (60 * 1000)
103
104 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
105
106 static RPC_STATUS RPCRT4_SpawnConnection(RpcConnection** Connection, RpcConnection* OldConnection);
107
108 /**** ncacn_np support ****/
109
110 typedef struct _RpcConnection_np
111 {
112 RpcConnection common;
113 HANDLE pipe;
114 OVERLAPPED ovl;
115 BOOL listening;
116 } RpcConnection_np;
117
118 static RpcConnection *rpcrt4_conn_np_alloc(void)
119 {
120 RpcConnection_np *npc = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_np));
121 if (npc)
122 {
123 npc->pipe = NULL;
124 memset(&npc->ovl, 0, sizeof(npc->ovl));
125 npc->listening = FALSE;
126 }
127 return &npc->common;
128 }
129
130 static RPC_STATUS rpcrt4_conn_listen_pipe(RpcConnection_np *npc)
131 {
132 if (npc->listening)
133 return RPC_S_OK;
134
135 npc->listening = TRUE;
136 for (;;)
137 {
138 if (ConnectNamedPipe(npc->pipe, &npc->ovl))
139 return RPC_S_OK;
140
141 switch(GetLastError())
142 {
143 case ERROR_PIPE_CONNECTED:
144 SetEvent(npc->ovl.hEvent);
145 return RPC_S_OK;
146 case ERROR_IO_PENDING:
147 /* will be completed in rpcrt4_protseq_np_wait_for_new_connection */
148 return RPC_S_OK;
149 case ERROR_NO_DATA_DETECTED:
150 /* client has disconnected, retry */
151 DisconnectNamedPipe( npc->pipe );
152 break;
153 default:
154 npc->listening = FALSE;
155 WARN("Couldn't ConnectNamedPipe (error was %d)\n", GetLastError());
156 return RPC_S_OUT_OF_RESOURCES;
157 }
158 }
159 }
160
161 static RPC_STATUS rpcrt4_conn_create_pipe(RpcConnection *Connection, LPCSTR pname)
162 {
163 RpcConnection_np *npc = (RpcConnection_np *) Connection;
164 TRACE("listening on %s\n", pname);
165
166 npc->pipe = CreateNamedPipeA(pname, PIPE_ACCESS_DUPLEX,
167 PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
168 PIPE_UNLIMITED_INSTANCES,
169 RPC_MAX_PACKET_SIZE, RPC_MAX_PACKET_SIZE, 5000, NULL);
170 if (npc->pipe == INVALID_HANDLE_VALUE) {
171 WARN("CreateNamedPipe failed with error %d\n", GetLastError());
172 if (GetLastError() == ERROR_FILE_EXISTS)
173 return RPC_S_DUPLICATE_ENDPOINT;
174 else
175 return RPC_S_CANT_CREATE_ENDPOINT;
176 }
177
178 memset(&npc->ovl, 0, sizeof(npc->ovl));
179 npc->ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
180
181 /* Note: we don't call ConnectNamedPipe here because it must be done in the
182 * server thread as the thread must be alertable */
183 return RPC_S_OK;
184 }
185
186 static RPC_STATUS rpcrt4_conn_open_pipe(RpcConnection *Connection, LPCSTR pname, BOOL wait)
187 {
188 RpcConnection_np *npc = (RpcConnection_np *) Connection;
189 HANDLE pipe;
190 DWORD err, dwMode;
191
192 TRACE("connecting to %s\n", pname);
193
194 while (TRUE) {
195 DWORD dwFlags = 0;
196 if (Connection->QOS)
197 {
198 dwFlags = SECURITY_SQOS_PRESENT;
199 switch (Connection->QOS->qos->ImpersonationType)
200 {
201 case RPC_C_IMP_LEVEL_DEFAULT:
202 /* FIXME: what to do here? */
203 break;
204 case RPC_C_IMP_LEVEL_ANONYMOUS:
205 dwFlags |= SECURITY_ANONYMOUS;
206 break;
207 case RPC_C_IMP_LEVEL_IDENTIFY:
208 dwFlags |= SECURITY_IDENTIFICATION;
209 break;
210 case RPC_C_IMP_LEVEL_IMPERSONATE:
211 dwFlags |= SECURITY_IMPERSONATION;
212 break;
213 case RPC_C_IMP_LEVEL_DELEGATE:
214 dwFlags |= SECURITY_DELEGATION;
215 break;
216 }
217 if (Connection->QOS->qos->IdentityTracking == RPC_C_QOS_IDENTITY_DYNAMIC)
218 dwFlags |= SECURITY_CONTEXT_TRACKING;
219 }
220 pipe = CreateFileA(pname, GENERIC_READ|GENERIC_WRITE, 0, NULL,
221 OPEN_EXISTING, dwFlags, 0);
222 if (pipe != INVALID_HANDLE_VALUE) break;
223 err = GetLastError();
224 if (err == ERROR_PIPE_BUSY) {
225 TRACE("connection failed, error=%x\n", err);
226 return RPC_S_SERVER_TOO_BUSY;
227 }
228 if (!wait || !WaitNamedPipeA(pname, NMPWAIT_WAIT_FOREVER)) {
229 err = GetLastError();
230 WARN("connection failed, error=%x\n", err);
231 return RPC_S_SERVER_UNAVAILABLE;
232 }
233 }
234
235 /* success */
236 memset(&npc->ovl, 0, sizeof(npc->ovl));
237 /* pipe is connected; change to message-read mode. */
238 dwMode = PIPE_READMODE_MESSAGE;
239 SetNamedPipeHandleState(pipe, &dwMode, NULL, NULL);
240 npc->ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
241 npc->pipe = pipe;
242
243 return RPC_S_OK;
244 }
245
246 static RPC_STATUS rpcrt4_ncalrpc_open(RpcConnection* Connection)
247 {
248 RpcConnection_np *npc = (RpcConnection_np *) Connection;
249 static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
250 RPC_STATUS r;
251 LPSTR pname;
252
253 /* already connected? */
254 if (npc->pipe)
255 return RPC_S_OK;
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_open_pipe(Connection, pname, TRUE);
262 I_RpcFree(pname);
263
264 return r;
265 }
266
267 static RPC_STATUS rpcrt4_protseq_ncalrpc_open_endpoint(RpcServerProtseq* protseq, const char *endpoint)
268 {
269 static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
270 RPC_STATUS r;
271 LPSTR pname;
272 RpcConnection *Connection;
273 char generated_endpoint[22];
274
275 if (!endpoint)
276 {
277 static LONG lrpc_nameless_id;
278 DWORD process_id = GetCurrentProcessId();
279 ULONG id = InterlockedIncrement(&lrpc_nameless_id);
280 snprintf(generated_endpoint, sizeof(generated_endpoint),
281 "LRPC%08x.%08x", process_id, id);
282 endpoint = generated_endpoint;
283 }
284
285 r = RPCRT4_CreateConnection(&Connection, TRUE, protseq->Protseq, NULL,
286 endpoint, NULL, NULL, NULL);
287 if (r != RPC_S_OK)
288 return r;
289
290 /* protseq=ncalrpc: supposed to use NT LPC ports,
291 * but we'll implement it with named pipes for now */
292 pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
293 strcat(strcpy(pname, prefix), Connection->Endpoint);
294 r = rpcrt4_conn_create_pipe(Connection, pname);
295 I_RpcFree(pname);
296
297 EnterCriticalSection(&protseq->cs);
298 Connection->Next = protseq->conn;
299 protseq->conn = Connection;
300 LeaveCriticalSection(&protseq->cs);
301
302 return r;
303 }
304
305 static RPC_STATUS rpcrt4_ncacn_np_open(RpcConnection* Connection)
306 {
307 RpcConnection_np *npc = (RpcConnection_np *) Connection;
308 static const char prefix[] = "\\\\.";
309 RPC_STATUS r;
310 LPSTR pname;
311
312 /* already connected? */
313 if (npc->pipe)
314 return RPC_S_OK;
315
316 /* protseq=ncacn_np: named pipes */
317 pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
318 strcat(strcpy(pname, prefix), Connection->Endpoint);
319 r = rpcrt4_conn_open_pipe(Connection, pname, FALSE);
320 I_RpcFree(pname);
321
322 return r;
323 }
324
325 static RPC_STATUS rpcrt4_protseq_ncacn_np_open_endpoint(RpcServerProtseq *protseq, const char *endpoint)
326 {
327 static const char prefix[] = "\\\\.";
328 RPC_STATUS r;
329 LPSTR pname;
330 RpcConnection *Connection;
331 char generated_endpoint[21];
332
333 if (!endpoint)
334 {
335 static LONG np_nameless_id;
336 DWORD process_id = GetCurrentProcessId();
337 ULONG id = InterlockedExchangeAdd(&np_nameless_id, 1 );
338 snprintf(generated_endpoint, sizeof(generated_endpoint),
339 "\\\\pipe\\\\%08x.%03x", process_id, id);
340 endpoint = generated_endpoint;
341 }
342
343 r = RPCRT4_CreateConnection(&Connection, TRUE, protseq->Protseq, NULL,
344 endpoint, NULL, NULL, NULL);
345 if (r != RPC_S_OK)
346 return r;
347
348 /* protseq=ncacn_np: named pipes */
349 pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
350 strcat(strcpy(pname, prefix), Connection->Endpoint);
351 r = rpcrt4_conn_create_pipe(Connection, pname);
352 I_RpcFree(pname);
353
354 EnterCriticalSection(&protseq->cs);
355 Connection->Next = protseq->conn;
356 protseq->conn = Connection;
357 LeaveCriticalSection(&protseq->cs);
358
359 return r;
360 }
361
362 static void rpcrt4_conn_np_handoff(RpcConnection_np *old_npc, RpcConnection_np *new_npc)
363 {
364 /* because of the way named pipes work, we'll transfer the connected pipe
365 * to the child, then reopen the server binding to continue listening */
366
367 new_npc->pipe = old_npc->pipe;
368 new_npc->ovl = old_npc->ovl;
369 old_npc->pipe = 0;
370 memset(&old_npc->ovl, 0, sizeof(old_npc->ovl));
371 old_npc->listening = FALSE;
372 }
373
374 static RPC_STATUS rpcrt4_ncacn_np_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
375 {
376 RPC_STATUS status;
377 LPSTR pname;
378 static const char prefix[] = "\\\\.";
379
380 rpcrt4_conn_np_handoff((RpcConnection_np *)old_conn, (RpcConnection_np *)new_conn);
381
382 pname = I_RpcAllocate(strlen(prefix) + strlen(old_conn->Endpoint) + 1);
383 strcat(strcpy(pname, prefix), old_conn->Endpoint);
384 status = rpcrt4_conn_create_pipe(old_conn, pname);
385 I_RpcFree(pname);
386
387 return status;
388 }
389
390 static RPC_STATUS rpcrt4_ncalrpc_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
391 {
392 RPC_STATUS status;
393 LPSTR pname;
394 static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
395
396 TRACE("%s\n", old_conn->Endpoint);
397
398 rpcrt4_conn_np_handoff((RpcConnection_np *)old_conn, (RpcConnection_np *)new_conn);
399
400 pname = I_RpcAllocate(strlen(prefix) + strlen(old_conn->Endpoint) + 1);
401 strcat(strcpy(pname, prefix), old_conn->Endpoint);
402 status = rpcrt4_conn_create_pipe(old_conn, pname);
403 I_RpcFree(pname);
404
405 return status;
406 }
407
408 static int rpcrt4_conn_np_read(RpcConnection *Connection,
409 void *buffer, unsigned int count)
410 {
411 RpcConnection_np *npc = (RpcConnection_np *) Connection;
412 char *buf = buffer;
413 BOOL ret = TRUE;
414 unsigned int bytes_left = count;
415
416 while (bytes_left)
417 {
418 DWORD bytes_read;
419 ret = ReadFile(npc->pipe, buf, bytes_left, &bytes_read, NULL);
420 if (!ret && GetLastError() == ERROR_MORE_DATA)
421 ret = TRUE;
422 if (!ret || !bytes_read)
423 break;
424 bytes_left -= bytes_read;
425 buf += bytes_read;
426 }
427 return ret ? count : -1;
428 }
429
430 static int rpcrt4_conn_np_write(RpcConnection *Connection,
431 const void *buffer, unsigned int count)
432 {
433 RpcConnection_np *npc = (RpcConnection_np *) Connection;
434 const char *buf = buffer;
435 BOOL ret = TRUE;
436 unsigned int bytes_left = count;
437
438 while (bytes_left)
439 {
440 DWORD bytes_written;
441 ret = WriteFile(npc->pipe, buf, bytes_left, &bytes_written, NULL);
442 if (!ret || !bytes_written)
443 break;
444 bytes_left -= bytes_written;
445 buf += bytes_written;
446 }
447 return ret ? count : -1;
448 }
449
450 static int rpcrt4_conn_np_close(RpcConnection *Connection)
451 {
452 RpcConnection_np *npc = (RpcConnection_np *) Connection;
453 if (npc->pipe) {
454 FlushFileBuffers(npc->pipe);
455 CloseHandle(npc->pipe);
456 npc->pipe = 0;
457 }
458 if (npc->ovl.hEvent) {
459 CloseHandle(npc->ovl.hEvent);
460 npc->ovl.hEvent = 0;
461 }
462 return 0;
463 }
464
465 static void rpcrt4_conn_np_cancel_call(RpcConnection *Connection)
466 {
467 /* FIXME: implement when named pipe writes use overlapped I/O */
468 }
469
470 static int rpcrt4_conn_np_wait_for_incoming_data(RpcConnection *Connection)
471 {
472 /* FIXME: implement when named pipe writes use overlapped I/O */
473 return -1;
474 }
475
476 static size_t rpcrt4_ncacn_np_get_top_of_tower(unsigned char *tower_data,
477 const char *networkaddr,
478 const char *endpoint)
479 {
480 twr_empty_floor_t *smb_floor;
481 twr_empty_floor_t *nb_floor;
482 size_t size;
483 size_t networkaddr_size;
484 size_t endpoint_size;
485
486 TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
487
488 networkaddr_size = networkaddr ? strlen(networkaddr) + 1 : 1;
489 endpoint_size = endpoint ? strlen(endpoint) + 1 : 1;
490 size = sizeof(*smb_floor) + endpoint_size + sizeof(*nb_floor) + networkaddr_size;
491
492 if (!tower_data)
493 return size;
494
495 smb_floor = (twr_empty_floor_t *)tower_data;
496
497 tower_data += sizeof(*smb_floor);
498
499 smb_floor->count_lhs = sizeof(smb_floor->protid);
500 smb_floor->protid = EPM_PROTOCOL_SMB;
501 smb_floor->count_rhs = endpoint_size;
502
503 if (endpoint)
504 memcpy(tower_data, endpoint, endpoint_size);
505 else
506 tower_data[0] = 0;
507 tower_data += endpoint_size;
508
509 nb_floor = (twr_empty_floor_t *)tower_data;
510
511 tower_data += sizeof(*nb_floor);
512
513 nb_floor->count_lhs = sizeof(nb_floor->protid);
514 nb_floor->protid = EPM_PROTOCOL_NETBIOS;
515 nb_floor->count_rhs = networkaddr_size;
516
517 if (networkaddr)
518 memcpy(tower_data, networkaddr, networkaddr_size);
519 else
520 tower_data[0] = 0;
521
522 return size;
523 }
524
525 static RPC_STATUS rpcrt4_ncacn_np_parse_top_of_tower(const unsigned char *tower_data,
526 size_t tower_size,
527 char **networkaddr,
528 char **endpoint)
529 {
530 const twr_empty_floor_t *smb_floor = (const twr_empty_floor_t *)tower_data;
531 const twr_empty_floor_t *nb_floor;
532
533 TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
534
535 if (tower_size < sizeof(*smb_floor))
536 return EPT_S_NOT_REGISTERED;
537
538 tower_data += sizeof(*smb_floor);
539 tower_size -= sizeof(*smb_floor);
540
541 if ((smb_floor->count_lhs != sizeof(smb_floor->protid)) ||
542 (smb_floor->protid != EPM_PROTOCOL_SMB) ||
543 (smb_floor->count_rhs > tower_size) ||
544 (tower_data[smb_floor->count_rhs - 1] != '\0'))
545 return EPT_S_NOT_REGISTERED;
546
547 if (endpoint)
548 {
549 *endpoint = I_RpcAllocate(smb_floor->count_rhs);
550 if (!*endpoint)
551 return RPC_S_OUT_OF_RESOURCES;
552 memcpy(*endpoint, tower_data, smb_floor->count_rhs);
553 }
554 tower_data += smb_floor->count_rhs;
555 tower_size -= smb_floor->count_rhs;
556
557 if (tower_size < sizeof(*nb_floor))
558 return EPT_S_NOT_REGISTERED;
559
560 nb_floor = (const twr_empty_floor_t *)tower_data;
561
562 tower_data += sizeof(*nb_floor);
563 tower_size -= sizeof(*nb_floor);
564
565 if ((nb_floor->count_lhs != sizeof(nb_floor->protid)) ||
566 (nb_floor->protid != EPM_PROTOCOL_NETBIOS) ||
567 (nb_floor->count_rhs > tower_size) ||
568 (tower_data[nb_floor->count_rhs - 1] != '\0'))
569 return EPT_S_NOT_REGISTERED;
570
571 if (networkaddr)
572 {
573 *networkaddr = I_RpcAllocate(nb_floor->count_rhs);
574 if (!*networkaddr)
575 {
576 if (endpoint)
577 {
578 I_RpcFree(*endpoint);
579 *endpoint = NULL;
580 }
581 return RPC_S_OUT_OF_RESOURCES;
582 }
583 memcpy(*networkaddr, tower_data, nb_floor->count_rhs);
584 }
585
586 return RPC_S_OK;
587 }
588
589 static RPC_STATUS rpcrt4_conn_np_impersonate_client(RpcConnection *conn)
590 {
591 RpcConnection_np *npc = (RpcConnection_np *)conn;
592 BOOL ret;
593
594 TRACE("(%p)\n", conn);
595
596 if (conn->AuthInfo && SecIsValidHandle(&conn->ctx))
597 return RPCRT4_default_impersonate_client(conn);
598
599 ret = ImpersonateNamedPipeClient(npc->pipe);
600 if (!ret)
601 {
602 DWORD error = GetLastError();
603 WARN("ImpersonateNamedPipeClient failed with error %u\n", error);
604 switch (error)
605 {
606 case ERROR_CANNOT_IMPERSONATE:
607 return RPC_S_NO_CONTEXT_AVAILABLE;
608 }
609 }
610 return RPC_S_OK;
611 }
612
613 static RPC_STATUS rpcrt4_conn_np_revert_to_self(RpcConnection *conn)
614 {
615 BOOL ret;
616
617 TRACE("(%p)\n", conn);
618
619 if (conn->AuthInfo && SecIsValidHandle(&conn->ctx))
620 return RPCRT4_default_revert_to_self(conn);
621
622 ret = RevertToSelf();
623 if (!ret)
624 {
625 WARN("RevertToSelf failed with error %u\n", GetLastError());
626 return RPC_S_NO_CONTEXT_AVAILABLE;
627 }
628 return RPC_S_OK;
629 }
630
631 typedef struct _RpcServerProtseq_np
632 {
633 RpcServerProtseq common;
634 HANDLE mgr_event;
635 } RpcServerProtseq_np;
636
637 static RpcServerProtseq *rpcrt4_protseq_np_alloc(void)
638 {
639 RpcServerProtseq_np *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps));
640 if (ps)
641 ps->mgr_event = CreateEventW(NULL, FALSE, FALSE, NULL);
642 return &ps->common;
643 }
644
645 static void rpcrt4_protseq_np_signal_state_changed(RpcServerProtseq *protseq)
646 {
647 RpcServerProtseq_np *npps = CONTAINING_RECORD(protseq, RpcServerProtseq_np, common);
648 SetEvent(npps->mgr_event);
649 }
650
651 static void *rpcrt4_protseq_np_get_wait_array(RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
652 {
653 HANDLE *objs = prev_array;
654 RpcConnection_np *conn;
655 RpcServerProtseq_np *npps = CONTAINING_RECORD(protseq, RpcServerProtseq_np, common);
656
657 EnterCriticalSection(&protseq->cs);
658
659 /* open and count connections */
660 *count = 1;
661 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
662 while (conn) {
663 rpcrt4_conn_listen_pipe(conn);
664 if (conn->ovl.hEvent)
665 (*count)++;
666 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
667 }
668
669 /* make array of connections */
670 if (objs)
671 objs = HeapReAlloc(GetProcessHeap(), 0, objs, *count*sizeof(HANDLE));
672 else
673 objs = HeapAlloc(GetProcessHeap(), 0, *count*sizeof(HANDLE));
674 if (!objs)
675 {
676 ERR("couldn't allocate objs\n");
677 LeaveCriticalSection(&protseq->cs);
678 return NULL;
679 }
680
681 objs[0] = npps->mgr_event;
682 *count = 1;
683 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
684 while (conn) {
685 if ((objs[*count] = conn->ovl.hEvent))
686 (*count)++;
687 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
688 }
689 LeaveCriticalSection(&protseq->cs);
690 return objs;
691 }
692
693 static void rpcrt4_protseq_np_free_wait_array(RpcServerProtseq *protseq, void *array)
694 {
695 HeapFree(GetProcessHeap(), 0, array);
696 }
697
698 static int rpcrt4_protseq_np_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array)
699 {
700 HANDLE b_handle;
701 HANDLE *objs = wait_array;
702 DWORD res;
703 RpcConnection *cconn;
704 RpcConnection_np *conn;
705
706 if (!objs)
707 return -1;
708
709 do
710 {
711 /* an alertable wait isn't strictly necessary, but due to our
712 * overlapped I/O implementation in Wine we need to free some memory
713 * by the file user APC being called, even if no completion routine was
714 * specified at the time of starting the async operation */
715 res = WaitForMultipleObjectsEx(count, objs, FALSE, INFINITE, TRUE);
716 } while (res == WAIT_IO_COMPLETION);
717
718 if (res == WAIT_OBJECT_0)
719 return 0;
720 else if (res == WAIT_FAILED)
721 {
722 ERR("wait failed with error %d\n", GetLastError());
723 return -1;
724 }
725 else
726 {
727 b_handle = objs[res - WAIT_OBJECT_0];
728 /* find which connection got a RPC */
729 EnterCriticalSection(&protseq->cs);
730 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
731 while (conn) {
732 if (b_handle == conn->ovl.hEvent) break;
733 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
734 }
735 cconn = NULL;
736 if (conn)
737 RPCRT4_SpawnConnection(&cconn, &conn->common);
738 else
739 ERR("failed to locate connection for handle %p\n", b_handle);
740 LeaveCriticalSection(&protseq->cs);
741 if (cconn)
742 {
743 RPCRT4_new_client(cconn);
744 return 1;
745 }
746 else return -1;
747 }
748 }
749
750 static size_t rpcrt4_ncalrpc_get_top_of_tower(unsigned char *tower_data,
751 const char *networkaddr,
752 const char *endpoint)
753 {
754 twr_empty_floor_t *pipe_floor;
755 size_t size;
756 size_t endpoint_size;
757
758 TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
759
760 endpoint_size = strlen(endpoint) + 1;
761 size = sizeof(*pipe_floor) + endpoint_size;
762
763 if (!tower_data)
764 return size;
765
766 pipe_floor = (twr_empty_floor_t *)tower_data;
767
768 tower_data += sizeof(*pipe_floor);
769
770 pipe_floor->count_lhs = sizeof(pipe_floor->protid);
771 pipe_floor->protid = EPM_PROTOCOL_PIPE;
772 pipe_floor->count_rhs = endpoint_size;
773
774 memcpy(tower_data, endpoint, endpoint_size);
775
776 return size;
777 }
778
779 static RPC_STATUS rpcrt4_ncalrpc_parse_top_of_tower(const unsigned char *tower_data,
780 size_t tower_size,
781 char **networkaddr,
782 char **endpoint)
783 {
784 const twr_empty_floor_t *pipe_floor = (const twr_empty_floor_t *)tower_data;
785
786 TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
787
788 if (tower_size < sizeof(*pipe_floor))
789 return EPT_S_NOT_REGISTERED;
790
791 tower_data += sizeof(*pipe_floor);
792 tower_size -= sizeof(*pipe_floor);
793
794 if ((pipe_floor->count_lhs != sizeof(pipe_floor->protid)) ||
795 (pipe_floor->protid != EPM_PROTOCOL_PIPE) ||
796 (pipe_floor->count_rhs > tower_size) ||
797 (tower_data[pipe_floor->count_rhs - 1] != '\0'))
798 return EPT_S_NOT_REGISTERED;
799
800 if (networkaddr)
801 *networkaddr = NULL;
802
803 if (endpoint)
804 {
805 *endpoint = I_RpcAllocate(pipe_floor->count_rhs);
806 if (!*endpoint)
807 return RPC_S_OUT_OF_RESOURCES;
808 memcpy(*endpoint, tower_data, pipe_floor->count_rhs);
809 }
810
811 return RPC_S_OK;
812 }
813
814 static BOOL rpcrt4_ncalrpc_is_authorized(RpcConnection *conn)
815 {
816 return FALSE;
817 }
818
819 static RPC_STATUS rpcrt4_ncalrpc_authorize(RpcConnection *conn, BOOL first_time,
820 unsigned char *in_buffer,
821 unsigned int in_size,
822 unsigned char *out_buffer,
823 unsigned int *out_size)
824 {
825 /* since this protocol is local to the machine there is no need to
826 * authenticate the caller */
827 *out_size = 0;
828 return RPC_S_OK;
829 }
830
831 static RPC_STATUS rpcrt4_ncalrpc_secure_packet(RpcConnection *conn,
832 enum secure_packet_direction dir,
833 RpcPktHdr *hdr, unsigned int hdr_size,
834 unsigned char *stub_data, unsigned int stub_data_size,
835 RpcAuthVerifier *auth_hdr,
836 unsigned char *auth_value, unsigned int auth_value_size)
837 {
838 /* since this protocol is local to the machine there is no need to secure
839 * the packet */
840 return RPC_S_OK;
841 }
842
843 static RPC_STATUS rpcrt4_ncalrpc_inquire_auth_client(
844 RpcConnection *conn, RPC_AUTHZ_HANDLE *privs, RPC_WSTR *server_princ_name,
845 ULONG *authn_level, ULONG *authn_svc, ULONG *authz_svc, ULONG flags)
846 {
847 TRACE("(%p, %p, %p, %p, %p, %p, 0x%x)\n", conn, privs,
848 server_princ_name, authn_level, authn_svc, authz_svc, flags);
849
850 if (privs)
851 {
852 FIXME("privs not implemented\n");
853 *privs = NULL;
854 }
855 if (server_princ_name)
856 {
857 FIXME("server_princ_name not implemented\n");
858 *server_princ_name = NULL;
859 }
860 if (authn_level) *authn_level = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
861 if (authn_svc) *authn_svc = RPC_C_AUTHN_WINNT;
862 if (authz_svc)
863 {
864 FIXME("authorization service not implemented\n");
865 *authz_svc = RPC_C_AUTHZ_NONE;
866 }
867 if (flags)
868 FIXME("flags 0x%x not implemented\n", flags);
869
870 return RPC_S_OK;
871 }
872
873 /**** ncacn_ip_tcp support ****/
874
875 static size_t rpcrt4_ip_tcp_get_top_of_tower(unsigned char *tower_data,
876 const char *networkaddr,
877 unsigned char tcp_protid,
878 const char *endpoint)
879 {
880 twr_tcp_floor_t *tcp_floor;
881 twr_ipv4_floor_t *ipv4_floor;
882 struct addrinfo *ai;
883 struct addrinfo hints;
884 int ret;
885 size_t size = sizeof(*tcp_floor) + sizeof(*ipv4_floor);
886
887 TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
888
889 if (!tower_data)
890 return size;
891
892 tcp_floor = (twr_tcp_floor_t *)tower_data;
893 tower_data += sizeof(*tcp_floor);
894
895 ipv4_floor = (twr_ipv4_floor_t *)tower_data;
896
897 tcp_floor->count_lhs = sizeof(tcp_floor->protid);
898 tcp_floor->protid = tcp_protid;
899 tcp_floor->count_rhs = sizeof(tcp_floor->port);
900
901 ipv4_floor->count_lhs = sizeof(ipv4_floor->protid);
902 ipv4_floor->protid = EPM_PROTOCOL_IP;
903 ipv4_floor->count_rhs = sizeof(ipv4_floor->ipv4addr);
904
905 hints.ai_flags = AI_NUMERICHOST;
906 /* FIXME: only support IPv4 at the moment. how is IPv6 represented by the EPM? */
907 hints.ai_family = PF_INET;
908 hints.ai_socktype = SOCK_STREAM;
909 hints.ai_protocol = IPPROTO_TCP;
910 hints.ai_addrlen = 0;
911 hints.ai_addr = NULL;
912 hints.ai_canonname = NULL;
913 hints.ai_next = NULL;
914
915 ret = getaddrinfo(networkaddr, endpoint, &hints, &ai);
916 if (ret)
917 {
918 ret = getaddrinfo("0.0.0.0", endpoint, &hints, &ai);
919 if (ret)
920 {
921 ERR("getaddrinfo failed: %s\n", gai_strerror(ret));
922 return 0;
923 }
924 }
925
926 if (ai->ai_family == PF_INET)
927 {
928 const struct sockaddr_in *sin = (const struct sockaddr_in *)ai->ai_addr;
929 tcp_floor->port = sin->sin_port;
930 ipv4_floor->ipv4addr = sin->sin_addr.s_addr;
931 }
932 else
933 {
934 ERR("unexpected protocol family %d\n", ai->ai_family);
935 return 0;
936 }
937
938 freeaddrinfo(ai);
939
940 return size;
941 }
942
943 static RPC_STATUS rpcrt4_ip_tcp_parse_top_of_tower(const unsigned char *tower_data,
944 size_t tower_size,
945 char **networkaddr,
946 unsigned char tcp_protid,
947 char **endpoint)
948 {
949 const twr_tcp_floor_t *tcp_floor = (const twr_tcp_floor_t *)tower_data;
950 const twr_ipv4_floor_t *ipv4_floor;
951 struct in_addr in_addr;
952
953 TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
954
955 if (tower_size < sizeof(*tcp_floor))
956 return EPT_S_NOT_REGISTERED;
957
958 tower_data += sizeof(*tcp_floor);
959 tower_size -= sizeof(*tcp_floor);
960
961 if (tower_size < sizeof(*ipv4_floor))
962 return EPT_S_NOT_REGISTERED;
963
964 ipv4_floor = (const twr_ipv4_floor_t *)tower_data;
965
966 if ((tcp_floor->count_lhs != sizeof(tcp_floor->protid)) ||
967 (tcp_floor->protid != tcp_protid) ||
968 (tcp_floor->count_rhs != sizeof(tcp_floor->port)) ||
969 (ipv4_floor->count_lhs != sizeof(ipv4_floor->protid)) ||
970 (ipv4_floor->protid != EPM_PROTOCOL_IP) ||
971 (ipv4_floor->count_rhs != sizeof(ipv4_floor->ipv4addr)))
972 return EPT_S_NOT_REGISTERED;
973
974 if (endpoint)
975 {
976 *endpoint = I_RpcAllocate(6 /* sizeof("65535") + 1 */);
977 if (!*endpoint)
978 return RPC_S_OUT_OF_RESOURCES;
979 sprintf(*endpoint, "%u", ntohs(tcp_floor->port));
980 }
981
982 if (networkaddr)
983 {
984 *networkaddr = I_RpcAllocate(INET_ADDRSTRLEN);
985 if (!*networkaddr)
986 {
987 if (endpoint)
988 {
989 I_RpcFree(*endpoint);
990 *endpoint = NULL;
991 }
992 return RPC_S_OUT_OF_RESOURCES;
993 }
994 in_addr.s_addr = ipv4_floor->ipv4addr;
995 if (!inet_ntop(AF_INET, &in_addr, *networkaddr, INET_ADDRSTRLEN))
996 {
997 ERR("inet_ntop: %s\n", strerror(errno));
998 I_RpcFree(*networkaddr);
999 *networkaddr = NULL;
1000 if (endpoint)
1001 {
1002 I_RpcFree(*endpoint);
1003 *endpoint = NULL;
1004 }
1005 return EPT_S_NOT_REGISTERED;
1006 }
1007 }
1008
1009 return RPC_S_OK;
1010 }
1011
1012 typedef struct _RpcConnection_tcp
1013 {
1014 RpcConnection common;
1015 int sock;
1016 #ifdef HAVE_SOCKETPAIR
1017 int cancel_fds[2];
1018 #else
1019 HANDLE sock_event;
1020 HANDLE cancel_event;
1021 #endif
1022 } RpcConnection_tcp;
1023
1024 #ifdef HAVE_SOCKETPAIR
1025
1026 static BOOL rpcrt4_sock_wait_init(RpcConnection_tcp *tcpc)
1027 {
1028 if (socketpair(PF_UNIX, SOCK_STREAM, 0, tcpc->cancel_fds) < 0)
1029 {
1030 ERR("socketpair() failed: %s\n", strerror(errno));
1031 return FALSE;
1032 }
1033 return TRUE;
1034 }
1035
1036 static BOOL rpcrt4_sock_wait_for_recv(RpcConnection_tcp *tcpc)
1037 {
1038 struct pollfd pfds[2];
1039 pfds[0].fd = tcpc->sock;
1040 pfds[0].events = POLLIN;
1041 pfds[1].fd = tcpc->cancel_fds[0];
1042 pfds[1].events = POLLIN;
1043 if (poll(pfds, 2, -1 /* infinite */) == -1 && errno != EINTR)
1044 {
1045 ERR("poll() failed: %s\n", strerror(errno));
1046 return FALSE;
1047 }
1048 if (pfds[1].revents & POLLIN) /* canceled */
1049 {
1050 char dummy;
1051 read(pfds[1].fd, &dummy, sizeof(dummy));
1052 return FALSE;
1053 }
1054 return TRUE;
1055 }
1056
1057 static BOOL rpcrt4_sock_wait_for_send(RpcConnection_tcp *tcpc)
1058 {
1059 struct pollfd pfd;
1060 pfd.fd = tcpc->sock;
1061 pfd.events = POLLOUT;
1062 if (poll(&pfd, 1, -1 /* infinite */) == -1 && errno != EINTR)
1063 {
1064 ERR("poll() failed: %s\n", strerror(errno));
1065 return FALSE;
1066 }
1067 return TRUE;
1068 }
1069
1070 static void rpcrt4_sock_wait_cancel(RpcConnection_tcp *tcpc)
1071 {
1072 char dummy = 1;
1073
1074 write(tcpc->cancel_fds[1], &dummy, 1);
1075 }
1076
1077 static void rpcrt4_sock_wait_destroy(RpcConnection_tcp *tcpc)
1078 {
1079 close(tcpc->cancel_fds[0]);
1080 close(tcpc->cancel_fds[1]);
1081 }
1082
1083 #else /* HAVE_SOCKETPAIR */
1084
1085 static BOOL rpcrt4_sock_wait_init(RpcConnection_tcp *tcpc)
1086 {
1087 static BOOL wsa_inited;
1088 if (!wsa_inited)
1089 {
1090 WSADATA wsadata;
1091 WSAStartup(MAKEWORD(2, 2), &wsadata);
1092 /* Note: WSAStartup can be called more than once so we don't bother with
1093 * making accesses to wsa_inited thread-safe */
1094 wsa_inited = TRUE;
1095 }
1096 tcpc->sock_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1097 tcpc->cancel_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1098 if (!tcpc->sock_event || !tcpc->cancel_event)
1099 {
1100 ERR("event creation failed\n");
1101 if (tcpc->sock_event) CloseHandle(tcpc->sock_event);
1102 return FALSE;
1103 }
1104 return TRUE;
1105 }
1106
1107 static BOOL rpcrt4_sock_wait_for_recv(RpcConnection_tcp *tcpc)
1108 {
1109 HANDLE wait_handles[2];
1110 DWORD res;
1111 if (WSAEventSelect(tcpc->sock, tcpc->sock_event, FD_READ | FD_CLOSE) == SOCKET_ERROR)
1112 {
1113 ERR("WSAEventSelect() failed with error %d\n", WSAGetLastError());
1114 return FALSE;
1115 }
1116 wait_handles[0] = tcpc->sock_event;
1117 wait_handles[1] = tcpc->cancel_event;
1118 res = WaitForMultipleObjects(2, wait_handles, FALSE, INFINITE);
1119 switch (res)
1120 {
1121 case WAIT_OBJECT_0:
1122 return TRUE;
1123 case WAIT_OBJECT_0 + 1:
1124 return FALSE;
1125 default:
1126 ERR("WaitForMultipleObjects() failed with error %d\n", GetLastError());
1127 return FALSE;
1128 }
1129 }
1130
1131 static BOOL rpcrt4_sock_wait_for_send(RpcConnection_tcp *tcpc)
1132 {
1133 DWORD res;
1134 if (WSAEventSelect(tcpc->sock, tcpc->sock_event, FD_WRITE | FD_CLOSE) == SOCKET_ERROR)
1135 {
1136 ERR("WSAEventSelect() failed with error %d\n", WSAGetLastError());
1137 return FALSE;
1138 }
1139 res = WaitForSingleObject(tcpc->sock_event, INFINITE);
1140 switch (res)
1141 {
1142 case WAIT_OBJECT_0:
1143 return TRUE;
1144 default:
1145 ERR("WaitForMultipleObjects() failed with error %d\n", GetLastError());
1146 return FALSE;
1147 }
1148 }
1149
1150 static void rpcrt4_sock_wait_cancel(RpcConnection_tcp *tcpc)
1151 {
1152 SetEvent(tcpc->cancel_event);
1153 }
1154
1155 static void rpcrt4_sock_wait_destroy(RpcConnection_tcp *tcpc)
1156 {
1157 CloseHandle(tcpc->sock_event);
1158 CloseHandle(tcpc->cancel_event);
1159 }
1160
1161 #endif
1162
1163 static RpcConnection *rpcrt4_conn_tcp_alloc(void)
1164 {
1165 RpcConnection_tcp *tcpc;
1166 tcpc = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_tcp));
1167 if (tcpc == NULL)
1168 return NULL;
1169 tcpc->sock = -1;
1170 if (!rpcrt4_sock_wait_init(tcpc))
1171 {
1172 HeapFree(GetProcessHeap(), 0, tcpc);
1173 return NULL;
1174 }
1175 return &tcpc->common;
1176 }
1177
1178 static RPC_STATUS rpcrt4_ncacn_ip_tcp_open(RpcConnection* Connection)
1179 {
1180 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1181 int sock;
1182 int ret;
1183 struct addrinfo *ai;
1184 struct addrinfo *ai_cur;
1185 struct addrinfo hints;
1186
1187 TRACE("(%s, %s)\n", Connection->NetworkAddr, Connection->Endpoint);
1188
1189 if (tcpc->sock != -1)
1190 return RPC_S_OK;
1191
1192 hints.ai_flags = 0;
1193 hints.ai_family = PF_UNSPEC;
1194 hints.ai_socktype = SOCK_STREAM;
1195 hints.ai_protocol = IPPROTO_TCP;
1196 hints.ai_addrlen = 0;
1197 hints.ai_addr = NULL;
1198 hints.ai_canonname = NULL;
1199 hints.ai_next = NULL;
1200
1201 ret = getaddrinfo(Connection->NetworkAddr, Connection->Endpoint, &hints, &ai);
1202 if (ret)
1203 {
1204 ERR("getaddrinfo for %s:%s failed: %s\n", Connection->NetworkAddr,
1205 Connection->Endpoint, gai_strerror(ret));
1206 return RPC_S_SERVER_UNAVAILABLE;
1207 }
1208
1209 for (ai_cur = ai; ai_cur; ai_cur = ai_cur->ai_next)
1210 {
1211 int val;
1212 u_long nonblocking;
1213
1214 if (ai_cur->ai_family != AF_INET && ai_cur->ai_family != AF_INET6)
1215 {
1216 TRACE("skipping non-IP/IPv6 address family\n");
1217 continue;
1218 }
1219
1220 if (TRACE_ON(rpc))
1221 {
1222 char host[256];
1223 char service[256];
1224 getnameinfo(ai_cur->ai_addr, ai_cur->ai_addrlen,
1225 host, sizeof(host), service, sizeof(service),
1226 NI_NUMERICHOST | NI_NUMERICSERV);
1227 TRACE("trying %s:%s\n", host, service);
1228 }
1229
1230 sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol);
1231 if (sock == -1)
1232 {
1233 WARN("socket() failed: %s\n", strerror(errno));
1234 continue;
1235 }
1236
1237 if (0>connect(sock, ai_cur->ai_addr, ai_cur->ai_addrlen))
1238 {
1239 WARN("connect() failed: %s\n", strerror(errno));
1240 closesocket(sock);
1241 continue;
1242 }
1243
1244 /* RPC depends on having minimal latency so disable the Nagle algorithm */
1245 val = 1;
1246 setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
1247 nonblocking = 1;
1248 ioctlsocket(sock, FIONBIO, &nonblocking);
1249
1250 tcpc->sock = sock;
1251
1252 freeaddrinfo(ai);
1253 TRACE("connected\n");
1254 return RPC_S_OK;
1255 }
1256
1257 freeaddrinfo(ai);
1258 ERR("couldn't connect to %s:%s\n", Connection->NetworkAddr, Connection->Endpoint);
1259 return RPC_S_SERVER_UNAVAILABLE;
1260 }
1261
1262 static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *protseq, const char *endpoint)
1263 {
1264 RPC_STATUS status = RPC_S_CANT_CREATE_ENDPOINT;
1265 int sock;
1266 int ret;
1267 struct addrinfo *ai;
1268 struct addrinfo *ai_cur;
1269 struct addrinfo hints;
1270 RpcConnection *first_connection = NULL;
1271
1272 TRACE("(%p, %s)\n", protseq, endpoint);
1273
1274 hints.ai_flags = AI_PASSIVE /* for non-localhost addresses */;
1275 hints.ai_family = PF_UNSPEC;
1276 hints.ai_socktype = SOCK_STREAM;
1277 hints.ai_protocol = IPPROTO_TCP;
1278 hints.ai_addrlen = 0;
1279 hints.ai_addr = NULL;
1280 hints.ai_canonname = NULL;
1281 hints.ai_next = NULL;
1282
1283 ret = getaddrinfo(NULL, endpoint ? endpoint : "0", &hints, &ai);
1284 if (ret)
1285 {
1286 ERR("getaddrinfo for port %s failed: %s\n", endpoint,
1287 gai_strerror(ret));
1288 if ((ret == EAI_SERVICE) || (ret == EAI_NONAME))
1289 return RPC_S_INVALID_ENDPOINT_FORMAT;
1290 return RPC_S_CANT_CREATE_ENDPOINT;
1291 }
1292
1293 for (ai_cur = ai; ai_cur; ai_cur = ai_cur->ai_next)
1294 {
1295 RpcConnection_tcp *tcpc;
1296 RPC_STATUS create_status;
1297 struct sockaddr_storage sa;
1298 socklen_t sa_len;
1299 char service[NI_MAXSERV];
1300 u_long nonblocking;
1301
1302 if (ai_cur->ai_family != AF_INET && ai_cur->ai_family != AF_INET6)
1303 {
1304 TRACE("skipping non-IP/IPv6 address family\n");
1305 continue;
1306 }
1307
1308 if (TRACE_ON(rpc))
1309 {
1310 char host[256];
1311 getnameinfo(ai_cur->ai_addr, ai_cur->ai_addrlen,
1312 host, sizeof(host), service, sizeof(service),
1313 NI_NUMERICHOST | NI_NUMERICSERV);
1314 TRACE("trying %s:%s\n", host, service);
1315 }
1316
1317 sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol);
1318 if (sock == -1)
1319 {
1320 WARN("socket() failed: %s\n", strerror(errno));
1321 status = RPC_S_CANT_CREATE_ENDPOINT;
1322 continue;
1323 }
1324
1325 ret = bind(sock, ai_cur->ai_addr, ai_cur->ai_addrlen);
1326 if (ret < 0)
1327 {
1328 WARN("bind failed: %s\n", strerror(errno));
1329 closesocket(sock);
1330 if (errno == EADDRINUSE)
1331 status = RPC_S_DUPLICATE_ENDPOINT;
1332 else
1333 status = RPC_S_CANT_CREATE_ENDPOINT;
1334 continue;
1335 }
1336
1337 sa_len = sizeof(sa);
1338 if (getsockname(sock, (struct sockaddr *)&sa, &sa_len))
1339 {
1340 WARN("getsockname() failed: %s\n", strerror(errno));
1341 status = RPC_S_CANT_CREATE_ENDPOINT;
1342 continue;
1343 }
1344
1345 ret = getnameinfo((struct sockaddr *)&sa, sa_len,
1346 NULL, 0, service, sizeof(service),
1347 NI_NUMERICSERV);
1348 if (ret)
1349 {
1350 WARN("getnameinfo failed: %s\n", gai_strerror(ret));
1351 status = RPC_S_CANT_CREATE_ENDPOINT;
1352 continue;
1353 }
1354
1355 create_status = RPCRT4_CreateConnection((RpcConnection **)&tcpc, TRUE,
1356 protseq->Protseq, NULL,
1357 service, NULL, NULL, NULL);
1358 if (create_status != RPC_S_OK)
1359 {
1360 closesocket(sock);
1361 status = create_status;
1362 continue;
1363 }
1364
1365 tcpc->sock = sock;
1366 ret = listen(sock, protseq->MaxCalls);
1367 if (ret < 0)
1368 {
1369 WARN("listen failed: %s\n", strerror(errno));
1370 RPCRT4_DestroyConnection(&tcpc->common);
1371 status = RPC_S_OUT_OF_RESOURCES;
1372 continue;
1373 }
1374 /* need a non-blocking socket, otherwise accept() has a potential
1375 * race-condition (poll() says it is readable, connection drops,
1376 * and accept() blocks until the next connection comes...)
1377 */
1378 nonblocking = 1;
1379 ret = ioctlsocket(sock, FIONBIO, &nonblocking);
1380 if (ret < 0)
1381 {
1382 WARN("couldn't make socket non-blocking, error %d\n", ret);
1383 RPCRT4_DestroyConnection(&tcpc->common);
1384 status = RPC_S_OUT_OF_RESOURCES;
1385 continue;
1386 }
1387
1388 tcpc->common.Next = first_connection;
1389 first_connection = &tcpc->common;
1390
1391 /* since IPv4 and IPv6 share the same port space, we only need one
1392 * successful bind to listen for both */
1393 break;
1394 }
1395
1396 freeaddrinfo(ai);
1397
1398 /* if at least one connection was created for an endpoint then
1399 * return success */
1400 if (first_connection)
1401 {
1402 RpcConnection *conn;
1403
1404 /* find last element in list */
1405 for (conn = first_connection; conn->Next; conn = conn->Next)
1406 ;
1407
1408 EnterCriticalSection(&protseq->cs);
1409 conn->Next = protseq->conn;
1410 protseq->conn = first_connection;
1411 LeaveCriticalSection(&protseq->cs);
1412
1413 TRACE("listening on %s\n", endpoint);
1414 return RPC_S_OK;
1415 }
1416
1417 ERR("couldn't listen on port %s\n", endpoint);
1418 return status;
1419 }
1420
1421 static RPC_STATUS rpcrt4_conn_tcp_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
1422 {
1423 int ret;
1424 struct sockaddr_in address;
1425 socklen_t addrsize;
1426 RpcConnection_tcp *server = (RpcConnection_tcp*) old_conn;
1427 RpcConnection_tcp *client = (RpcConnection_tcp*) new_conn;
1428 u_long nonblocking;
1429
1430 addrsize = sizeof(address);
1431 ret = accept(server->sock, (struct sockaddr*) &address, &addrsize);
1432 if (ret < 0)
1433 {
1434 ERR("Failed to accept a TCP connection: error %d\n", ret);
1435 return RPC_S_OUT_OF_RESOURCES;
1436 }
1437 nonblocking = 1;
1438 ioctlsocket(ret, FIONBIO, &nonblocking);
1439 client->sock = ret;
1440 TRACE("Accepted a new TCP connection\n");
1441 return RPC_S_OK;
1442 }
1443
1444 static int rpcrt4_conn_tcp_read(RpcConnection *Connection,
1445 void *buffer, unsigned int count)
1446 {
1447 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1448 int bytes_read = 0;
1449 while (bytes_read != count)
1450 {
1451 int r = recv(tcpc->sock, (char *)buffer + bytes_read, count - bytes_read, 0);
1452 if (!r)
1453 return -1;
1454 else if (r > 0)
1455 bytes_read += r;
1456 else if (errno != EAGAIN)
1457 {
1458 WARN("recv() failed: %s\n", strerror(errno));
1459 return -1;
1460 }
1461 else
1462 {
1463 if (!rpcrt4_sock_wait_for_recv(tcpc))
1464 return -1;
1465 }
1466 }
1467 TRACE("%d %p %u -> %d\n", tcpc->sock, buffer, count, bytes_read);
1468 return bytes_read;
1469 }
1470
1471 static int rpcrt4_conn_tcp_write(RpcConnection *Connection,
1472 const void *buffer, unsigned int count)
1473 {
1474 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1475 int bytes_written = 0;
1476 while (bytes_written != count)
1477 {
1478 int r = send(tcpc->sock, (const char *)buffer + bytes_written, count - bytes_written, 0);
1479 if (r >= 0)
1480 bytes_written += r;
1481 else if (errno != EAGAIN)
1482 return -1;
1483 else
1484 {
1485 if (!rpcrt4_sock_wait_for_send(tcpc))
1486 return -1;
1487 }
1488 }
1489 TRACE("%d %p %u -> %d\n", tcpc->sock, buffer, count, bytes_written);
1490 return bytes_written;
1491 }
1492
1493 static int rpcrt4_conn_tcp_close(RpcConnection *Connection)
1494 {
1495 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1496
1497 TRACE("%d\n", tcpc->sock);
1498
1499 if (tcpc->sock != -1)
1500 closesocket(tcpc->sock);
1501 tcpc->sock = -1;
1502 rpcrt4_sock_wait_destroy(tcpc);
1503 return 0;
1504 }
1505
1506 static void rpcrt4_conn_tcp_cancel_call(RpcConnection *Connection)
1507 {
1508 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1509 TRACE("%p\n", Connection);
1510 rpcrt4_sock_wait_cancel(tcpc);
1511 }
1512
1513 static int rpcrt4_conn_tcp_wait_for_incoming_data(RpcConnection *Connection)
1514 {
1515 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1516
1517 TRACE("%p\n", Connection);
1518
1519 if (!rpcrt4_sock_wait_for_recv(tcpc))
1520 return -1;
1521 return 0;
1522 }
1523
1524 static size_t rpcrt4_ncacn_ip_tcp_get_top_of_tower(unsigned char *tower_data,
1525 const char *networkaddr,
1526 const char *endpoint)
1527 {
1528 return rpcrt4_ip_tcp_get_top_of_tower(tower_data, networkaddr,
1529 EPM_PROTOCOL_TCP, endpoint);
1530 }
1531
1532 #ifdef HAVE_SOCKETPAIR
1533
1534 typedef struct _RpcServerProtseq_sock
1535 {
1536 RpcServerProtseq common;
1537 int mgr_event_rcv;
1538 int mgr_event_snd;
1539 } RpcServerProtseq_sock;
1540
1541 static RpcServerProtseq *rpcrt4_protseq_sock_alloc(void)
1542 {
1543 RpcServerProtseq_sock *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps));
1544 if (ps)
1545 {
1546 int fds[2];
1547 if (!socketpair(PF_UNIX, SOCK_DGRAM, 0, fds))
1548 {
1549 fcntl(fds[0], F_SETFL, O_NONBLOCK);
1550 fcntl(fds[1], F_SETFL, O_NONBLOCK);
1551 ps->mgr_event_rcv = fds[0];
1552 ps->mgr_event_snd = fds[1];
1553 }
1554 else
1555 {
1556 ERR("socketpair failed with error %s\n", strerror(errno));
1557 HeapFree(GetProcessHeap(), 0, ps);
1558 return NULL;
1559 }
1560 }
1561 return &ps->common;
1562 }
1563
1564 static void rpcrt4_protseq_sock_signal_state_changed(RpcServerProtseq *protseq)
1565 {
1566 RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common);
1567 char dummy = 1;
1568 write(sockps->mgr_event_snd, &dummy, sizeof(dummy));
1569 }
1570
1571 static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
1572 {
1573 struct pollfd *poll_info = prev_array;
1574 RpcConnection_tcp *conn;
1575 RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common);
1576
1577 EnterCriticalSection(&protseq->cs);
1578
1579 /* open and count connections */
1580 *count = 1;
1581 conn = (RpcConnection_tcp *)protseq->conn;
1582 while (conn) {
1583 if (conn->sock != -1)
1584 (*count)++;
1585 conn = (RpcConnection_tcp *)conn->common.Next;
1586 }
1587
1588 /* make array of connections */
1589 if (poll_info)
1590 poll_info = HeapReAlloc(GetProcessHeap(), 0, poll_info, *count*sizeof(*poll_info));
1591 else
1592 poll_info = HeapAlloc(GetProcessHeap(), 0, *count*sizeof(*poll_info));
1593 if (!poll_info)
1594 {
1595 ERR("couldn't allocate poll_info\n");
1596 LeaveCriticalSection(&protseq->cs);
1597 return NULL;
1598 }
1599
1600 poll_info[0].fd = sockps->mgr_event_rcv;
1601 poll_info[0].events = POLLIN;
1602 *count = 1;
1603 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1604 while (conn) {
1605 if (conn->sock != -1)
1606 {
1607 poll_info[*count].fd = conn->sock;
1608 poll_info[*count].events = POLLIN;
1609 (*count)++;
1610 }
1611 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1612 }
1613 LeaveCriticalSection(&protseq->cs);
1614 return poll_info;
1615 }
1616
1617 static void rpcrt4_protseq_sock_free_wait_array(RpcServerProtseq *protseq, void *array)
1618 {
1619 HeapFree(GetProcessHeap(), 0, array);
1620 }
1621
1622 static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array)
1623 {
1624 struct pollfd *poll_info = wait_array;
1625 int ret;
1626 unsigned int i;
1627 RpcConnection *cconn;
1628 RpcConnection_tcp *conn;
1629
1630 if (!poll_info)
1631 return -1;
1632
1633 ret = poll(poll_info, count, -1);
1634 if (ret < 0)
1635 {
1636 ERR("poll failed with error %d\n", ret);
1637 return -1;
1638 }
1639
1640 for (i = 0; i < count; i++)
1641 if (poll_info[i].revents & POLLIN)
1642 {
1643 /* RPC server event */
1644 if (i == 0)
1645 {
1646 char dummy;
1647 read(poll_info[0].fd, &dummy, sizeof(dummy));
1648 return 0;
1649 }
1650
1651 /* find which connection got a RPC */
1652 EnterCriticalSection(&protseq->cs);
1653 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1654 while (conn) {
1655 if (poll_info[i].fd == conn->sock) break;
1656 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1657 }
1658 cconn = NULL;
1659 if (conn)
1660 RPCRT4_SpawnConnection(&cconn, &conn->common);
1661 else
1662 ERR("failed to locate connection for fd %d\n", poll_info[i].fd);
1663 LeaveCriticalSection(&protseq->cs);
1664 if (cconn)
1665 RPCRT4_new_client(cconn);
1666 else
1667 return -1;
1668 }
1669
1670 return 1;
1671 }
1672
1673 #else /* HAVE_SOCKETPAIR */
1674
1675 typedef struct _RpcServerProtseq_sock
1676 {
1677 RpcServerProtseq common;
1678 HANDLE mgr_event;
1679 } RpcServerProtseq_sock;
1680
1681 static RpcServerProtseq *rpcrt4_protseq_sock_alloc(void)
1682 {
1683 RpcServerProtseq_sock *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps));
1684 if (ps)
1685 {
1686 static BOOL wsa_inited;
1687 if (!wsa_inited)
1688 {
1689 WSADATA wsadata;
1690 WSAStartup(MAKEWORD(2, 2), &wsadata);
1691 /* Note: WSAStartup can be called more than once so we don't bother with
1692 * making accesses to wsa_inited thread-safe */
1693 wsa_inited = TRUE;
1694 }
1695 ps->mgr_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1696 }
1697 return &ps->common;
1698 }
1699
1700 static void rpcrt4_protseq_sock_signal_state_changed(RpcServerProtseq *protseq)
1701 {
1702 RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common);
1703 SetEvent(sockps->mgr_event);
1704 }
1705
1706 static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
1707 {
1708 HANDLE *objs = prev_array;
1709 RpcConnection_tcp *conn;
1710 RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common);
1711
1712 EnterCriticalSection(&protseq->cs);
1713
1714 /* open and count connections */
1715 *count = 1;
1716 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1717 while (conn)
1718 {
1719 if (conn->sock != -1)
1720 (*count)++;
1721 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1722 }
1723
1724 /* make array of connections */
1725 if (objs)
1726 objs = HeapReAlloc(GetProcessHeap(), 0, objs, *count*sizeof(HANDLE));
1727 else
1728 objs = HeapAlloc(GetProcessHeap(), 0, *count*sizeof(HANDLE));
1729 if (!objs)
1730 {
1731 ERR("couldn't allocate objs\n");
1732 LeaveCriticalSection(&protseq->cs);
1733 return NULL;
1734 }
1735
1736 objs[0] = sockps->mgr_event;
1737 *count = 1;
1738 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1739 while (conn)
1740 {
1741 if (conn->sock != -1)
1742 {
1743 int res = WSAEventSelect(conn->sock, conn->sock_event, FD_ACCEPT);
1744 if (res == SOCKET_ERROR)
1745 ERR("WSAEventSelect() failed with error %d\n", WSAGetLastError());
1746 else
1747 {
1748 objs[*count] = conn->sock_event;
1749 (*count)++;
1750 }
1751 }
1752 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1753 }
1754 LeaveCriticalSection(&protseq->cs);
1755 return objs;
1756 }
1757
1758 static void rpcrt4_protseq_sock_free_wait_array(RpcServerProtseq *protseq, void *array)
1759 {
1760 HeapFree(GetProcessHeap(), 0, array);
1761 }
1762
1763 static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array)
1764 {
1765 HANDLE b_handle;
1766 HANDLE *objs = wait_array;
1767 DWORD res;
1768 RpcConnection *cconn;
1769 RpcConnection_tcp *conn;
1770
1771 if (!objs)
1772 return -1;
1773
1774 do
1775 {
1776 /* an alertable wait isn't strictly necessary, but due to our
1777 * overlapped I/O implementation in Wine we need to free some memory
1778 * by the file user APC being called, even if no completion routine was
1779 * specified at the time of starting the async operation */
1780 res = WaitForMultipleObjectsEx(count, objs, FALSE, INFINITE, TRUE);
1781 } while (res == WAIT_IO_COMPLETION);
1782
1783 if (res == WAIT_OBJECT_0)
1784 return 0;
1785 else if (res == WAIT_FAILED)
1786 {
1787 ERR("wait failed with error %d\n", GetLastError());
1788 return -1;
1789 }
1790 else
1791 {
1792 b_handle = objs[res - WAIT_OBJECT_0];
1793 /* find which connection got a RPC */
1794 EnterCriticalSection(&protseq->cs);
1795 conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1796 while (conn)
1797 {
1798 if (b_handle == conn->sock_event) break;
1799 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1800 }
1801 cconn = NULL;
1802 if (conn)
1803 RPCRT4_SpawnConnection(&cconn, &conn->common);
1804 else
1805 ERR("failed to locate connection for handle %p\n", b_handle);
1806 LeaveCriticalSection(&protseq->cs);
1807 if (cconn)
1808 {
1809 RPCRT4_new_client(cconn);
1810 return 1;
1811 }
1812 else return -1;
1813 }
1814 }
1815
1816 #endif /* HAVE_SOCKETPAIR */
1817
1818 static RPC_STATUS rpcrt4_ncacn_ip_tcp_parse_top_of_tower(const unsigned char *tower_data,
1819 size_t tower_size,
1820 char **networkaddr,
1821 char **endpoint)
1822 {
1823 return rpcrt4_ip_tcp_parse_top_of_tower(tower_data, tower_size,
1824 networkaddr, EPM_PROTOCOL_TCP,
1825 endpoint);
1826 }
1827
1828 /**** ncacn_http support ****/
1829
1830 /* 60 seconds is the period native uses */
1831 #define HTTP_IDLE_TIME 60000
1832
1833 /* reference counted to avoid a race between a cancelled call's connection
1834 * being destroyed and the asynchronous InternetReadFileEx call being
1835 * completed */
1836 typedef struct _RpcHttpAsyncData
1837 {
1838 LONG refs;
1839 HANDLE completion_event;
1840 INTERNET_BUFFERSA inet_buffers;
1841 void *destination_buffer; /* the address that inet_buffers.lpvBuffer will be
1842 * copied into when the call completes */
1843 CRITICAL_SECTION cs;
1844 } RpcHttpAsyncData;
1845
1846 static ULONG RpcHttpAsyncData_AddRef(RpcHttpAsyncData *data)
1847 {
1848 return InterlockedIncrement(&data->refs);
1849 }
1850
1851 static ULONG RpcHttpAsyncData_Release(RpcHttpAsyncData *data)
1852 {
1853 ULONG refs = InterlockedDecrement(&data->refs);
1854 if (!refs)
1855 {
1856 TRACE("destroying async data %p\n", data);
1857 CloseHandle(data->completion_event);
1858 HeapFree(GetProcessHeap(), 0, data->inet_buffers.lpvBuffer);
1859 DeleteCriticalSection(&data->cs);
1860 HeapFree(GetProcessHeap(), 0, data);
1861 }
1862 return refs;
1863 }
1864
1865 typedef struct _RpcConnection_http
1866 {
1867 RpcConnection common;
1868 HINTERNET app_info;
1869 HINTERNET session;
1870 HINTERNET in_request;
1871 HINTERNET out_request;
1872 HANDLE timer_cancelled;
1873 HANDLE cancel_event;
1874 DWORD last_sent_time;
1875 ULONG bytes_received;
1876 ULONG flow_control_mark; /* send a control packet to the server when this many bytes received */
1877 ULONG flow_control_increment; /* number of bytes to increment flow_control_mark by */
1878 UUID connection_uuid;
1879 UUID in_pipe_uuid;
1880 UUID out_pipe_uuid;
1881 RpcHttpAsyncData *async_data;
1882 } RpcConnection_http;
1883
1884 static RpcConnection *rpcrt4_ncacn_http_alloc(void)
1885 {
1886 RpcConnection_http *httpc;
1887 httpc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*httpc));
1888 if (!httpc) return NULL;
1889 httpc->async_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcHttpAsyncData));
1890 if (!httpc->async_data)
1891 {
1892 HeapFree(GetProcessHeap(), 0, httpc);
1893 return NULL;
1894 }
1895 TRACE("async data = %p\n", httpc->async_data);
1896 httpc->cancel_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1897 httpc->async_data->refs = 1;
1898 httpc->async_data->inet_buffers.dwStructSize = sizeof(INTERNET_BUFFERSA);
1899 httpc->async_data->inet_buffers.lpvBuffer = NULL;
1900 httpc->async_data->destination_buffer = NULL;
1901 InitializeCriticalSection(&httpc->async_data->cs);
1902 return &httpc->common;
1903 }
1904
1905 typedef struct _HttpTimerThreadData
1906 {
1907 PVOID timer_param;
1908 DWORD *last_sent_time;
1909 HANDLE timer_cancelled;
1910 } HttpTimerThreadData;
1911
1912 static VOID rpcrt4_http_keep_connection_active_timer_proc(PVOID param, BOOLEAN dummy)
1913 {
1914 HINTERNET in_request = param;
1915 RpcPktHdr *idle_pkt;
1916
1917 idle_pkt = RPCRT4_BuildHttpHeader(NDR_LOCAL_DATA_REPRESENTATION, 0x0001,
1918 0, 0);
1919 if (idle_pkt)
1920 {
1921 DWORD bytes_written;
1922 InternetWriteFile(in_request, idle_pkt, idle_pkt->common.frag_len, &bytes_written);
1923 RPCRT4_FreeHeader(idle_pkt);
1924 }
1925 }
1926
1927 static inline DWORD rpcrt4_http_timer_calc_timeout(DWORD *last_sent_time)
1928 {
1929 DWORD cur_time = GetTickCount();
1930 DWORD cached_last_sent_time = *last_sent_time;
1931 return HTTP_IDLE_TIME - (cur_time - cached_last_sent_time > HTTP_IDLE_TIME ? 0 : cur_time - cached_last_sent_time);
1932 }
1933
1934 static DWORD CALLBACK rpcrt4_http_timer_thread(PVOID param)
1935 {
1936 HttpTimerThreadData *data_in = param;
1937 HttpTimerThreadData data;
1938 DWORD timeout;
1939
1940 data = *data_in;
1941 HeapFree(GetProcessHeap(), 0, data_in);
1942
1943 for (timeout = HTTP_IDLE_TIME;
1944 WaitForSingleObject(data.timer_cancelled, timeout) == WAIT_TIMEOUT;
1945 timeout = rpcrt4_http_timer_calc_timeout(data.last_sent_time))
1946 {
1947 /* are we too soon after last send? */
1948 if (GetTickCount() - HTTP_IDLE_TIME < *data.last_sent_time)
1949 continue;
1950 rpcrt4_http_keep_connection_active_timer_proc(data.timer_param, TRUE);
1951 }
1952
1953 CloseHandle(data.timer_cancelled);
1954 return 0;
1955 }
1956
1957 static VOID WINAPI rpcrt4_http_internet_callback(
1958 HINTERNET hInternet,
1959 DWORD_PTR dwContext,
1960 DWORD dwInternetStatus,
1961 LPVOID lpvStatusInformation,
1962 DWORD dwStatusInformationLength)
1963 {
1964 RpcHttpAsyncData *async_data = (RpcHttpAsyncData *)dwContext;
1965
1966 switch (dwInternetStatus)
1967 {
1968 case INTERNET_STATUS_REQUEST_COMPLETE:
1969 TRACE("INTERNET_STATUS_REQUEST_COMPLETED\n");
1970 if (async_data)
1971 {
1972 if (async_data->inet_buffers.lpvBuffer)
1973 {
1974 EnterCriticalSection(&async_data->cs);
1975 if (async_data->destination_buffer)
1976 {
1977 memcpy(async_data->destination_buffer,
1978 async_data->inet_buffers.lpvBuffer,
1979 async_data->inet_buffers.dwBufferLength);
1980 async_data->destination_buffer = NULL;
1981 }
1982 LeaveCriticalSection(&async_data->cs);
1983 }
1984 HeapFree(GetProcessHeap(), 0, async_data->inet_buffers.lpvBuffer);
1985 async_data->inet_buffers.lpvBuffer = NULL;
1986 SetEvent(async_data->completion_event);
1987 RpcHttpAsyncData_Release(async_data);
1988 }
1989 break;
1990 }
1991 }
1992
1993 static RPC_STATUS rpcrt4_http_check_response(HINTERNET hor)
1994 {
1995 BOOL ret;
1996 DWORD status_code;
1997 DWORD size;
1998 DWORD index;
1999 WCHAR buf[32];
2000 WCHAR *status_text = buf;
2001 TRACE("\n");
2002
2003 index = 0;
2004 size = sizeof(status_code);
2005 ret = HttpQueryInfoW(hor, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status_code, &size, &index);
2006 if (!ret)
2007 return GetLastError();
2008 if (status_code < 400)
2009 return RPC_S_OK;
2010 index = 0;
2011 size = sizeof(buf);
2012 ret = HttpQueryInfoW(hor, HTTP_QUERY_STATUS_TEXT, status_text, &size, &index);
2013 if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
2014 {
2015 status_text = HeapAlloc(GetProcessHeap(), 0, size);
2016 ret = HttpQueryInfoW(hor, HTTP_QUERY_STATUS_TEXT, status_text, &size, &index);
2017 }
2018
2019 ERR("server returned: %d %s\n", status_code, ret ? debugstr_w(status_text) : "<status text unavailable>");
2020 if(status_text != buf) HeapFree(GetProcessHeap(), 0, status_text);
2021
2022 if (status_code == HTTP_STATUS_DENIED)
2023 return ERROR_ACCESS_DENIED;
2024 return RPC_S_SERVER_UNAVAILABLE;
2025 }
2026
2027 static RPC_STATUS rpcrt4_http_internet_connect(RpcConnection_http *httpc)
2028 {
2029 static const WCHAR wszUserAgent[] = {'M','S','R','P','C',0};
2030 LPWSTR proxy = NULL;
2031 LPWSTR user = NULL;
2032 LPWSTR password = NULL;
2033 LPWSTR servername = NULL;
2034 const WCHAR *option;
2035 INTERNET_PORT port = INTERNET_INVALID_PORT_NUMBER; /* use default port */
2036
2037 if (httpc->common.QOS &&
2038 (httpc->common.QOS->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP))
2039 {
2040 const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_cred = httpc->common.QOS->qos->u.HttpCredentials;
2041 if (http_cred->TransportCredentials)
2042 {
2043 WCHAR *p;
2044 const SEC_WINNT_AUTH_IDENTITY_W *cred = http_cred->TransportCredentials;
2045 ULONG len = cred->DomainLength + 1 + cred->UserLength;
2046 user = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
2047 if (!user)
2048 return RPC_S_OUT_OF_RESOURCES;
2049 p = user;
2050 if (cred->DomainLength)
2051 {
2052 memcpy(p, cred->Domain, cred->DomainLength * sizeof(WCHAR));
2053 p += cred->DomainLength;
2054 *p = '\\';
2055 p++;
2056 }
2057 memcpy(p, cred->User, cred->UserLength * sizeof(WCHAR));
2058 p[cred->UserLength] = 0;
2059
2060 password = RPCRT4_strndupW(cred->Password, cred->PasswordLength);
2061 }
2062 }
2063
2064 for (option = httpc->common.NetworkOptions; option;
2065 option = (strchrW(option, ',') ? strchrW(option, ',')+1 : NULL))
2066 {
2067 static const WCHAR wszRpcProxy[] = {'R','p','c','P','r','o','x','y','=',0};
2068 static const WCHAR wszHttpProxy[] = {'H','t','t','p','P','r','o','x','y','=',0};
2069
2070 if (!strncmpiW(option, wszRpcProxy, sizeof(wszRpcProxy)/sizeof(wszRpcProxy[0])-1))
2071 {
2072 const WCHAR *value_start = option + sizeof(wszRpcProxy)/sizeof(wszRpcProxy[0])-1;
2073 const WCHAR *value_end;
2074 const WCHAR *p;
2075
2076 value_end = strchrW(option, ',');
2077 if (!value_end)
2078 value_end = value_start + strlenW(value_start);
2079 for (p = value_start; p < value_end; p++)
2080 if (*p == ':')
2081 {
2082 port = atoiW(p+1);
2083 value_end = p;
2084 break;
2085 }
2086 TRACE("RpcProxy value is %s\n", debugstr_wn(value_start, value_end-value_start));
2087 servername = RPCRT4_strndupW(value_start, value_end-value_start);
2088 }
2089 else if (!strncmpiW(option, wszHttpProxy, sizeof(wszHttpProxy)/sizeof(wszHttpProxy[0])-1))
2090 {
2091 const WCHAR *value_start = option + sizeof(wszHttpProxy)/sizeof(wszHttpProxy[0])-1;
2092 const WCHAR *value_end;
2093
2094 value_end = strchrW(option, ',');
2095 if (!value_end)
2096 value_end = value_start + strlenW(value_start);
2097 TRACE("HttpProxy value is %s\n", debugstr_wn(value_start, value_end-value_start));
2098 proxy = RPCRT4_strndupW(value_start, value_end-value_start);
2099 }
2100 else
2101 FIXME("unhandled option %s\n", debugstr_w(option));
2102 }
2103
2104 httpc->app_info = InternetOpenW(wszUserAgent, proxy ? INTERNET_OPEN_TYPE_PROXY : INTERNET_OPEN_TYPE_PRECONFIG,
2105 NULL, NULL, INTERNET_FLAG_ASYNC);
2106 if (!httpc->app_info)
2107 {
2108 HeapFree(GetProcessHeap(), 0, password);
2109 HeapFree(GetProcessHeap(), 0, user);
2110 ERR("InternetOpenW failed with error %d\n", GetLastError());
2111 return RPC_S_SERVER_UNAVAILABLE;
2112 }
2113 InternetSetStatusCallbackW(httpc->app_info, rpcrt4_http_internet_callback);
2114
2115 /* if no RpcProxy option specified, set the HTTP server address to the
2116 * RPC server address */
2117 if (!servername)
2118 {
2119 servername = HeapAlloc(GetProcessHeap(), 0, (strlen(httpc->common.NetworkAddr) + 1)*sizeof(WCHAR));
2120 if (!servername)
2121 {
2122 HeapFree(GetProcessHeap(), 0, password);
2123 HeapFree(GetProcessHeap(), 0, user);
2124 return RPC_S_OUT_OF_RESOURCES;
2125 }
2126 MultiByteToWideChar(CP_ACP, 0, httpc->common.NetworkAddr, -1, servername, strlen(httpc->common.NetworkAddr) + 1);
2127 }
2128
2129 httpc->session = InternetConnectW(httpc->app_info, servername, port, user, password,
2130 INTERNET_SERVICE_HTTP, 0, 0);
2131
2132 HeapFree(GetProcessHeap(), 0, password);
2133 HeapFree(GetProcessHeap(), 0, user);
2134 HeapFree(GetProcessHeap(), 0, servername);
2135
2136 if (!httpc->session)
2137 {
2138 ERR("InternetConnectW failed with error %d\n", GetLastError());
2139 return RPC_S_SERVER_UNAVAILABLE;
2140 }
2141
2142 return RPC_S_OK;
2143 }
2144
2145 /* prepare the in pipe for use by RPC packets */
2146 static RPC_STATUS rpcrt4_http_prepare_in_pipe(HINTERNET in_request, RpcHttpAsyncData *async_data,
2147 const UUID *connection_uuid,
2148 const UUID *in_pipe_uuid,
2149 const UUID *association_uuid)
2150 {
2151 BYTE packet[44];
2152 BOOL ret;
2153 RPC_STATUS status;
2154 RpcPktHdr *hdr;
2155 INTERNET_BUFFERSW buffers_in;
2156 DWORD bytes_read, bytes_written;
2157
2158 /* prepare in pipe */
2159 ResetEvent(async_data->completion_event);
2160 RpcHttpAsyncData_AddRef(async_data);
2161 ret = HttpSendRequestW(in_request, NULL, 0, NULL, 0);
2162 if (!ret)
2163 {
2164 if (GetLastError() == ERROR_IO_PENDING)
2165 WaitForSingleObject(async_data->completion_event, INFINITE);
2166 else
2167 {
2168 RpcHttpAsyncData_Release(async_data);
2169 ERR("HttpSendRequestW failed with error %d\n", GetLastError());
2170 return RPC_S_SERVER_UNAVAILABLE;
2171 }
2172 }
2173 status = rpcrt4_http_check_response(in_request);
2174 if (status != RPC_S_OK) return status;
2175
2176 InternetReadFile(in_request, packet, 20, &bytes_read);
2177 /* FIXME: do something with retrieved data */
2178
2179 memset(&buffers_in, 0, sizeof(buffers_in));
2180 buffers_in.dwStructSize = sizeof(buffers_in);
2181 /* FIXME: get this from the registry */
2182 buffers_in.dwBufferTotal = 1024 * 1024 * 1024; /* 1Gb */
2183 ResetEvent(async_data->completion_event);
2184 RpcHttpAsyncData_AddRef(async_data);
2185 ret = HttpSendRequestExW(in_request, &buffers_in, NULL, 0, 0);
2186 if (!ret)
2187 {
2188 if (GetLastError() == ERROR_IO_PENDING)
2189 WaitForSingleObject(async_data->completion_event, INFINITE);
2190 else
2191 {
2192 RpcHttpAsyncData_Release(async_data);
2193 ERR("HttpSendRequestExW failed with error %d\n", GetLastError());
2194 return RPC_S_SERVER_UNAVAILABLE;
2195 }
2196 }
2197
2198 TRACE("sending HTTP connect header to server\n");
2199 hdr = RPCRT4_BuildHttpConnectHeader(0, FALSE, connection_uuid, in_pipe_uuid, association_uuid);
2200 if (!hdr) return RPC_S_OUT_OF_RESOURCES;
2201 ret = InternetWriteFile(in_request, hdr, hdr->common.frag_len, &bytes_written);
2202 RPCRT4_FreeHeader(hdr);
2203 if (!ret)
2204 {
2205 ERR("InternetWriteFile failed with error %d\n", GetLastError());
2206 return RPC_S_SERVER_UNAVAILABLE;
2207 }
2208
2209 return RPC_S_OK;
2210 }
2211
2212 static RPC_STATUS rpcrt4_http_read_http_packet(HINTERNET request, RpcPktHdr *hdr, BYTE **data)
2213 {
2214 BOOL ret;
2215 DWORD bytes_read;
2216 unsigned short data_len;
2217
2218 ret = InternetReadFile(request, hdr, sizeof(hdr->common), &bytes_read);
2219 if (!ret)
2220 return RPC_S_SERVER_UNAVAILABLE;
2221 if (hdr->common.ptype != PKT_HTTP || hdr->common.frag_len < sizeof(hdr->http))
2222 {
2223 ERR("wrong packet type received %d or wrong frag_len %d\n",
2224 hdr->common.ptype, hdr->common.frag_len);
2225 return RPC_S_PROTOCOL_ERROR;
2226 }
2227
2228 ret = InternetReadFile(request, &hdr->common + 1, sizeof(hdr->http) - sizeof(hdr->common), &bytes_read);
2229 if (!ret)
2230 return RPC_S_SERVER_UNAVAILABLE;
2231
2232 data_len = hdr->common.frag_len - sizeof(hdr->http);
2233 if (data_len)
2234 {
2235 *data = HeapAlloc(GetProcessHeap(), 0, data_len);
2236 if (!*data)
2237 return RPC_S_OUT_OF_RESOURCES;
2238 ret = InternetReadFile(request, *data, data_len, &bytes_read);
2239 if (!ret)
2240 {
2241 HeapFree(GetProcessHeap(), 0, *data);
2242 return RPC_S_SERVER_UNAVAILABLE;
2243 }
2244 }
2245 else
2246 *data = NULL;
2247
2248 if (!RPCRT4_IsValidHttpPacket(hdr, *data, data_len))
2249 {
2250 ERR("invalid http packet\n");
2251 return RPC_S_PROTOCOL_ERROR;
2252 }
2253
2254 return RPC_S_OK;
2255 }
2256
2257 /* prepare the out pipe for use by RPC packets */
2258 static RPC_STATUS rpcrt4_http_prepare_out_pipe(HINTERNET out_request,
2259 RpcHttpAsyncData *async_data,
2260 const UUID *connection_uuid,
2261 const UUID *out_pipe_uuid,
2262 ULONG *flow_control_increment)
2263 {
2264 BYTE packet[20];
2265 BOOL ret;
2266 RPC_STATUS status;
2267 RpcPktHdr *hdr;
2268 DWORD bytes_read;
2269 BYTE *data_from_server;
2270 RpcPktHdr pkt_from_server;
2271 ULONG field1, field3;
2272
2273 ResetEvent(async_data->completion_event);
2274 RpcHttpAsyncData_AddRef(async_data);
2275 ret = HttpSendRequestW(out_request, NULL, 0, NULL, 0);
2276 if (!ret)
2277 {
2278 if (GetLastError() == ERROR_IO_PENDING)
2279 WaitForSingleObject(async_data->completion_event, INFINITE);
2280 else
2281 {
2282 RpcHttpAsyncData_Release(async_data);
2283 ERR("HttpSendRequestW failed with error %d\n", GetLastError());
2284 return RPC_S_SERVER_UNAVAILABLE;
2285 }
2286 }
2287 status = rpcrt4_http_check_response(out_request);
2288 if (status != RPC_S_OK) return status;
2289
2290 InternetReadFile(out_request, packet, 20, &bytes_read);
2291 /* FIXME: do something with retrieved data */
2292
2293 hdr = RPCRT4_BuildHttpConnectHeader(0, TRUE, connection_uuid, out_pipe_uuid, NULL);
2294 if (!hdr) return RPC_S_OUT_OF_RESOURCES;
2295 ResetEvent(async_data->completion_event);
2296 RpcHttpAsyncData_AddRef(async_data);
2297 ret = HttpSendRequestW(out_request, NULL, 0, hdr, hdr->common.frag_len);
2298 if (!ret)
2299 {
2300 if (GetLastError() == ERROR_IO_PENDING)
2301 WaitForSingleObject(async_data->completion_event, INFINITE);
2302 else
2303 {
2304 RpcHttpAsyncData_Release(async_data);
2305 ERR("HttpSendRequestW failed with error %d\n", GetLastError());
2306 RPCRT4_FreeHeader(hdr);
2307 return RPC_S_SERVER_UNAVAILABLE;
2308 }
2309 }
2310 RPCRT4_FreeHeader(hdr);
2311 status = rpcrt4_http_check_response(out_request);
2312 if (status != RPC_S_OK) return status;
2313
2314 status = rpcrt4_http_read_http_packet(out_request, &pkt_from_server,
2315 &data_from_server);
2316 if (status != RPC_S_OK) return status;
2317 status = RPCRT4_ParseHttpPrepareHeader1(&pkt_from_server, data_from_server,
2318 &field1);
2319 HeapFree(GetProcessHeap(), 0, data_from_server);
2320 if (status != RPC_S_OK) return status;
2321 TRACE("received (%d) from first prepare header\n", field1);
2322
2323 status = rpcrt4_http_read_http_packet(out_request, &pkt_from_server,
2324 &data_from_server);
2325 if (status != RPC_S_OK) return status;
2326 status = RPCRT4_ParseHttpPrepareHeader2(&pkt_from_server, data_from_server,
2327 &field1, flow_control_increment,
2328 &field3);
2329 HeapFree(GetProcessHeap(), 0, data_from_server);
2330 if (status != RPC_S_OK) return status;
2331 TRACE("received (0x%08x 0x%08x %d) from second prepare header\n", field1, *flow_control_increment, field3);
2332
2333 return RPC_S_OK;
2334 }
2335
2336 static RPC_STATUS rpcrt4_ncacn_http_open(RpcConnection* Connection)
2337 {
2338 RpcConnection_http *httpc = (RpcConnection_http *)Connection;
2339 static const WCHAR wszVerbIn[] = {'R','P','C','_','I','N','_','D','A','T','A',0};
2340 static const WCHAR wszVerbOut[] = {'R','P','C','_','O','U','T','_','D','A','T','A',0};
2341 static const WCHAR wszRpcProxyPrefix[] = {'/','r','p','c','/','r','p','c','p','r','o','x','y','.','d','l','l','?',0};
2342 static const WCHAR wszColon[] = {':',0};
2343 static const WCHAR wszAcceptType[] = {'a','p','p','l','i','c','a','t','i','o','n','/','r','p','c',0};
2344 LPCWSTR wszAcceptTypes[] = { wszAcceptType, NULL };
2345 WCHAR *url;
2346 RPC_STATUS status;
2347 BOOL secure;
2348 HttpTimerThreadData *timer_data;
2349 HANDLE thread;
2350
2351 TRACE("(%s, %s)\n", Connection->NetworkAddr, Connection->Endpoint);
2352
2353 if (Connection->server)
2354 {
2355 ERR("ncacn_http servers not supported yet\n");
2356 return RPC_S_SERVER_UNAVAILABLE;
2357 }
2358
2359 if (httpc->in_request)
2360 return RPC_S_OK;
2361
2362 httpc->async_data->completion_event = CreateEventW(NULL, FALSE, FALSE, NULL);
2363
2364 status = UuidCreate(&httpc->connection_uuid);
2365 status = UuidCreate(&httpc->in_pipe_uuid);
2366 status = UuidCreate(&httpc->out_pipe_uuid);
2367
2368 status = rpcrt4_http_internet_connect(httpc);
2369 if (status != RPC_S_OK)
2370 return status;
2371
2372 url = HeapAlloc(GetProcessHeap(), 0, sizeof(wszRpcProxyPrefix) + (strlen(Connection->NetworkAddr) + 1 + strlen(Connection->Endpoint))*sizeof(WCHAR));
2373 if (!url)
2374 return RPC_S_OUT_OF_MEMORY;
2375 memcpy(url, wszRpcProxyPrefix, sizeof(wszRpcProxyPrefix));
2376 MultiByteToWideChar(CP_ACP, 0, Connection->NetworkAddr, -1, url+sizeof(wszRpcProxyPrefix)/sizeof(wszRpcProxyPrefix[0])-1, strlen(Connection->NetworkAddr)+1);
2377 strcatW(url, wszColon);
2378 MultiByteToWideChar(CP_ACP, 0, Connection->Endpoint, -1, url+strlenW(url), strlen(Connection->Endpoint)+1);
2379
2380 secure = httpc->common.QOS &&
2381 (httpc->common.QOS->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP) &&
2382 (httpc->common.QOS->qos->u.HttpCredentials->Flags & RPC_C_HTTP_FLAG_USE_SSL);
2383
2384 httpc->in_request = HttpOpenRequestW(httpc->session, wszVerbIn, url, NULL, NULL,
2385 wszAcceptTypes,
2386 (secure ? INTERNET_FLAG_SECURE : 0)|INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_PRAGMA_NOCACHE,
2387 (DWORD_PTR)httpc->async_data);
2388 if (!httpc->in_request)
2389 {
2390 ERR("HttpOpenRequestW failed with error %d\n", GetLastError());
2391 return RPC_S_SERVER_UNAVAILABLE;
2392 }
2393 httpc->out_request = HttpOpenRequestW(httpc->session, wszVerbOut, url, NULL, NULL,
2394 wszAcceptTypes,
2395 (secure ? INTERNET_FLAG_SECURE : 0)|INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_PRAGMA_NOCACHE,
2396 (DWORD_PTR)httpc->async_data);
2397 if (!httpc->out_request)
2398 {
2399 ERR("HttpOpenRequestW failed with error %d\n", GetLastError());
2400 return RPC_S_SERVER_UNAVAILABLE;
2401 }
2402
2403 status = rpcrt4_http_prepare_in_pipe(httpc->in_request,
2404 httpc->async_data,
2405 &httpc->connection_uuid,
2406 &httpc->in_pipe_uuid,
2407 &Connection->assoc->http_uuid);
2408 if (status != RPC_S_OK)
2409 return status;
2410
2411 status = rpcrt4_http_prepare_out_pipe(httpc->out_request,
2412 httpc->async_data,
2413 &httpc->connection_uuid,
2414 &httpc->out_pipe_uuid,
2415 &httpc->flow_control_increment);
2416 if (status != RPC_S_OK)
2417 return status;
2418
2419 httpc->flow_control_mark = httpc->flow_control_increment / 2;
2420 httpc->last_sent_time = GetTickCount();
2421 httpc->timer_cancelled = CreateEventW(NULL, FALSE, FALSE, NULL);
2422
2423 timer_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*timer_data));
2424 if (!timer_data)
2425 return ERROR_OUTOFMEMORY;
2426 timer_data->timer_param = httpc->in_request;
2427 timer_data->last_sent_time = &httpc->last_sent_time;
2428 timer_data->timer_cancelled = httpc->timer_cancelled;
2429 /* FIXME: should use CreateTimerQueueTimer when implemented */
2430 thread = CreateThread(NULL, 0, rpcrt4_http_timer_thread, timer_data, 0, NULL);
2431 if (!thread)
2432 {
2433 HeapFree(GetProcessHeap(), 0, timer_data);
2434 return GetLastError();
2435 }
2436 CloseHandle(thread);
2437
2438 return RPC_S_OK;
2439 }
2440
2441 static RPC_STATUS rpcrt4_ncacn_http_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
2442 {
2443 assert(0);
2444 return RPC_S_SERVER_UNAVAILABLE;
2445 }
2446
2447 static int rpcrt4_ncacn_http_read(RpcConnection *Connection,
2448 void *buffer, unsigned int count)
2449 {
2450 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
2451 char *buf = buffer;
2452 BOOL ret = TRUE;
2453 unsigned int bytes_left = count;
2454
2455 ResetEvent(httpc->async_data->completion_event);
2456 while (bytes_left)
2457 {
2458 RpcHttpAsyncData_AddRef(httpc->async_data);
2459 httpc->async_data->inet_buffers.dwBufferLength = bytes_left;
2460 httpc->async_data->inet_buffers.lpvBuffer = HeapAlloc(GetProcessHeap(), 0, bytes_left);
2461 httpc->async_data->destination_buffer = buf;
2462 ret = InternetReadFileExA(httpc->out_request, &httpc->async_data->inet_buffers, IRF_ASYNC, 0);
2463 if (ret)
2464 {
2465 /* INTERNET_STATUS_REQUEST_COMPLETED won't be sent, so release our
2466 * async ref now */
2467 RpcHttpAsyncData_Release(httpc->async_data);
2468 memcpy(buf, httpc->async_data->inet_buffers.lpvBuffer,
2469 httpc->async_data->inet_buffers.dwBufferLength);
2470 HeapFree(GetProcessHeap(), 0, httpc->async_data->inet_buffers.lpvBuffer);
2471 httpc->async_data->inet_buffers.lpvBuffer = NULL;
2472 httpc->async_data->destination_buffer = NULL;
2473 }
2474 else
2475 {
2476 if (GetLastError() == ERROR_IO_PENDING)
2477 {
2478 HANDLE handles[2] = { httpc->async_data->completion_event, httpc->cancel_event };
2479 DWORD result = WaitForMultipleObjects(2, handles, FALSE, DEFAULT_NCACN_HTTP_TIMEOUT);
2480 if (result == WAIT_OBJECT_0)
2481 ret = TRUE;
2482 else
2483 {
2484 TRACE("call cancelled\n");
2485 EnterCriticalSection(&httpc->async_data->cs);
2486 httpc->async_data->destination_buffer = NULL;
2487 LeaveCriticalSection(&httpc->async_data->cs);
2488 break;
2489 }
2490 }
2491 else
2492 {
2493 HeapFree(GetProcessHeap(), 0, httpc->async_data->inet_buffers.lpvBuffer);
2494 httpc->async_data->inet_buffers.lpvBuffer = NULL;
2495 httpc->async_data->destination_buffer = NULL;
2496 RpcHttpAsyncData_Release(httpc->async_data);
2497 break;
2498 }
2499 }
2500 if (!httpc->async_data->inet_buffers.dwBufferLength)
2501 break;
2502 bytes_left -= httpc->async_data->inet_buffers.dwBufferLength;
2503 buf += httpc->async_data->inet_buffers.dwBufferLength;
2504 }
2505 TRACE("%p %p %u -> %s\n", httpc->out_request, buffer, count, ret ? "TRUE" : "FALSE");
2506 return ret ? count : -1;
2507 }
2508
2509 static RPC_STATUS rpcrt4_ncacn_http_receive_fragment(RpcConnection *Connection, RpcPktHdr **Header, void **Payload)
2510 {
2511 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
2512 RPC_STATUS status;
2513 DWORD hdr_length;
2514 LONG dwRead;
2515 RpcPktCommonHdr common_hdr;
2516
2517 *Header = NULL;
2518
2519 TRACE("(%p, %p, %p)\n", Connection, Header, Payload);
2520
2521 again:
2522 /* read packet common header */
2523 dwRead = rpcrt4_ncacn_http_read(Connection, &common_hdr, sizeof(common_hdr));
2524 if (dwRead != sizeof(common_hdr)) {
2525 WARN("Short read of header, %d bytes\n", dwRead);
2526 status = RPC_S_PROTOCOL_ERROR;
2527 goto fail;
2528 }
2529 if (!memcmp(&common_hdr, "HTTP/1.1", sizeof("HTTP/1.1")) ||
2530 !memcmp(&common_hdr, "HTTP/1.0", sizeof("HTTP/1.0")))
2531 {
2532 FIXME("server returned %s\n", debugstr_a((const char *)&common_hdr));
2533 status = RPC_S_PROTOCOL_ERROR;
2534 goto fail;
2535 }
2536
2537 status = RPCRT4_ValidateCommonHeader(&common_hdr);
2538 if (status != RPC_S_OK) goto fail;
2539
2540 hdr_length = RPCRT4_GetHeaderSize((RpcPktHdr*)&common_hdr);
2541 if (hdr_length == 0) {
2542 WARN("header length == 0\n");
2543 status = RPC_S_PROTOCOL_ERROR;
2544 goto fail;
2545 }
2546
2547 *Header = HeapAlloc(GetProcessHeap(), 0, hdr_length);
2548 if (!*Header)
2549 {
2550 status = RPC_S_OUT_OF_RESOURCES;
2551 goto fail;
2552 }
2553 memcpy(*Header, &common_hdr, sizeof(common_hdr));
2554
2555 /* read the rest of packet header */
2556 dwRead = rpcrt4_ncacn_http_read(Connection, &(*Header)->common + 1, hdr_length - sizeof(common_hdr));
2557 if (dwRead != hdr_length - sizeof(common_hdr)) {
2558 WARN("bad header length, %d bytes, hdr_length %d\n", dwRead, hdr_length);
2559 status = RPC_S_PROTOCOL_ERROR;
2560 goto fail;
2561 }
2562
2563 if (common_hdr.frag_len - hdr_length)
2564 {
2565 *Payload = HeapAlloc(GetProcessHeap(), 0, common_hdr.frag_len - hdr_length);
2566 if (!*Payload)
2567 {
2568 status = RPC_S_OUT_OF_RESOURCES;
2569 goto fail;
2570 }
2571
2572 dwRead = rpcrt4_ncacn_http_read(Connection, *Payload, common_hdr.frag_len - hdr_length);
2573 if (dwRead != common_hdr.frag_len - hdr_length)
2574 {
2575 WARN("bad data length, %d/%d\n", dwRead, common_hdr.frag_len - hdr_length);
2576 status = RPC_S_PROTOCOL_ERROR;
2577 goto fail;
2578 }
2579 }
2580 else
2581 *Payload = NULL;
2582
2583 if ((*Header)->common.ptype == PKT_HTTP)
2584 {
2585 if (!RPCRT4_IsValidHttpPacket(*Header, *Payload, common_hdr.frag_len - hdr_length))
2586 {
2587 ERR("invalid http packet of length %d bytes\n", (*Header)->common.frag_len);
2588 status = RPC_S_PROTOCOL_ERROR;
2589 goto fail;
2590 }
2591 if ((*Header)->http.flags == 0x0001)
2592 {
2593 TRACE("http idle packet, waiting for real packet\n");
2594 if ((*Header)->http.num_data_items != 0)
2595 {
2596 ERR("HTTP idle packet should have no data items instead of %d\n", (*Header)->http.num_data_items);
2597 status = RPC_S_PROTOCOL_ERROR;
2598 goto fail;
2599 }
2600 }
2601 else if ((*Header)->http.flags == 0x0002)
2602 {
2603 ULONG bytes_transmitted;
2604 ULONG flow_control_increment;
2605 UUID pipe_uuid;
2606 status = RPCRT4_ParseHttpFlowControlHeader(*Header, *Payload,
2607 Connection->server,
2608 &bytes_transmitted,
2609 &flow_control_increment,
2610 &pipe_uuid);
2611 if (status != RPC_S_OK)
2612 goto fail;
2613 TRACE("received http flow control header (0x%x, 0x%x, %s)\n",
2614 bytes_transmitted, flow_control_increment, debugstr_guid(&pipe_uuid));
2615 /* FIXME: do something with parsed data */
2616 }
2617 else
2618 {
2619 FIXME("unrecognised http packet with flags 0x%04x\n", (*Header)->http.flags);
2620 status = RPC_S_PROTOCOL_ERROR;
2621 goto fail;
2622 }
2623 RPCRT4_FreeHeader(*Header);
2624 *Header = NULL;
2625 HeapFree(GetProcessHeap(), 0, *Payload);
2626 *Payload = NULL;
2627 goto again;
2628 }
2629
2630 /* success */
2631 status = RPC_S_OK;
2632
2633 httpc->bytes_received += common_hdr.frag_len;
2634
2635 TRACE("httpc->bytes_received = 0x%x\n", httpc->bytes_received);
2636
2637 if (httpc->bytes_received > httpc->flow_control_mark)
2638 {
2639 RpcPktHdr *hdr = RPCRT4_BuildHttpFlowControlHeader(httpc->common.server,
2640 httpc->bytes_received,
2641 httpc->flow_control_increment,
2642 &httpc->out_pipe_uuid);
2643 if (hdr)
2644 {
2645 DWORD bytes_written;
2646 BOOL ret2;
2647 TRACE("sending flow control packet at 0x%x\n", httpc->bytes_received);
2648 ret2 = InternetWriteFile(httpc->in_request, hdr, hdr->common.frag_len, &bytes_written);
2649 RPCRT4_FreeHeader(hdr);
2650 if (ret2)
2651 httpc->flow_control_mark = httpc->bytes_received + httpc->flow_control_increment / 2;
2652 }
2653 }
2654
2655 fail:
2656 if (status != RPC_S_OK) {
2657 RPCRT4_FreeHeader(*Header);
2658 *Header = NULL;
2659 HeapFree(GetProcessHeap(), 0, *Payload);
2660 *Payload = NULL;
2661 }
2662 return status;
2663 }
2664
2665 static int rpcrt4_ncacn_http_write(RpcConnection *Connection,
2666 const void *buffer, unsigned int count)
2667 {
2668 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
2669 DWORD bytes_written;
2670 BOOL ret;
2671
2672 httpc->last_sent_time = ~0U; /* disable idle packet sending */
2673 ret = InternetWriteFile(httpc->in_request, buffer, count, &bytes_written);
2674 httpc->last_sent_time = GetTickCount();
2675 TRACE("%p %p %u -> %s\n", httpc->in_request, buffer, count, ret ? "TRUE" : "FALSE");
2676 return ret ? bytes_written : -1;
2677 }
2678
2679 static int rpcrt4_ncacn_http_close(RpcConnection *Connection)
2680 {
2681 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
2682
2683 TRACE("\n");
2684
2685 SetEvent(httpc->timer_cancelled);
2686 if (httpc->in_request)
2687 InternetCloseHandle(httpc->in_request);
2688 httpc->in_request = NULL;
2689 if (httpc->out_request)
2690 InternetCloseHandle(httpc->out_request);
2691 httpc->out_request = NULL;
2692 if (httpc->app_info)
2693 InternetCloseHandle(httpc->app_info);
2694 httpc->app_info = NULL;
2695 if (httpc->session)
2696 InternetCloseHandle(httpc->session);
2697 httpc->session = NULL;
2698 RpcHttpAsyncData_Release(httpc->async_data);
2699 if (httpc->cancel_event)
2700 CloseHandle(httpc->cancel_event);
2701
2702 return 0;
2703 }
2704
2705 static void rpcrt4_ncacn_http_cancel_call(RpcConnection *Connection)
2706 {
2707 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
2708
2709 SetEvent(httpc->cancel_event);
2710 }
2711
2712 static int rpcrt4_ncacn_http_wait_for_incoming_data(RpcConnection *Connection)
2713 {
2714 BOOL ret;
2715 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
2716
2717 RpcHttpAsyncData_AddRef(httpc->async_data);
2718 ret = InternetQueryDataAvailable(httpc->out_request,
2719 &httpc->async_data->inet_buffers.dwBufferLength, IRF_ASYNC, 0);
2720 if (ret)
2721 {
2722 /* INTERNET_STATUS_REQUEST_COMPLETED won't be sent, so release our
2723 * async ref now */
2724 RpcHttpAsyncData_Release(httpc->async_data);
2725 }
2726 else
2727 {
2728 if (GetLastError() == ERROR_IO_PENDING)
2729 {
2730 HANDLE handles[2] = { httpc->async_data->completion_event, httpc->cancel_event };
2731 DWORD result = WaitForMultipleObjects(2, handles, FALSE, DEFAULT_NCACN_HTTP_TIMEOUT);
2732 if (result != WAIT_OBJECT_0)
2733 {
2734 TRACE("call cancelled\n");
2735 return -1;
2736 }
2737 }
2738 else
2739 {
2740 RpcHttpAsyncData_Release(httpc->async_data);
2741 return -1;
2742 }
2743 }
2744
2745 /* success */
2746 return 0;
2747 }
2748
2749 static size_t rpcrt4_ncacn_http_get_top_of_tower(unsigned char *tower_data,
2750 const char *networkaddr,
2751 const char *endpoint)
2752 {
2753 return rpcrt4_ip_tcp_get_top_of_tower(tower_data, networkaddr,
2754 EPM_PROTOCOL_HTTP, endpoint);
2755 }
2756
2757 static RPC_STATUS rpcrt4_ncacn_http_parse_top_of_tower(const unsigned char *tower_data,
2758 size_t tower_size,
2759 char **networkaddr,
2760 char **endpoint)
2761 {
2762 return rpcrt4_ip_tcp_parse_top_of_tower(tower_data, tower_size,
2763 networkaddr, EPM_PROTOCOL_HTTP,
2764 endpoint);
2765 }
2766
2767 static const struct connection_ops conn_protseq_list[] = {
2768 { "ncacn_np",
2769 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_SMB },
2770 rpcrt4_conn_np_alloc,
2771 rpcrt4_ncacn_np_open,
2772 rpcrt4_ncacn_np_handoff,
2773 rpcrt4_conn_np_read,
2774 rpcrt4_conn_np_write,
2775 rpcrt4_conn_np_close,
2776 rpcrt4_conn_np_cancel_call,
2777 rpcrt4_conn_np_wait_for_incoming_data,
2778 rpcrt4_ncacn_np_get_top_of_tower,
2779 rpcrt4_ncacn_np_parse_top_of_tower,
2780 NULL,
2781 RPCRT4_default_is_authorized,
2782 RPCRT4_default_authorize,
2783 RPCRT4_default_secure_packet,
2784 rpcrt4_conn_np_impersonate_client,
2785 rpcrt4_conn_np_revert_to_self,
2786 RPCRT4_default_inquire_auth_client,
2787 },
2788 { "ncalrpc",
2789 { EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_PIPE },
2790 rpcrt4_conn_np_alloc,
2791 rpcrt4_ncalrpc_open,
2792 rpcrt4_ncalrpc_handoff,
2793 rpcrt4_conn_np_read,
2794 rpcrt4_conn_np_write,
2795 rpcrt4_conn_np_close,
2796 rpcrt4_conn_np_cancel_call,
2797 rpcrt4_conn_np_wait_for_incoming_data,
2798 rpcrt4_ncalrpc_get_top_of_tower,
2799 rpcrt4_ncalrpc_parse_top_of_tower,
2800 NULL,
2801 rpcrt4_ncalrpc_is_authorized,
2802 rpcrt4_ncalrpc_authorize,
2803 rpcrt4_ncalrpc_secure_packet,
2804 rpcrt4_conn_np_impersonate_client,
2805 rpcrt4_conn_np_revert_to_self,
2806 rpcrt4_ncalrpc_inquire_auth_client,
2807 },
2808 { "ncacn_ip_tcp",
2809 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_TCP },
2810 rpcrt4_conn_tcp_alloc,
2811 rpcrt4_ncacn_ip_tcp_open,
2812 rpcrt4_conn_tcp_handoff,
2813 rpcrt4_conn_tcp_read,
2814 rpcrt4_conn_tcp_write,
2815 rpcrt4_conn_tcp_close,
2816 rpcrt4_conn_tcp_cancel_call,
2817 rpcrt4_conn_tcp_wait_for_incoming_data,
2818 rpcrt4_ncacn_ip_tcp_get_top_of_tower,
2819 rpcrt4_ncacn_ip_tcp_parse_top_of_tower,
2820 NULL,
2821 RPCRT4_default_is_authorized,
2822 RPCRT4_default_authorize,
2823 RPCRT4_default_secure_packet,
2824 RPCRT4_default_impersonate_client,
2825 RPCRT4_default_revert_to_self,
2826 RPCRT4_default_inquire_auth_client,
2827 },
2828 { "ncacn_http",
2829 { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_HTTP },
2830 rpcrt4_ncacn_http_alloc,
2831 rpcrt4_ncacn_http_open,
2832 rpcrt4_ncacn_http_handoff,
2833 rpcrt4_ncacn_http_read,
2834 rpcrt4_ncacn_http_write,
2835 rpcrt4_ncacn_http_close,
2836 rpcrt4_ncacn_http_cancel_call,
2837 rpcrt4_ncacn_http_wait_for_incoming_data,
2838 rpcrt4_ncacn_http_get_top_of_tower,
2839 rpcrt4_ncacn_http_parse_top_of_tower,
2840 rpcrt4_ncacn_http_receive_fragment,
2841 RPCRT4_default_is_authorized,
2842 RPCRT4_default_authorize,
2843 RPCRT4_default_secure_packet,
2844 RPCRT4_default_impersonate_client,
2845 RPCRT4_default_revert_to_self,
2846 RPCRT4_default_inquire_auth_client,
2847 },
2848 };
2849
2850
2851 static const struct protseq_ops protseq_list[] =
2852 {
2853 {
2854 "ncacn_np",
2855 rpcrt4_protseq_np_alloc,
2856 rpcrt4_protseq_np_signal_state_changed,
2857 rpcrt4_protseq_np_get_wait_array,
2858 rpcrt4_protseq_np_free_wait_array,
2859 rpcrt4_protseq_np_wait_for_new_connection,
2860 rpcrt4_protseq_ncacn_np_open_endpoint,
2861 },
2862 {
2863 "ncalrpc",
2864 rpcrt4_protseq_np_alloc,
2865 rpcrt4_protseq_np_signal_state_changed,
2866 rpcrt4_protseq_np_get_wait_array,
2867 rpcrt4_protseq_np_free_wait_array,
2868 rpcrt4_protseq_np_wait_for_new_connection,
2869 rpcrt4_protseq_ncalrpc_open_endpoint,
2870 },
2871 {
2872 "ncacn_ip_tcp",
2873 rpcrt4_protseq_sock_alloc,
2874 rpcrt4_protseq_sock_signal_state_changed,
2875 rpcrt4_protseq_sock_get_wait_array,
2876 rpcrt4_protseq_sock_free_wait_array,
2877 rpcrt4_protseq_sock_wait_for_new_connection,
2878 rpcrt4_protseq_ncacn_ip_tcp_open_endpoint,
2879 },
2880 };
2881
2882 #define ARRAYSIZE(a) (sizeof((a)) / sizeof((a)[0]))
2883
2884 const struct protseq_ops *rpcrt4_get_protseq_ops(const char *protseq)
2885 {
2886 unsigned int i;
2887 for(i=0; i<ARRAYSIZE(protseq_list); i++)
2888 if (!strcmp(protseq_list[i].name, protseq))
2889 return &protseq_list[i];
2890 return NULL;
2891 }
2892
2893 static const struct connection_ops *rpcrt4_get_conn_protseq_ops(const char *protseq)
2894 {
2895 unsigned int i;
2896 for(i=0; i<ARRAYSIZE(conn_protseq_list); i++)
2897 if (!strcmp(conn_protseq_list[i].name, protseq))
2898 return &conn_protseq_list[i];
2899 return NULL;
2900 }
2901
2902 /**** interface to rest of code ****/
2903
2904 RPC_STATUS RPCRT4_OpenClientConnection(RpcConnection* Connection)
2905 {
2906 TRACE("(Connection == ^%p)\n", Connection);
2907
2908 assert(!Connection->server);
2909 return Connection->ops->open_connection_client(Connection);
2910 }
2911
2912 RPC_STATUS RPCRT4_CloseConnection(RpcConnection* Connection)
2913 {
2914 TRACE("(Connection == ^%p)\n", Connection);
2915 if (SecIsValidHandle(&Connection->ctx))
2916 {
2917 DeleteSecurityContext(&Connection->ctx);
2918 SecInvalidateHandle(&Connection->ctx);
2919 }
2920 rpcrt4_conn_close(Connection);
2921 return RPC_S_OK;
2922 }
2923
2924 RPC_STATUS RPCRT4_CreateConnection(RpcConnection** Connection, BOOL server,
2925 LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint,
2926 LPCWSTR NetworkOptions, RpcAuthInfo* AuthInfo, RpcQualityOfService *QOS)
2927 {
2928 static LONG next_id;
2929 const struct connection_ops *ops;
2930 RpcConnection* NewConnection;
2931
2932 ops = rpcrt4_get_conn_protseq_ops(Protseq);
2933 if (!ops)
2934 {
2935 FIXME("not supported for protseq %s\n", Protseq);
2936 return RPC_S_PROTSEQ_NOT_SUPPORTED;
2937 }
2938
2939 NewConnection = ops->alloc();
2940 NewConnection->Next = NULL;
2941 NewConnection->server_binding = NULL;
2942 NewConnection->server = server;
2943 NewConnection->ops = ops;
2944 NewConnection->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
2945 NewConnection->Endpoint = RPCRT4_strdupA(Endpoint);
2946 NewConnection->NetworkOptions = RPCRT4_strdupW(NetworkOptions);
2947 NewConnection->MaxTransmissionSize = RPC_MAX_PACKET_SIZE;
2948 memset(&NewConnection->ActiveInterface, 0, sizeof(NewConnection->ActiveInterface));
2949 NewConnection->NextCallId = 1;
2950
2951 SecInvalidateHandle(&NewConnection->ctx);
2952 memset(&NewConnection->exp, 0, sizeof(NewConnection->exp));
2953 NewConnection->attr = 0;
2954 if (AuthInfo) RpcAuthInfo_AddRef(AuthInfo);
2955 NewConnection->AuthInfo = AuthInfo;
2956 NewConnection->auth_context_id = InterlockedIncrement( &next_id );
2957 NewConnection->encryption_auth_len = 0;
2958 NewConnection->signature_auth_len = 0;
2959 if (QOS) RpcQualityOfService_AddRef(QOS);
2960 NewConnection->QOS = QOS;
2961
2962 list_init(&NewConnection->conn_pool_entry);
2963 NewConnection->async_state = NULL;
2964
2965 TRACE("connection: %p\n", NewConnection);
2966 *Connection = NewConnection;
2967
2968 return RPC_S_OK;
2969 }
2970
2971 static RPC_STATUS RPCRT4_SpawnConnection(RpcConnection** Connection, RpcConnection* OldConnection)
2972 {
2973 RPC_STATUS err;
2974
2975 err = RPCRT4_CreateConnection(Connection, OldConnection->server,
2976 rpcrt4_conn_get_name(OldConnection),
2977 OldConnection->NetworkAddr,
2978 OldConnection->Endpoint, NULL,
2979 OldConnection->AuthInfo, OldConnection->QOS);
2980 if (err == RPC_S_OK)
2981 rpcrt4_conn_handoff(OldConnection, *Connection);
2982 return err;
2983 }
2984
2985 RPC_STATUS RPCRT4_DestroyConnection(RpcConnection* Connection)
2986 {
2987 TRACE("connection: %p\n", Connection);
2988
2989 RPCRT4_CloseConnection(Connection);
2990 RPCRT4_strfree(Connection->Endpoint);
2991 RPCRT4_strfree(Connection->NetworkAddr);
2992 HeapFree(GetProcessHeap(), 0, Connection->NetworkOptions);
2993 if (Connection->AuthInfo) RpcAuthInfo_Release(Connection->AuthInfo);
2994 if (Connection->QOS) RpcQualityOfService_Release(Connection->QOS);
2995
2996 /* server-only */
2997 if (Connection->server_binding) RPCRT4_ReleaseBinding(Connection->server_binding);
2998
2999 HeapFree(GetProcessHeap(), 0, Connection);
3000 return RPC_S_OK;
3001 }
3002
3003 RPC_STATUS RpcTransport_GetTopOfTower(unsigned char *tower_data,
3004 size_t *tower_size,
3005 const char *protseq,
3006 const char *networkaddr,
3007 const char *endpoint)
3008 {
3009 twr_empty_floor_t *protocol_floor;
3010 const struct connection_ops *protseq_ops = rpcrt4_get_conn_protseq_ops(protseq);
3011
3012 *tower_size = 0;
3013
3014 if (!protseq_ops)
3015 return RPC_S_INVALID_RPC_PROTSEQ;
3016
3017 if (!tower_data)
3018 {
3019 *tower_size = sizeof(*protocol_floor);
3020 *tower_size += protseq_ops->get_top_of_tower(NULL, networkaddr, endpoint);
3021 return RPC_S_OK;
3022 }
3023
3024 protocol_floor = (twr_empty_floor_t *)tower_data;
3025 protocol_floor->count_lhs = sizeof(protocol_floor->protid);
3026 protocol_floor->protid = protseq_ops->epm_protocols[0];
3027 protocol_floor->count_rhs = 0;
3028
3029 tower_data += sizeof(*protocol_floor);
3030
3031 *tower_size = protseq_ops->get_top_of_tower(tower_data, networkaddr, endpoint);
3032 if (!*tower_size)
3033 return EPT_S_NOT_REGISTERED;
3034
3035 *tower_size += sizeof(*protocol_floor);
3036
3037 return RPC_S_OK;
3038 }
3039
3040 RPC_STATUS RpcTransport_ParseTopOfTower(const unsigned char *tower_data,
3041 size_t tower_size,
3042 char **protseq,
3043 char **networkaddr,
3044 char **endpoint)
3045 {
3046 const twr_empty_floor_t *protocol_floor;
3047 const twr_empty_floor_t *floor4;
3048 const struct connection_ops *protseq_ops = NULL;
3049 RPC_STATUS status;
3050 unsigned int i;
3051
3052 if (tower_size < sizeof(*protocol_floor))
3053 return EPT_S_NOT_REGISTERED;
3054
3055 protocol_floor = (const twr_empty_floor_t *)tower_data;
3056 tower_data += sizeof(*protocol_floor);
3057 tower_size -= sizeof(*protocol_floor);
3058 if ((protocol_floor->count_lhs != sizeof(protocol_floor->protid)) ||
3059 (protocol_floor->count_rhs > tower_size))
3060 return EPT_S_NOT_REGISTERED;
3061 tower_data += protocol_floor->count_rhs;
3062 tower_size -= protocol_floor->count_rhs;
3063
3064 floor4 = (const twr_empty_floor_t *)tower_data;
3065 if ((tower_size < sizeof(*floor4)) ||
3066 (floor4->count_lhs != sizeof(floor4->protid)))
3067 return EPT_S_NOT_REGISTERED;
3068
3069 for(i = 0; i < ARRAYSIZE(conn_protseq_list); i++)
3070 if ((protocol_floor->protid == conn_protseq_list[i].epm_protocols[0]) &&
3071 (floor4->protid == conn_protseq_list[i].epm_protocols[1]))
3072 {
3073 protseq_ops = &conn_protseq_list[i];
3074 break;
3075 }
3076
3077 if (!protseq_ops)
3078 return EPT_S_NOT_REGISTERED;
3079
3080 status = protseq_ops->parse_top_of_tower(tower_data, tower_size, networkaddr, endpoint);
3081
3082 if ((status == RPC_S_OK) && protseq)
3083 {
3084 *protseq = I_RpcAllocate(strlen(protseq_ops->name) + 1);
3085 strcpy(*protseq, protseq_ops->name);
3086 }
3087
3088 return status;
3089 }
3090
3091 /***********************************************************************
3092 * RpcNetworkIsProtseqValidW (RPCRT4.@)
3093 *
3094 * Checks if the given protocol sequence is known by the RPC system.
3095 * If it is, returns RPC_S_OK, otherwise RPC_S_PROTSEQ_NOT_SUPPORTED.
3096 *
3097 */
3098 RPC_STATUS WINAPI RpcNetworkIsProtseqValidW(RPC_WSTR protseq)
3099 {
3100 char ps[0x10];
3101
3102 WideCharToMultiByte(CP_ACP, 0, protseq, -1,
3103 ps, sizeof ps, NULL, NULL);
3104 if (rpcrt4_get_conn_protseq_ops(ps))
3105 return RPC_S_OK;
3106
3107 FIXME("Unknown protseq %s\n", debugstr_w(protseq));
3108
3109 return RPC_S_INVALID_RPC_PROTSEQ;
3110 }
3111
3112 /***********************************************************************
3113 * RpcNetworkIsProtseqValidA (RPCRT4.@)
3114 */
3115 RPC_STATUS WINAPI RpcNetworkIsProtseqValidA(RPC_CSTR protseq)
3116 {
3117 UNICODE_STRING protseqW;
3118
3119 if (RtlCreateUnicodeStringFromAsciiz(&protseqW, (char*)protseq))
3120 {
3121 RPC_STATUS ret = RpcNetworkIsProtseqValidW(protseqW.Buffer);
3122 RtlFreeUnicodeString(&protseqW);
3123 return ret;
3124 }
3125 return RPC_S_OUT_OF_MEMORY;
3126 }
useful hacks and other patches not (yet) suitable for mainline