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
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.
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.
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
39 #include <sys/types.h>
40 #ifdef HAVE_SYS_SOCKET_H
41 # include <sys/socket.h>
43 #ifdef HAVE_NETINET_IN_H
44 # include <netinet/in.h>
46 #ifdef HAVE_NETINET_TCP_H
47 # include <netinet/tcp.h>
49 #ifdef HAVE_ARPA_INET_H
50 # include <arpa/inet.h>
55 #ifdef HAVE_SYS_POLL_H
64 #include "wine/unicode.h"
69 #include "wine/debug.h"
71 #include "rpc_binding.h"
72 #include "rpc_message.h"
73 #include "rpc_server.h"
74 #include "epm_towers.h"
77 # define SOL_TCP IPPROTO_TCP
80 WINE_DEFAULT_DEBUG_CHANNEL(rpc
);
82 static CRITICAL_SECTION assoc_list_cs
;
83 static CRITICAL_SECTION_DEBUG assoc_list_cs_debug
=
86 { &assoc_list_cs_debug
.ProcessLocksList
, &assoc_list_cs_debug
.ProcessLocksList
},
87 0, 0, { (DWORD_PTR
)(__FILE__
": assoc_list_cs") }
89 static CRITICAL_SECTION assoc_list_cs
= { &assoc_list_cs_debug
, -1, 0, 0, 0, 0 };
91 static struct list assoc_list
= LIST_INIT(assoc_list
);
93 /**** ncacn_np support ****/
95 typedef struct _RpcConnection_np
103 static RpcConnection
*rpcrt4_conn_np_alloc(void)
105 RpcConnection_np
*npc
= HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_np
));
109 memset(&npc
->ovl
, 0, sizeof(npc
->ovl
));
110 npc
->listening
= FALSE
;
115 static RPC_STATUS
rpcrt4_conn_listen_pipe(RpcConnection_np
*npc
)
120 npc
->listening
= TRUE
;
121 if (ConnectNamedPipe(npc
->pipe
, &npc
->ovl
))
124 if (GetLastError() == ERROR_PIPE_CONNECTED
) {
125 SetEvent(npc
->ovl
.hEvent
);
128 if (GetLastError() == ERROR_IO_PENDING
) {
129 /* will be completed in rpcrt4_protseq_np_wait_for_new_connection */
132 npc
->listening
= FALSE
;
133 WARN("Couldn't ConnectNamedPipe (error was %d)\n", GetLastError());
134 return RPC_S_OUT_OF_RESOURCES
;
137 static RPC_STATUS
rpcrt4_conn_create_pipe(RpcConnection
*Connection
, LPCSTR pname
)
139 RpcConnection_np
*npc
= (RpcConnection_np
*) Connection
;
140 TRACE("listening on %s\n", pname
);
142 npc
->pipe
= CreateNamedPipeA(pname
, PIPE_ACCESS_DUPLEX
,
143 PIPE_TYPE_MESSAGE
| PIPE_READMODE_MESSAGE
,
144 PIPE_UNLIMITED_INSTANCES
,
145 RPC_MAX_PACKET_SIZE
, RPC_MAX_PACKET_SIZE
, 5000, NULL
);
146 if (npc
->pipe
== INVALID_HANDLE_VALUE
) {
147 WARN("CreateNamedPipe failed with error %d\n", GetLastError());
148 if (GetLastError() == ERROR_FILE_EXISTS
)
149 return RPC_S_DUPLICATE_ENDPOINT
;
151 return RPC_S_CANT_CREATE_ENDPOINT
;
154 memset(&npc
->ovl
, 0, sizeof(npc
->ovl
));
155 npc
->ovl
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
157 /* Note: we don't call ConnectNamedPipe here because it must be done in the
158 * server thread as the thread must be alertable */
162 static RPC_STATUS
rpcrt4_conn_open_pipe(RpcConnection
*Connection
, LPCSTR pname
, BOOL wait
)
164 RpcConnection_np
*npc
= (RpcConnection_np
*) Connection
;
168 TRACE("connecting to %s\n", pname
);
174 dwFlags
= SECURITY_SQOS_PRESENT
;
175 switch (Connection
->QOS
->qos
->ImpersonationType
)
177 case RPC_C_IMP_LEVEL_DEFAULT
:
178 /* FIXME: what to do here? */
180 case RPC_C_IMP_LEVEL_ANONYMOUS
:
181 dwFlags
|= SECURITY_ANONYMOUS
;
183 case RPC_C_IMP_LEVEL_IDENTIFY
:
184 dwFlags
|= SECURITY_IDENTIFICATION
;
186 case RPC_C_IMP_LEVEL_IMPERSONATE
:
187 dwFlags
|= SECURITY_IMPERSONATION
;
189 case RPC_C_IMP_LEVEL_DELEGATE
:
190 dwFlags
|= SECURITY_DELEGATION
;
193 if (Connection
->QOS
->qos
->IdentityTracking
== RPC_C_QOS_IDENTIFY_DYNAMIC
)
194 dwFlags
|= SECURITY_CONTEXT_TRACKING
;
196 pipe
= CreateFileA(pname
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
197 OPEN_EXISTING
, dwFlags
, 0);
198 if (pipe
!= INVALID_HANDLE_VALUE
) break;
199 err
= GetLastError();
200 if (err
== ERROR_PIPE_BUSY
) {
201 TRACE("connection failed, error=%x\n", err
);
202 return RPC_S_SERVER_TOO_BUSY
;
205 return RPC_S_SERVER_UNAVAILABLE
;
206 if (!WaitNamedPipeA(pname
, NMPWAIT_WAIT_FOREVER
)) {
207 err
= GetLastError();
208 WARN("connection failed, error=%x\n", err
);
209 return RPC_S_SERVER_UNAVAILABLE
;
214 memset(&npc
->ovl
, 0, sizeof(npc
->ovl
));
215 /* pipe is connected; change to message-read mode. */
216 dwMode
= PIPE_READMODE_MESSAGE
;
217 SetNamedPipeHandleState(pipe
, &dwMode
, NULL
, NULL
);
218 npc
->ovl
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
224 static RPC_STATUS
rpcrt4_ncalrpc_open(RpcConnection
* Connection
)
226 RpcConnection_np
*npc
= (RpcConnection_np
*) Connection
;
227 static const char prefix
[] = "\\\\.\\pipe\\lrpc\\";
231 /* already connected? */
235 /* protseq=ncalrpc: supposed to use NT LPC ports,
236 * but we'll implement it with named pipes for now */
237 pname
= I_RpcAllocate(strlen(prefix
) + strlen(Connection
->Endpoint
) + 1);
238 strcat(strcpy(pname
, prefix
), Connection
->Endpoint
);
239 r
= rpcrt4_conn_open_pipe(Connection
, pname
, TRUE
);
245 static RPC_STATUS
rpcrt4_protseq_ncalrpc_open_endpoint(RpcServerProtseq
* protseq
, LPSTR endpoint
)
247 static const char prefix
[] = "\\\\.\\pipe\\lrpc\\";
250 RpcConnection
*Connection
;
252 r
= RPCRT4_CreateConnection(&Connection
, TRUE
, protseq
->Protseq
, NULL
,
253 endpoint
, NULL
, NULL
, NULL
);
257 /* protseq=ncalrpc: supposed to use NT LPC ports,
258 * but we'll implement it with named pipes for now */
259 pname
= I_RpcAllocate(strlen(prefix
) + strlen(Connection
->Endpoint
) + 1);
260 strcat(strcpy(pname
, prefix
), Connection
->Endpoint
);
261 r
= rpcrt4_conn_create_pipe(Connection
, pname
);
264 EnterCriticalSection(&protseq
->cs
);
265 Connection
->Next
= protseq
->conn
;
266 protseq
->conn
= Connection
;
267 LeaveCriticalSection(&protseq
->cs
);
272 static RPC_STATUS
rpcrt4_ncacn_np_open(RpcConnection
* Connection
)
274 RpcConnection_np
*npc
= (RpcConnection_np
*) Connection
;
275 static const char prefix
[] = "\\\\.";
279 /* already connected? */
283 /* protseq=ncacn_np: named pipes */
284 pname
= I_RpcAllocate(strlen(prefix
) + strlen(Connection
->Endpoint
) + 1);
285 strcat(strcpy(pname
, prefix
), Connection
->Endpoint
);
286 r
= rpcrt4_conn_open_pipe(Connection
, pname
, FALSE
);
292 static RPC_STATUS
rpcrt4_protseq_ncacn_np_open_endpoint(RpcServerProtseq
*protseq
, LPSTR endpoint
)
294 static const char prefix
[] = "\\\\.";
297 RpcConnection
*Connection
;
299 r
= RPCRT4_CreateConnection(&Connection
, TRUE
, protseq
->Protseq
, NULL
,
300 endpoint
, NULL
, NULL
, NULL
);
304 /* protseq=ncacn_np: named pipes */
305 pname
= I_RpcAllocate(strlen(prefix
) + strlen(Connection
->Endpoint
) + 1);
306 strcat(strcpy(pname
, prefix
), Connection
->Endpoint
);
307 r
= rpcrt4_conn_create_pipe(Connection
, pname
);
310 EnterCriticalSection(&protseq
->cs
);
311 Connection
->Next
= protseq
->conn
;
312 protseq
->conn
= Connection
;
313 LeaveCriticalSection(&protseq
->cs
);
318 static void rpcrt4_conn_np_handoff(RpcConnection_np
*old_npc
, RpcConnection_np
*new_npc
)
320 /* because of the way named pipes work, we'll transfer the connected pipe
321 * to the child, then reopen the server binding to continue listening */
323 new_npc
->pipe
= old_npc
->pipe
;
324 new_npc
->ovl
= old_npc
->ovl
;
326 memset(&old_npc
->ovl
, 0, sizeof(old_npc
->ovl
));
327 old_npc
->listening
= FALSE
;
330 static RPC_STATUS
rpcrt4_ncacn_np_handoff(RpcConnection
*old_conn
, RpcConnection
*new_conn
)
334 static const char prefix
[] = "\\\\.";
336 rpcrt4_conn_np_handoff((RpcConnection_np
*)old_conn
, (RpcConnection_np
*)new_conn
);
338 pname
= I_RpcAllocate(strlen(prefix
) + strlen(old_conn
->Endpoint
) + 1);
339 strcat(strcpy(pname
, prefix
), old_conn
->Endpoint
);
340 status
= rpcrt4_conn_create_pipe(old_conn
, pname
);
346 static RPC_STATUS
rpcrt4_ncalrpc_handoff(RpcConnection
*old_conn
, RpcConnection
*new_conn
)
350 static const char prefix
[] = "\\\\.\\pipe\\lrpc\\";
352 TRACE("%s\n", old_conn
->Endpoint
);
354 rpcrt4_conn_np_handoff((RpcConnection_np
*)old_conn
, (RpcConnection_np
*)new_conn
);
356 pname
= I_RpcAllocate(strlen(prefix
) + strlen(old_conn
->Endpoint
) + 1);
357 strcat(strcpy(pname
, prefix
), old_conn
->Endpoint
);
358 status
= rpcrt4_conn_create_pipe(old_conn
, pname
);
364 static int rpcrt4_conn_np_read(RpcConnection
*Connection
,
365 void *buffer
, unsigned int count
)
367 RpcConnection_np
*npc
= (RpcConnection_np
*) Connection
;
370 unsigned int bytes_left
= count
;
375 ret
= ReadFile(npc
->pipe
, buf
, bytes_left
, &bytes_read
, NULL
);
376 if (!ret
|| !bytes_read
)
378 bytes_left
-= bytes_read
;
381 return ret
? count
: -1;
384 static int rpcrt4_conn_np_write(RpcConnection
*Connection
,
385 const void *buffer
, unsigned int count
)
387 RpcConnection_np
*npc
= (RpcConnection_np
*) Connection
;
388 const char *buf
= buffer
;
390 unsigned int bytes_left
= count
;
395 ret
= WriteFile(npc
->pipe
, buf
, count
, &bytes_written
, NULL
);
396 if (!ret
|| !bytes_written
)
398 bytes_left
-= bytes_written
;
399 buf
+= bytes_written
;
401 return ret
? count
: -1;
404 static int rpcrt4_conn_np_close(RpcConnection
*Connection
)
406 RpcConnection_np
*npc
= (RpcConnection_np
*) Connection
;
408 FlushFileBuffers(npc
->pipe
);
409 CloseHandle(npc
->pipe
);
412 if (npc
->ovl
.hEvent
) {
413 CloseHandle(npc
->ovl
.hEvent
);
419 static size_t rpcrt4_ncacn_np_get_top_of_tower(unsigned char *tower_data
,
420 const char *networkaddr
,
421 const char *endpoint
)
423 twr_empty_floor_t
*smb_floor
;
424 twr_empty_floor_t
*nb_floor
;
426 size_t networkaddr_size
;
427 size_t endpoint_size
;
429 TRACE("(%p, %s, %s)\n", tower_data
, networkaddr
, endpoint
);
431 networkaddr_size
= strlen(networkaddr
) + 1;
432 endpoint_size
= strlen(endpoint
) + 1;
433 size
= sizeof(*smb_floor
) + endpoint_size
+ sizeof(*nb_floor
) + networkaddr_size
;
438 smb_floor
= (twr_empty_floor_t
*)tower_data
;
440 tower_data
+= sizeof(*smb_floor
);
442 smb_floor
->count_lhs
= sizeof(smb_floor
->protid
);
443 smb_floor
->protid
= EPM_PROTOCOL_SMB
;
444 smb_floor
->count_rhs
= endpoint_size
;
446 memcpy(tower_data
, endpoint
, endpoint_size
);
447 tower_data
+= endpoint_size
;
449 nb_floor
= (twr_empty_floor_t
*)tower_data
;
451 tower_data
+= sizeof(*nb_floor
);
453 nb_floor
->count_lhs
= sizeof(nb_floor
->protid
);
454 nb_floor
->protid
= EPM_PROTOCOL_NETBIOS
;
455 nb_floor
->count_rhs
= networkaddr_size
;
457 memcpy(tower_data
, networkaddr
, networkaddr_size
);
458 tower_data
+= networkaddr_size
;
463 static RPC_STATUS
rpcrt4_ncacn_np_parse_top_of_tower(const unsigned char *tower_data
,
468 const twr_empty_floor_t
*smb_floor
= (const twr_empty_floor_t
*)tower_data
;
469 const twr_empty_floor_t
*nb_floor
;
471 TRACE("(%p, %d, %p, %p)\n", tower_data
, (int)tower_size
, networkaddr
, endpoint
);
473 if (tower_size
< sizeof(*smb_floor
))
474 return EPT_S_NOT_REGISTERED
;
476 tower_data
+= sizeof(*smb_floor
);
477 tower_size
-= sizeof(*smb_floor
);
479 if ((smb_floor
->count_lhs
!= sizeof(smb_floor
->protid
)) ||
480 (smb_floor
->protid
!= EPM_PROTOCOL_SMB
) ||
481 (smb_floor
->count_rhs
> tower_size
))
482 return EPT_S_NOT_REGISTERED
;
486 *endpoint
= I_RpcAllocate(smb_floor
->count_rhs
);
488 return RPC_S_OUT_OF_RESOURCES
;
489 memcpy(*endpoint
, tower_data
, smb_floor
->count_rhs
);
491 tower_data
+= smb_floor
->count_rhs
;
492 tower_size
-= smb_floor
->count_rhs
;
494 if (tower_size
< sizeof(*nb_floor
))
495 return EPT_S_NOT_REGISTERED
;
497 nb_floor
= (const twr_empty_floor_t
*)tower_data
;
499 tower_data
+= sizeof(*nb_floor
);
500 tower_size
-= sizeof(*nb_floor
);
502 if ((nb_floor
->count_lhs
!= sizeof(nb_floor
->protid
)) ||
503 (nb_floor
->protid
!= EPM_PROTOCOL_NETBIOS
) ||
504 (nb_floor
->count_rhs
> tower_size
))
505 return EPT_S_NOT_REGISTERED
;
509 *networkaddr
= I_RpcAllocate(nb_floor
->count_rhs
);
514 I_RpcFree(*endpoint
);
517 return RPC_S_OUT_OF_RESOURCES
;
519 memcpy(*networkaddr
, tower_data
, nb_floor
->count_rhs
);
525 typedef struct _RpcServerProtseq_np
527 RpcServerProtseq common
;
529 } RpcServerProtseq_np
;
531 static RpcServerProtseq
*rpcrt4_protseq_np_alloc(void)
533 RpcServerProtseq_np
*ps
= HeapAlloc(GetProcessHeap(), 0, sizeof(*ps
));
535 ps
->mgr_event
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
539 static void rpcrt4_protseq_np_signal_state_changed(RpcServerProtseq
*protseq
)
541 RpcServerProtseq_np
*npps
= CONTAINING_RECORD(protseq
, RpcServerProtseq_np
, common
);
542 SetEvent(npps
->mgr_event
);
545 static void *rpcrt4_protseq_np_get_wait_array(RpcServerProtseq
*protseq
, void *prev_array
, unsigned int *count
)
547 HANDLE
*objs
= prev_array
;
548 RpcConnection_np
*conn
;
549 RpcServerProtseq_np
*npps
= CONTAINING_RECORD(protseq
, RpcServerProtseq_np
, common
);
551 EnterCriticalSection(&protseq
->cs
);
553 /* open and count connections */
555 conn
= CONTAINING_RECORD(protseq
->conn
, RpcConnection_np
, common
);
557 rpcrt4_conn_listen_pipe(conn
);
558 if (conn
->ovl
.hEvent
)
560 conn
= CONTAINING_RECORD(conn
->common
.Next
, RpcConnection_np
, common
);
563 /* make array of connections */
565 objs
= HeapReAlloc(GetProcessHeap(), 0, objs
, *count
*sizeof(HANDLE
));
567 objs
= HeapAlloc(GetProcessHeap(), 0, *count
*sizeof(HANDLE
));
570 ERR("couldn't allocate objs\n");
571 LeaveCriticalSection(&protseq
->cs
);
575 objs
[0] = npps
->mgr_event
;
577 conn
= CONTAINING_RECORD(protseq
->conn
, RpcConnection_np
, common
);
579 if ((objs
[*count
] = conn
->ovl
.hEvent
))
581 conn
= CONTAINING_RECORD(conn
->common
.Next
, RpcConnection_np
, common
);
583 LeaveCriticalSection(&protseq
->cs
);
587 static void rpcrt4_protseq_np_free_wait_array(RpcServerProtseq
*protseq
, void *array
)
589 HeapFree(GetProcessHeap(), 0, array
);
592 static int rpcrt4_protseq_np_wait_for_new_connection(RpcServerProtseq
*protseq
, unsigned int count
, void *wait_array
)
595 HANDLE
*objs
= wait_array
;
597 RpcConnection
*cconn
;
598 RpcConnection_np
*conn
;
603 res
= WaitForMultipleObjects(count
, objs
, FALSE
, INFINITE
);
604 if (res
== WAIT_OBJECT_0
)
606 else if (res
== WAIT_FAILED
)
608 ERR("wait failed with error %d\n", GetLastError());
613 b_handle
= objs
[res
- WAIT_OBJECT_0
];
614 /* find which connection got a RPC */
615 EnterCriticalSection(&protseq
->cs
);
616 conn
= CONTAINING_RECORD(protseq
->conn
, RpcConnection_np
, common
);
618 if (b_handle
== conn
->ovl
.hEvent
) break;
619 conn
= CONTAINING_RECORD(conn
->common
.Next
, RpcConnection_np
, common
);
623 RPCRT4_SpawnConnection(&cconn
, &conn
->common
);
625 ERR("failed to locate connection for handle %p\n", b_handle
);
626 LeaveCriticalSection(&protseq
->cs
);
629 RPCRT4_new_client(cconn
);
636 static size_t rpcrt4_ncalrpc_get_top_of_tower(unsigned char *tower_data
,
637 const char *networkaddr
,
638 const char *endpoint
)
640 twr_empty_floor_t
*pipe_floor
;
642 size_t endpoint_size
;
644 TRACE("(%p, %s, %s)\n", tower_data
, networkaddr
, endpoint
);
646 endpoint_size
= strlen(networkaddr
) + 1;
647 size
= sizeof(*pipe_floor
) + endpoint_size
;
652 pipe_floor
= (twr_empty_floor_t
*)tower_data
;
654 tower_data
+= sizeof(*pipe_floor
);
656 pipe_floor
->count_lhs
= sizeof(pipe_floor
->protid
);
657 pipe_floor
->protid
= EPM_PROTOCOL_SMB
;
658 pipe_floor
->count_rhs
= endpoint_size
;
660 memcpy(tower_data
, endpoint
, endpoint_size
);
661 tower_data
+= endpoint_size
;
666 static RPC_STATUS
rpcrt4_ncalrpc_parse_top_of_tower(const unsigned char *tower_data
,
671 const twr_empty_floor_t
*pipe_floor
= (const twr_empty_floor_t
*)tower_data
;
673 TRACE("(%p, %d, %p, %p)\n", tower_data
, (int)tower_size
, networkaddr
, endpoint
);
678 if (tower_size
< sizeof(*pipe_floor
))
679 return EPT_S_NOT_REGISTERED
;
681 tower_data
+= sizeof(*pipe_floor
);
682 tower_size
-= sizeof(*pipe_floor
);
684 if ((pipe_floor
->count_lhs
!= sizeof(pipe_floor
->protid
)) ||
685 (pipe_floor
->protid
!= EPM_PROTOCOL_SMB
) ||
686 (pipe_floor
->count_rhs
> tower_size
))
687 return EPT_S_NOT_REGISTERED
;
691 *endpoint
= I_RpcAllocate(pipe_floor
->count_rhs
);
693 return RPC_S_OUT_OF_RESOURCES
;
694 memcpy(*endpoint
, tower_data
, pipe_floor
->count_rhs
);
700 /**** ncacn_ip_tcp support ****/
702 typedef struct _RpcConnection_tcp
704 RpcConnection common
;
708 static RpcConnection
*rpcrt4_conn_tcp_alloc(void)
710 RpcConnection_tcp
*tcpc
;
711 tcpc
= HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_tcp
));
715 return &tcpc
->common
;
718 static RPC_STATUS
rpcrt4_ncacn_ip_tcp_open(RpcConnection
* Connection
)
720 RpcConnection_tcp
*tcpc
= (RpcConnection_tcp
*) Connection
;
724 struct addrinfo
*ai_cur
;
725 struct addrinfo hints
;
727 TRACE("(%s, %s)\n", Connection
->NetworkAddr
, Connection
->Endpoint
);
729 if (tcpc
->sock
!= -1)
733 hints
.ai_family
= PF_UNSPEC
;
734 hints
.ai_socktype
= SOCK_STREAM
;
735 hints
.ai_protocol
= IPPROTO_TCP
;
736 hints
.ai_addrlen
= 0;
737 hints
.ai_addr
= NULL
;
738 hints
.ai_canonname
= NULL
;
739 hints
.ai_next
= NULL
;
741 ret
= getaddrinfo(Connection
->NetworkAddr
, Connection
->Endpoint
, &hints
, &ai
);
744 ERR("getaddrinfo for %s:%s failed: %s\n", Connection
->NetworkAddr
,
745 Connection
->Endpoint
, gai_strerror(ret
));
746 return RPC_S_SERVER_UNAVAILABLE
;
749 for (ai_cur
= ai
; ai_cur
; ai_cur
= ai_cur
->ai_next
)
757 getnameinfo(ai_cur
->ai_addr
, ai_cur
->ai_addrlen
,
758 host
, sizeof(host
), service
, sizeof(service
),
759 NI_NUMERICHOST
| NI_NUMERICSERV
);
760 TRACE("trying %s:%s\n", host
, service
);
763 sock
= socket(ai_cur
->ai_family
, ai_cur
->ai_socktype
, ai_cur
->ai_protocol
);
766 WARN("socket() failed: %s\n", strerror(errno
));
770 if (0>connect(sock
, ai_cur
->ai_addr
, ai_cur
->ai_addrlen
))
772 WARN("connect() failed: %s\n", strerror(errno
));
777 /* RPC depends on having minimal latency so disable the Nagle algorithm */
779 setsockopt(sock
, SOL_TCP
, TCP_NODELAY
, &val
, sizeof(val
));
784 TRACE("connected\n");
789 ERR("couldn't connect to %s:%s\n", Connection
->NetworkAddr
, Connection
->Endpoint
);
790 return RPC_S_SERVER_UNAVAILABLE
;
793 static RPC_STATUS
rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq
*protseq
, LPSTR endpoint
)
795 RPC_STATUS status
= RPC_S_CANT_CREATE_ENDPOINT
;
799 struct addrinfo
*ai_cur
;
800 struct addrinfo hints
;
801 RpcConnection
*first_connection
= NULL
;
803 TRACE("(%p, %s)\n", protseq
, endpoint
);
805 hints
.ai_flags
= AI_PASSIVE
/* for non-localhost addresses */;
806 hints
.ai_family
= PF_UNSPEC
;
807 hints
.ai_socktype
= SOCK_STREAM
;
808 hints
.ai_protocol
= IPPROTO_TCP
;
809 hints
.ai_addrlen
= 0;
810 hints
.ai_addr
= NULL
;
811 hints
.ai_canonname
= NULL
;
812 hints
.ai_next
= NULL
;
814 ret
= getaddrinfo(NULL
, endpoint
, &hints
, &ai
);
817 ERR("getaddrinfo for port %s failed: %s\n", endpoint
,
819 if ((ret
== EAI_SERVICE
) || (ret
== EAI_NONAME
))
820 return RPC_S_INVALID_ENDPOINT_FORMAT
;
821 return RPC_S_CANT_CREATE_ENDPOINT
;
824 for (ai_cur
= ai
; ai_cur
; ai_cur
= ai_cur
->ai_next
)
826 RpcConnection_tcp
*tcpc
;
827 RPC_STATUS create_status
;
833 getnameinfo(ai_cur
->ai_addr
, ai_cur
->ai_addrlen
,
834 host
, sizeof(host
), service
, sizeof(service
),
835 NI_NUMERICHOST
| NI_NUMERICSERV
);
836 TRACE("trying %s:%s\n", host
, service
);
839 sock
= socket(ai_cur
->ai_family
, ai_cur
->ai_socktype
, ai_cur
->ai_protocol
);
842 WARN("socket() failed: %s\n", strerror(errno
));
843 status
= RPC_S_CANT_CREATE_ENDPOINT
;
847 ret
= bind(sock
, ai_cur
->ai_addr
, ai_cur
->ai_addrlen
);
850 WARN("bind failed: %s\n", strerror(errno
));
852 if (errno
== EADDRINUSE
)
853 status
= RPC_S_DUPLICATE_ENDPOINT
;
855 status
= RPC_S_CANT_CREATE_ENDPOINT
;
858 create_status
= RPCRT4_CreateConnection((RpcConnection
**)&tcpc
, TRUE
,
859 protseq
->Protseq
, NULL
,
860 endpoint
, NULL
, NULL
, NULL
);
861 if (create_status
!= RPC_S_OK
)
864 status
= create_status
;
869 ret
= listen(sock
, protseq
->MaxCalls
);
872 WARN("listen failed: %s\n", strerror(errno
));
873 RPCRT4_DestroyConnection(&tcpc
->common
);
874 status
= RPC_S_OUT_OF_RESOURCES
;
877 /* need a non-blocking socket, otherwise accept() has a potential
878 * race-condition (poll() says it is readable, connection drops,
879 * and accept() blocks until the next connection comes...)
881 ret
= fcntl(sock
, F_SETFL
, O_NONBLOCK
);
884 WARN("couldn't make socket non-blocking, error %d\n", ret
);
885 RPCRT4_DestroyConnection(&tcpc
->common
);
886 status
= RPC_S_OUT_OF_RESOURCES
;
890 tcpc
->common
.Next
= first_connection
;
891 first_connection
= &tcpc
->common
;
896 /* if at least one connection was created for an endpoint then
898 if (first_connection
)
902 /* find last element in list */
903 for (conn
= first_connection
; conn
->Next
; conn
= conn
->Next
)
906 EnterCriticalSection(&protseq
->cs
);
907 conn
->Next
= protseq
->conn
;
908 protseq
->conn
= first_connection
;
909 LeaveCriticalSection(&protseq
->cs
);
911 TRACE("listening on %s\n", endpoint
);
915 ERR("couldn't listen on port %s\n", endpoint
);
919 static RPC_STATUS
rpcrt4_conn_tcp_handoff(RpcConnection
*old_conn
, RpcConnection
*new_conn
)
922 struct sockaddr_in address
;
924 RpcConnection_tcp
*server
= (RpcConnection_tcp
*) old_conn
;
925 RpcConnection_tcp
*client
= (RpcConnection_tcp
*) new_conn
;
927 addrsize
= sizeof(address
);
928 ret
= accept(server
->sock
, (struct sockaddr
*) &address
, &addrsize
);
931 ERR("Failed to accept a TCP connection: error %d\n", ret
);
932 return RPC_S_OUT_OF_RESOURCES
;
934 /* reset to blocking behaviour */
935 fcntl(ret
, F_SETFL
, 0);
937 TRACE("Accepted a new TCP connection\n");
941 static int rpcrt4_conn_tcp_read(RpcConnection
*Connection
,
942 void *buffer
, unsigned int count
)
944 RpcConnection_tcp
*tcpc
= (RpcConnection_tcp
*) Connection
;
945 int r
= recv(tcpc
->sock
, buffer
, count
, MSG_WAITALL
);
946 TRACE("%d %p %u -> %d\n", tcpc
->sock
, buffer
, count
, r
);
950 static int rpcrt4_conn_tcp_write(RpcConnection
*Connection
,
951 const void *buffer
, unsigned int count
)
953 RpcConnection_tcp
*tcpc
= (RpcConnection_tcp
*) Connection
;
954 int r
= write(tcpc
->sock
, buffer
, count
);
955 TRACE("%d %p %u -> %d\n", tcpc
->sock
, buffer
, count
, r
);
959 static int rpcrt4_conn_tcp_close(RpcConnection
*Connection
)
961 RpcConnection_tcp
*tcpc
= (RpcConnection_tcp
*) Connection
;
963 TRACE("%d\n", tcpc
->sock
);
965 if (tcpc
->sock
!= -1)
971 static size_t rpcrt4_ncacn_ip_tcp_get_top_of_tower(unsigned char *tower_data
,
972 const char *networkaddr
,
973 const char *endpoint
)
975 twr_tcp_floor_t
*tcp_floor
;
976 twr_ipv4_floor_t
*ipv4_floor
;
978 struct addrinfo hints
;
980 size_t size
= sizeof(*tcp_floor
) + sizeof(*ipv4_floor
);
982 TRACE("(%p, %s, %s)\n", tower_data
, networkaddr
, endpoint
);
987 tcp_floor
= (twr_tcp_floor_t
*)tower_data
;
988 tower_data
+= sizeof(*tcp_floor
);
990 ipv4_floor
= (twr_ipv4_floor_t
*)tower_data
;
992 tcp_floor
->count_lhs
= sizeof(tcp_floor
->protid
);
993 tcp_floor
->protid
= EPM_PROTOCOL_TCP
;
994 tcp_floor
->count_rhs
= sizeof(tcp_floor
->port
);
996 ipv4_floor
->count_lhs
= sizeof(ipv4_floor
->protid
);
997 ipv4_floor
->protid
= EPM_PROTOCOL_IP
;
998 ipv4_floor
->count_rhs
= sizeof(ipv4_floor
->ipv4addr
);
1000 hints
.ai_flags
= AI_NUMERICHOST
;
1001 /* FIXME: only support IPv4 at the moment. how is IPv6 represented by the EPM? */
1002 hints
.ai_family
= PF_INET
;
1003 hints
.ai_socktype
= SOCK_STREAM
;
1004 hints
.ai_protocol
= IPPROTO_TCP
;
1005 hints
.ai_addrlen
= 0;
1006 hints
.ai_addr
= NULL
;
1007 hints
.ai_canonname
= NULL
;
1008 hints
.ai_next
= NULL
;
1010 ret
= getaddrinfo(networkaddr
, endpoint
, &hints
, &ai
);
1013 ret
= getaddrinfo("0.0.0.0", endpoint
, &hints
, &ai
);
1016 ERR("getaddrinfo failed: %s\n", gai_strerror(ret
));
1021 if (ai
->ai_family
== PF_INET
)
1023 const struct sockaddr_in
*sin
= (const struct sockaddr_in
*)ai
->ai_addr
;
1024 tcp_floor
->port
= sin
->sin_port
;
1025 ipv4_floor
->ipv4addr
= sin
->sin_addr
.s_addr
;
1029 ERR("unexpected protocol family %d\n", ai
->ai_family
);
1038 static RPC_STATUS
rpcrt4_ncacn_ip_tcp_parse_top_of_tower(const unsigned char *tower_data
,
1043 const twr_tcp_floor_t
*tcp_floor
= (const twr_tcp_floor_t
*)tower_data
;
1044 const twr_ipv4_floor_t
*ipv4_floor
;
1045 struct in_addr in_addr
;
1047 TRACE("(%p, %d, %p, %p)\n", tower_data
, (int)tower_size
, networkaddr
, endpoint
);
1049 if (tower_size
< sizeof(*tcp_floor
))
1050 return EPT_S_NOT_REGISTERED
;
1052 tower_data
+= sizeof(*tcp_floor
);
1053 tower_size
-= sizeof(*tcp_floor
);
1055 if (tower_size
< sizeof(*ipv4_floor
))
1056 return EPT_S_NOT_REGISTERED
;
1058 ipv4_floor
= (const twr_ipv4_floor_t
*)tower_data
;
1060 if ((tcp_floor
->count_lhs
!= sizeof(tcp_floor
->protid
)) ||
1061 (tcp_floor
->protid
!= EPM_PROTOCOL_TCP
) ||
1062 (tcp_floor
->count_rhs
!= sizeof(tcp_floor
->port
)) ||
1063 (ipv4_floor
->count_lhs
!= sizeof(ipv4_floor
->protid
)) ||
1064 (ipv4_floor
->protid
!= EPM_PROTOCOL_IP
) ||
1065 (ipv4_floor
->count_rhs
!= sizeof(ipv4_floor
->ipv4addr
)))
1066 return EPT_S_NOT_REGISTERED
;
1070 *endpoint
= I_RpcAllocate(6 /* sizeof("65535") + 1 */);
1072 return RPC_S_OUT_OF_RESOURCES
;
1073 sprintf(*endpoint
, "%u", ntohs(tcp_floor
->port
));
1078 *networkaddr
= I_RpcAllocate(INET_ADDRSTRLEN
);
1083 I_RpcFree(*endpoint
);
1086 return RPC_S_OUT_OF_RESOURCES
;
1088 in_addr
.s_addr
= ipv4_floor
->ipv4addr
;
1089 if (!inet_ntop(AF_INET
, &in_addr
, *networkaddr
, INET_ADDRSTRLEN
))
1091 ERR("inet_ntop: %s\n", strerror(errno
));
1092 I_RpcFree(*networkaddr
);
1093 *networkaddr
= NULL
;
1096 I_RpcFree(*endpoint
);
1099 return EPT_S_NOT_REGISTERED
;
1106 typedef struct _RpcServerProtseq_sock
1108 RpcServerProtseq common
;
1111 } RpcServerProtseq_sock
;
1113 static RpcServerProtseq
*rpcrt4_protseq_sock_alloc(void)
1115 RpcServerProtseq_sock
*ps
= HeapAlloc(GetProcessHeap(), 0, sizeof(*ps
));
1119 if (!socketpair(PF_UNIX
, SOCK_DGRAM
, 0, fds
))
1121 fcntl(fds
[0], F_SETFL
, O_NONBLOCK
);
1122 fcntl(fds
[1], F_SETFL
, O_NONBLOCK
);
1123 ps
->mgr_event_rcv
= fds
[0];
1124 ps
->mgr_event_snd
= fds
[1];
1128 ERR("socketpair failed with error %s\n", strerror(errno
));
1129 HeapFree(GetProcessHeap(), 0, ps
);
1136 static void rpcrt4_protseq_sock_signal_state_changed(RpcServerProtseq
*protseq
)
1138 RpcServerProtseq_sock
*sockps
= CONTAINING_RECORD(protseq
, RpcServerProtseq_sock
, common
);
1140 write(sockps
->mgr_event_snd
, &dummy
, sizeof(dummy
));
1143 static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq
*protseq
, void *prev_array
, unsigned int *count
)
1145 struct pollfd
*poll_info
= prev_array
;
1146 RpcConnection_tcp
*conn
;
1147 RpcServerProtseq_sock
*sockps
= CONTAINING_RECORD(protseq
, RpcServerProtseq_sock
, common
);
1149 EnterCriticalSection(&protseq
->cs
);
1151 /* open and count connections */
1153 conn
= (RpcConnection_tcp
*)protseq
->conn
;
1155 if (conn
->sock
!= -1)
1157 conn
= (RpcConnection_tcp
*)conn
->common
.Next
;
1160 /* make array of connections */
1162 poll_info
= HeapReAlloc(GetProcessHeap(), 0, poll_info
, *count
*sizeof(*poll_info
));
1164 poll_info
= HeapAlloc(GetProcessHeap(), 0, *count
*sizeof(*poll_info
));
1167 ERR("couldn't allocate poll_info\n");
1168 LeaveCriticalSection(&protseq
->cs
);
1172 poll_info
[0].fd
= sockps
->mgr_event_rcv
;
1173 poll_info
[0].events
= POLLIN
;
1175 conn
= CONTAINING_RECORD(protseq
->conn
, RpcConnection_tcp
, common
);
1177 if (conn
->sock
!= -1)
1179 poll_info
[*count
].fd
= conn
->sock
;
1180 poll_info
[*count
].events
= POLLIN
;
1183 conn
= CONTAINING_RECORD(conn
->common
.Next
, RpcConnection_tcp
, common
);
1185 LeaveCriticalSection(&protseq
->cs
);
1189 static void rpcrt4_protseq_sock_free_wait_array(RpcServerProtseq
*protseq
, void *array
)
1191 HeapFree(GetProcessHeap(), 0, array
);
1194 static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq
*protseq
, unsigned int count
, void *wait_array
)
1196 struct pollfd
*poll_info
= wait_array
;
1198 RpcConnection
*cconn
;
1199 RpcConnection_tcp
*conn
;
1204 ret
= poll(poll_info
, count
, -1);
1207 ERR("poll failed with error %d\n", ret
);
1211 for (i
= 0; i
< count
; i
++)
1212 if (poll_info
[i
].revents
& POLLIN
)
1214 /* RPC server event */
1218 read(poll_info
[0].fd
, &dummy
, sizeof(dummy
));
1222 /* find which connection got a RPC */
1223 EnterCriticalSection(&protseq
->cs
);
1224 conn
= CONTAINING_RECORD(protseq
->conn
, RpcConnection_tcp
, common
);
1226 if (poll_info
[i
].fd
== conn
->sock
) break;
1227 conn
= CONTAINING_RECORD(conn
->common
.Next
, RpcConnection_tcp
, common
);
1231 RPCRT4_SpawnConnection(&cconn
, &conn
->common
);
1233 ERR("failed to locate connection for fd %d\n", poll_info
[i
].fd
);
1234 LeaveCriticalSection(&protseq
->cs
);
1236 RPCRT4_new_client(cconn
);
1244 static const struct connection_ops conn_protseq_list
[] = {
1246 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_SMB
},
1247 rpcrt4_conn_np_alloc
,
1248 rpcrt4_ncacn_np_open
,
1249 rpcrt4_ncacn_np_handoff
,
1250 rpcrt4_conn_np_read
,
1251 rpcrt4_conn_np_write
,
1252 rpcrt4_conn_np_close
,
1253 rpcrt4_ncacn_np_get_top_of_tower
,
1254 rpcrt4_ncacn_np_parse_top_of_tower
,
1257 { EPM_PROTOCOL_NCALRPC
, EPM_PROTOCOL_PIPE
},
1258 rpcrt4_conn_np_alloc
,
1259 rpcrt4_ncalrpc_open
,
1260 rpcrt4_ncalrpc_handoff
,
1261 rpcrt4_conn_np_read
,
1262 rpcrt4_conn_np_write
,
1263 rpcrt4_conn_np_close
,
1264 rpcrt4_ncalrpc_get_top_of_tower
,
1265 rpcrt4_ncalrpc_parse_top_of_tower
,
1268 { EPM_PROTOCOL_NCACN
, EPM_PROTOCOL_TCP
},
1269 rpcrt4_conn_tcp_alloc
,
1270 rpcrt4_ncacn_ip_tcp_open
,
1271 rpcrt4_conn_tcp_handoff
,
1272 rpcrt4_conn_tcp_read
,
1273 rpcrt4_conn_tcp_write
,
1274 rpcrt4_conn_tcp_close
,
1275 rpcrt4_ncacn_ip_tcp_get_top_of_tower
,
1276 rpcrt4_ncacn_ip_tcp_parse_top_of_tower
,
1281 static const struct protseq_ops protseq_list
[] =
1285 rpcrt4_protseq_np_alloc
,
1286 rpcrt4_protseq_np_signal_state_changed
,
1287 rpcrt4_protseq_np_get_wait_array
,
1288 rpcrt4_protseq_np_free_wait_array
,
1289 rpcrt4_protseq_np_wait_for_new_connection
,
1290 rpcrt4_protseq_ncacn_np_open_endpoint
,
1294 rpcrt4_protseq_np_alloc
,
1295 rpcrt4_protseq_np_signal_state_changed
,
1296 rpcrt4_protseq_np_get_wait_array
,
1297 rpcrt4_protseq_np_free_wait_array
,
1298 rpcrt4_protseq_np_wait_for_new_connection
,
1299 rpcrt4_protseq_ncalrpc_open_endpoint
,
1303 rpcrt4_protseq_sock_alloc
,
1304 rpcrt4_protseq_sock_signal_state_changed
,
1305 rpcrt4_protseq_sock_get_wait_array
,
1306 rpcrt4_protseq_sock_free_wait_array
,
1307 rpcrt4_protseq_sock_wait_for_new_connection
,
1308 rpcrt4_protseq_ncacn_ip_tcp_open_endpoint
,
1312 #define ARRAYSIZE(a) (sizeof((a)) / sizeof((a)[0]))
1314 const struct protseq_ops
*rpcrt4_get_protseq_ops(const char *protseq
)
1317 for(i
=0; i
<ARRAYSIZE(protseq_list
); i
++)
1318 if (!strcmp(protseq_list
[i
].name
, protseq
))
1319 return &protseq_list
[i
];
1323 static const struct connection_ops
*rpcrt4_get_conn_protseq_ops(const char *protseq
)
1326 for(i
=0; i
<ARRAYSIZE(conn_protseq_list
); i
++)
1327 if (!strcmp(conn_protseq_list
[i
].name
, protseq
))
1328 return &conn_protseq_list
[i
];
1332 /**** interface to rest of code ****/
1334 RPC_STATUS
RPCRT4_OpenClientConnection(RpcConnection
* Connection
)
1336 TRACE("(Connection == ^%p)\n", Connection
);
1338 assert(!Connection
->server
);
1339 return Connection
->ops
->open_connection_client(Connection
);
1342 RPC_STATUS
RPCRT4_CloseConnection(RpcConnection
* Connection
)
1344 TRACE("(Connection == ^%p)\n", Connection
);
1345 if (SecIsValidHandle(&Connection
->ctx
))
1347 DeleteSecurityContext(&Connection
->ctx
);
1348 SecInvalidateHandle(&Connection
->ctx
);
1350 rpcrt4_conn_close(Connection
);
1354 RPC_STATUS
RPCRT4_CreateConnection(RpcConnection
** Connection
, BOOL server
,
1355 LPCSTR Protseq
, LPCSTR NetworkAddr
, LPCSTR Endpoint
,
1356 LPCWSTR NetworkOptions
, RpcAuthInfo
* AuthInfo
, RpcQualityOfService
*QOS
)
1358 const struct connection_ops
*ops
;
1359 RpcConnection
* NewConnection
;
1361 ops
= rpcrt4_get_conn_protseq_ops(Protseq
);
1364 FIXME("not supported for protseq %s\n", Protseq
);
1365 return RPC_S_PROTSEQ_NOT_SUPPORTED
;
1368 NewConnection
= ops
->alloc();
1369 NewConnection
->Next
= NULL
;
1370 NewConnection
->server
= server
;
1371 NewConnection
->ops
= ops
;
1372 NewConnection
->NetworkAddr
= RPCRT4_strdupA(NetworkAddr
);
1373 NewConnection
->Endpoint
= RPCRT4_strdupA(Endpoint
);
1374 NewConnection
->NetworkOptions
= RPCRT4_strdupW(NetworkOptions
);
1375 NewConnection
->MaxTransmissionSize
= RPC_MAX_PACKET_SIZE
;
1376 memset(&NewConnection
->ActiveInterface
, 0, sizeof(NewConnection
->ActiveInterface
));
1377 NewConnection
->NextCallId
= 1;
1379 SecInvalidateHandle(&NewConnection
->ctx
);
1380 memset(&NewConnection
->exp
, 0, sizeof(NewConnection
->exp
));
1381 NewConnection
->attr
= 0;
1382 if (AuthInfo
) RpcAuthInfo_AddRef(AuthInfo
);
1383 NewConnection
->AuthInfo
= AuthInfo
;
1384 NewConnection
->encryption_auth_len
= 0;
1385 NewConnection
->signature_auth_len
= 0;
1386 if (QOS
) RpcQualityOfService_AddRef(QOS
);
1387 NewConnection
->QOS
= QOS
;
1389 list_init(&NewConnection
->conn_pool_entry
);
1391 TRACE("connection: %p\n", NewConnection
);
1392 *Connection
= NewConnection
;
1397 RPC_STATUS
RPCRT4_GetAssociation(LPCSTR Protseq
, LPCSTR NetworkAddr
,
1398 LPCSTR Endpoint
, LPCWSTR NetworkOptions
,
1399 RpcAssoc
**assoc_out
)
1403 EnterCriticalSection(&assoc_list_cs
);
1404 LIST_FOR_EACH_ENTRY(assoc
, &assoc_list
, RpcAssoc
, entry
)
1406 if (!strcmp(Protseq
, assoc
->Protseq
) &&
1407 !strcmp(NetworkAddr
, assoc
->NetworkAddr
) &&
1408 !strcmp(Endpoint
, assoc
->Endpoint
) &&
1409 ((!assoc
->NetworkOptions
&& !NetworkOptions
) || !strcmpW(NetworkOptions
, assoc
->NetworkOptions
)))
1413 LeaveCriticalSection(&assoc_list_cs
);
1414 TRACE("using existing assoc %p\n", assoc
);
1419 assoc
= HeapAlloc(GetProcessHeap(), 0, sizeof(*assoc
));
1422 LeaveCriticalSection(&assoc_list_cs
);
1423 return RPC_S_OUT_OF_RESOURCES
;
1426 list_init(&assoc
->connection_pool
);
1427 InitializeCriticalSection(&assoc
->cs
);
1428 assoc
->Protseq
= RPCRT4_strdupA(Protseq
);
1429 assoc
->NetworkAddr
= RPCRT4_strdupA(NetworkAddr
);
1430 assoc
->Endpoint
= RPCRT4_strdupA(Endpoint
);
1431 assoc
->NetworkOptions
= NetworkOptions
? RPCRT4_strdupW(NetworkOptions
) : NULL
;
1432 assoc
->assoc_group_id
= 0;
1433 list_add_head(&assoc_list
, &assoc
->entry
);
1436 LeaveCriticalSection(&assoc_list_cs
);
1438 TRACE("new assoc %p\n", assoc
);
1443 ULONG
RpcAssoc_Release(RpcAssoc
*assoc
)
1447 EnterCriticalSection(&assoc_list_cs
);
1448 refs
= --assoc
->refs
;
1450 list_remove(&assoc
->entry
);
1451 LeaveCriticalSection(&assoc_list_cs
);
1455 RpcConnection
*Connection
, *cursor2
;
1457 TRACE("destroying assoc %p\n", assoc
);
1459 LIST_FOR_EACH_ENTRY_SAFE(Connection
, cursor2
, &assoc
->connection_pool
, RpcConnection
, conn_pool_entry
)
1461 list_remove(&Connection
->conn_pool_entry
);
1462 RPCRT4_DestroyConnection(Connection
);
1465 HeapFree(GetProcessHeap(), 0, assoc
->NetworkOptions
);
1466 HeapFree(GetProcessHeap(), 0, assoc
->Endpoint
);
1467 HeapFree(GetProcessHeap(), 0, assoc
->NetworkAddr
);
1468 HeapFree(GetProcessHeap(), 0, assoc
->Protseq
);
1470 HeapFree(GetProcessHeap(), 0, assoc
);
1476 #define ROUND_UP(value, alignment) (((value) + ((alignment) - 1)) & ~((alignment)-1))
1478 static RPC_STATUS
RpcAssoc_BindConnection(const RpcAssoc
*assoc
, RpcConnection
*conn
,
1479 const RPC_SYNTAX_IDENTIFIER
*InterfaceId
,
1480 const RPC_SYNTAX_IDENTIFIER
*TransferSyntax
)
1483 RpcPktHdr
*response_hdr
;
1487 TRACE("sending bind request to server\n");
1489 hdr
= RPCRT4_BuildBindHeader(NDR_LOCAL_DATA_REPRESENTATION
,
1490 RPC_MAX_PACKET_SIZE
, RPC_MAX_PACKET_SIZE
,
1491 assoc
->assoc_group_id
,
1492 InterfaceId
, TransferSyntax
);
1494 status
= RPCRT4_Send(conn
, hdr
, NULL
, 0);
1495 RPCRT4_FreeHeader(hdr
);
1496 if (status
!= RPC_S_OK
)
1499 status
= RPCRT4_Receive(conn
, &response_hdr
, &msg
);
1500 if (status
!= RPC_S_OK
)
1502 ERR("receive failed\n");
1506 switch (response_hdr
->common
.ptype
)
1510 RpcAddressString
*server_address
= msg
.Buffer
;
1511 if ((msg
.BufferLength
>= FIELD_OFFSET(RpcAddressString
, string
[0])) ||
1512 (msg
.BufferLength
>= ROUND_UP(FIELD_OFFSET(RpcAddressString
, string
[server_address
->length
]), 4)))
1514 unsigned short remaining
= msg
.BufferLength
-
1515 ROUND_UP(FIELD_OFFSET(RpcAddressString
, string
[server_address
->length
]), 4);
1516 RpcResults
*results
= (RpcResults
*)((ULONG_PTR
)server_address
+
1517 ROUND_UP(FIELD_OFFSET(RpcAddressString
, string
[server_address
->length
]), 4));
1518 if ((results
->num_results
== 1) && (remaining
>= sizeof(*results
)))
1520 switch (results
->results
[0].result
)
1523 conn
->assoc_group_id
= response_hdr
->bind_ack
.assoc_gid
;
1524 conn
->MaxTransmissionSize
= response_hdr
->bind_ack
.max_tsize
;
1525 conn
->ActiveInterface
= *InterfaceId
;
1527 case RESULT_PROVIDER_REJECTION
:
1528 switch (results
->results
[0].reason
)
1530 case REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED
:
1531 ERR("syntax %s, %d.%d not supported\n",
1532 debugstr_guid(&InterfaceId
->SyntaxGUID
),
1533 InterfaceId
->SyntaxVersion
.MajorVersion
,
1534 InterfaceId
->SyntaxVersion
.MinorVersion
);
1535 status
= RPC_S_UNKNOWN_IF
;
1537 case REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED
:
1538 ERR("transfer syntax not supported\n");
1539 status
= RPC_S_SERVER_UNAVAILABLE
;
1543 status
= RPC_S_CALL_FAILED_DNE
;
1546 case RESULT_USER_REJECTION
:
1548 ERR("rejection result %d\n", results
->results
[0].result
);
1549 status
= RPC_S_CALL_FAILED_DNE
;
1554 ERR("incorrect results size\n");
1555 status
= RPC_S_CALL_FAILED_DNE
;
1560 ERR("bind ack packet too small (%d)\n", msg
.BufferLength
);
1561 status
= RPC_S_PROTOCOL_ERROR
;
1566 switch (response_hdr
->bind_nack
.reject_reason
)
1568 case REJECT_LOCAL_LIMIT_EXCEEDED
:
1569 case REJECT_TEMPORARY_CONGESTION
:
1570 ERR("server too busy\n");
1571 status
= RPC_S_SERVER_TOO_BUSY
;
1573 case REJECT_PROTOCOL_VERSION_NOT_SUPPORTED
:
1574 ERR("protocol version not supported\n");
1575 status
= RPC_S_PROTOCOL_ERROR
;
1577 case REJECT_UNKNOWN_AUTHN_SERVICE
:
1578 ERR("unknown authentication service\n");
1579 status
= RPC_S_UNKNOWN_AUTHN_SERVICE
;
1581 case REJECT_INVALID_CHECKSUM
:
1582 ERR("invalid checksum\n");
1583 status
= ERROR_ACCESS_DENIED
;
1586 ERR("rejected bind for reason %d\n", response_hdr
->bind_nack
.reject_reason
);
1587 status
= RPC_S_CALL_FAILED_DNE
;
1591 ERR("wrong packet type received %d\n", response_hdr
->common
.ptype
);
1592 status
= RPC_S_PROTOCOL_ERROR
;
1596 RPCRT4_FreeHeader(response_hdr
);
1600 static RpcConnection
*RpcAssoc_GetIdleConnection(RpcAssoc
*assoc
,
1601 const RPC_SYNTAX_IDENTIFIER
*InterfaceId
,
1602 const RPC_SYNTAX_IDENTIFIER
*TransferSyntax
, const RpcAuthInfo
*AuthInfo
,
1603 const RpcQualityOfService
*QOS
)
1605 RpcConnection
*Connection
;
1606 EnterCriticalSection(&assoc
->cs
);
1607 /* try to find a compatible connection from the connection pool */
1608 LIST_FOR_EACH_ENTRY(Connection
, &assoc
->connection_pool
, RpcConnection
, conn_pool_entry
)
1610 if (!memcmp(&Connection
->ActiveInterface
, InterfaceId
,
1611 sizeof(RPC_SYNTAX_IDENTIFIER
)) &&
1612 RpcAuthInfo_IsEqual(Connection
->AuthInfo
, AuthInfo
) &&
1613 RpcQualityOfService_IsEqual(Connection
->QOS
, QOS
))
1615 list_remove(&Connection
->conn_pool_entry
);
1616 LeaveCriticalSection(&assoc
->cs
);
1617 TRACE("got connection from pool %p\n", Connection
);
1622 LeaveCriticalSection(&assoc
->cs
);
1626 RPC_STATUS
RpcAssoc_GetClientConnection(RpcAssoc
*assoc
,
1627 const RPC_SYNTAX_IDENTIFIER
*InterfaceId
,
1628 const RPC_SYNTAX_IDENTIFIER
*TransferSyntax
, RpcAuthInfo
*AuthInfo
,
1629 RpcQualityOfService
*QOS
, RpcConnection
**Connection
)
1631 RpcConnection
*NewConnection
;
1634 *Connection
= RpcAssoc_GetIdleConnection(assoc
, InterfaceId
, TransferSyntax
, AuthInfo
, QOS
);
1638 /* create a new connection */
1639 status
= RPCRT4_CreateConnection(&NewConnection
, FALSE
/* is this a server connection? */,
1640 assoc
->Protseq
, assoc
->NetworkAddr
,
1641 assoc
->Endpoint
, assoc
->NetworkOptions
,
1643 if (status
!= RPC_S_OK
)
1646 status
= RPCRT4_OpenClientConnection(NewConnection
);
1647 if (status
!= RPC_S_OK
)
1649 RPCRT4_DestroyConnection(NewConnection
);
1653 status
= RpcAssoc_BindConnection(assoc
, NewConnection
, InterfaceId
, TransferSyntax
);
1654 if (status
!= RPC_S_OK
)
1656 RPCRT4_DestroyConnection(NewConnection
);
1660 *Connection
= NewConnection
;
1665 void RpcAssoc_ReleaseIdleConnection(RpcAssoc
*assoc
, RpcConnection
*Connection
)
1667 assert(!Connection
->server
);
1668 EnterCriticalSection(&assoc
->cs
);
1669 if (!assoc
->assoc_group_id
) assoc
->assoc_group_id
= Connection
->assoc_group_id
;
1670 list_add_head(&assoc
->connection_pool
, &Connection
->conn_pool_entry
);
1671 LeaveCriticalSection(&assoc
->cs
);
1675 RPC_STATUS
RPCRT4_SpawnConnection(RpcConnection
** Connection
, RpcConnection
* OldConnection
)
1679 err
= RPCRT4_CreateConnection(Connection
, OldConnection
->server
,
1680 rpcrt4_conn_get_name(OldConnection
),
1681 OldConnection
->NetworkAddr
,
1682 OldConnection
->Endpoint
, NULL
,
1683 OldConnection
->AuthInfo
, OldConnection
->QOS
);
1684 if (err
== RPC_S_OK
)
1685 rpcrt4_conn_handoff(OldConnection
, *Connection
);
1689 RPC_STATUS
RPCRT4_DestroyConnection(RpcConnection
* Connection
)
1691 TRACE("connection: %p\n", Connection
);
1693 RPCRT4_CloseConnection(Connection
);
1694 RPCRT4_strfree(Connection
->Endpoint
);
1695 RPCRT4_strfree(Connection
->NetworkAddr
);
1696 HeapFree(GetProcessHeap(), 0, Connection
->NetworkOptions
);
1697 if (Connection
->AuthInfo
) RpcAuthInfo_Release(Connection
->AuthInfo
);
1698 if (Connection
->QOS
) RpcQualityOfService_Release(Connection
->QOS
);
1699 HeapFree(GetProcessHeap(), 0, Connection
);
1703 RPC_STATUS
RpcTransport_GetTopOfTower(unsigned char *tower_data
,
1705 const char *protseq
,
1706 const char *networkaddr
,
1707 const char *endpoint
)
1709 twr_empty_floor_t
*protocol_floor
;
1710 const struct connection_ops
*protseq_ops
= rpcrt4_get_conn_protseq_ops(protseq
);
1715 return RPC_S_INVALID_RPC_PROTSEQ
;
1719 *tower_size
= sizeof(*protocol_floor
);
1720 *tower_size
+= protseq_ops
->get_top_of_tower(NULL
, networkaddr
, endpoint
);
1724 protocol_floor
= (twr_empty_floor_t
*)tower_data
;
1725 protocol_floor
->count_lhs
= sizeof(protocol_floor
->protid
);
1726 protocol_floor
->protid
= protseq_ops
->epm_protocols
[0];
1727 protocol_floor
->count_rhs
= 0;
1729 tower_data
+= sizeof(*protocol_floor
);
1731 *tower_size
= protseq_ops
->get_top_of_tower(tower_data
, networkaddr
, endpoint
);
1733 return EPT_S_NOT_REGISTERED
;
1735 *tower_size
+= sizeof(*protocol_floor
);
1740 RPC_STATUS
RpcTransport_ParseTopOfTower(const unsigned char *tower_data
,
1746 const twr_empty_floor_t
*protocol_floor
;
1747 const twr_empty_floor_t
*floor4
;
1748 const struct connection_ops
*protseq_ops
= NULL
;
1752 if (tower_size
< sizeof(*protocol_floor
))
1753 return EPT_S_NOT_REGISTERED
;
1755 protocol_floor
= (const twr_empty_floor_t
*)tower_data
;
1756 tower_data
+= sizeof(*protocol_floor
);
1757 tower_size
-= sizeof(*protocol_floor
);
1758 if ((protocol_floor
->count_lhs
!= sizeof(protocol_floor
->protid
)) ||
1759 (protocol_floor
->count_rhs
> tower_size
))
1760 return EPT_S_NOT_REGISTERED
;
1761 tower_data
+= protocol_floor
->count_rhs
;
1762 tower_size
-= protocol_floor
->count_rhs
;
1764 floor4
= (const twr_empty_floor_t
*)tower_data
;
1765 if ((tower_size
< sizeof(*floor4
)) ||
1766 (floor4
->count_lhs
!= sizeof(floor4
->protid
)))
1767 return EPT_S_NOT_REGISTERED
;
1769 for(i
= 0; i
< ARRAYSIZE(conn_protseq_list
); i
++)
1770 if ((protocol_floor
->protid
== conn_protseq_list
[i
].epm_protocols
[0]) &&
1771 (floor4
->protid
== conn_protseq_list
[i
].epm_protocols
[1]))
1773 protseq_ops
= &conn_protseq_list
[i
];
1778 return EPT_S_NOT_REGISTERED
;
1780 status
= protseq_ops
->parse_top_of_tower(tower_data
, tower_size
, networkaddr
, endpoint
);
1782 if ((status
== RPC_S_OK
) && protseq
)
1784 *protseq
= I_RpcAllocate(strlen(protseq_ops
->name
) + 1);
1785 strcpy(*protseq
, protseq_ops
->name
);
1791 /***********************************************************************
1792 * RpcNetworkIsProtseqValidW (RPCRT4.@)
1794 * Checks if the given protocol sequence is known by the RPC system.
1795 * If it is, returns RPC_S_OK, otherwise RPC_S_PROTSEQ_NOT_SUPPORTED.
1798 RPC_STATUS WINAPI
RpcNetworkIsProtseqValidW(RPC_WSTR protseq
)
1802 WideCharToMultiByte(CP_ACP
, 0, protseq
, -1,
1803 ps
, sizeof ps
, NULL
, NULL
);
1804 if (rpcrt4_get_conn_protseq_ops(ps
))
1807 FIXME("Unknown protseq %s\n", debugstr_w(protseq
));
1809 return RPC_S_INVALID_RPC_PROTSEQ
;
1812 /***********************************************************************
1813 * RpcNetworkIsProtseqValidA (RPCRT4.@)
1815 RPC_STATUS WINAPI
RpcNetworkIsProtseqValidA(RPC_CSTR protseq
)
1817 UNICODE_STRING protseqW
;
1819 if (RtlCreateUnicodeStringFromAsciiz(&protseqW
, (char*)protseq
))
1821 RPC_STATUS ret
= RpcNetworkIsProtseqValidW(protseqW
.Buffer
);
1822 RtlFreeUnicodeString(&protseqW
);
1825 return RPC_S_OUT_OF_MEMORY
;