4 * Copyright 2001 Ove Kåven, TransGaming Technologies
5 * Copyright 2004 Filip Navara
6 * Copyright 2006-2008 Robert Shearman (for CodeWeavers)
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wine/port.h"
39 #include "wine/debug.h"
40 #include "wine/exception.h"
42 #include "rpc_server.h"
43 #include "rpc_assoc.h"
44 #include "rpc_message.h"
46 #include "ncastatus.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
50 typedef struct _RpcPacket
52 struct _RpcConnection* conn;
57 typedef struct _RpcObjTypeMap
59 /* FIXME: a hash table would be better. */
60 struct _RpcObjTypeMap *next;
65 static RpcObjTypeMap *RpcObjTypeMaps;
67 /* list of type RpcServerProtseq */
68 static struct list protseqs = LIST_INIT(protseqs);
69 static struct list server_interfaces = LIST_INIT(server_interfaces);
71 static CRITICAL_SECTION server_cs;
72 static CRITICAL_SECTION_DEBUG server_cs_debug =
75 { &server_cs_debug.ProcessLocksList, &server_cs_debug.ProcessLocksList },
76 0, 0, { (DWORD_PTR)(__FILE__ ": server_cs") }
78 static CRITICAL_SECTION server_cs = { &server_cs_debug, -1, 0, 0, 0, 0 };
80 static CRITICAL_SECTION listen_cs;
81 static CRITICAL_SECTION_DEBUG listen_cs_debug =
84 { &listen_cs_debug.ProcessLocksList, &listen_cs_debug.ProcessLocksList },
85 0, 0, { (DWORD_PTR)(__FILE__ ": listen_cs") }
87 static CRITICAL_SECTION listen_cs = { &listen_cs_debug, -1, 0, 0, 0, 0 };
89 /* whether the server is currently listening */
90 static BOOL std_listen;
91 /* number of manual listeners (calls to RpcServerListen) */
92 static LONG manual_listen_count;
93 /* total listeners including auto listeners */
94 static LONG listen_count;
98 static inline RpcObjTypeMap *LookupObjTypeMap(UUID *ObjUuid)
100 RpcObjTypeMap *rslt = RpcObjTypeMaps;
104 if (! UuidCompare(ObjUuid, &rslt->Object, &dummy)) break;
111 static inline UUID *LookupObjType(UUID *ObjUuid)
113 RpcObjTypeMap *map = LookupObjTypeMap(ObjUuid);
120 static RpcServerInterface* RPCRT4_find_interface(UUID* object,
121 const RPC_SYNTAX_IDENTIFIER* if_id,
124 UUID* MgrType = NULL;
125 RpcServerInterface* cif;
129 MgrType = LookupObjType(object);
130 EnterCriticalSection(&server_cs);
131 LIST_FOR_EACH_ENTRY(cif, &server_interfaces, RpcServerInterface, entry) {
132 if (!memcmp(if_id, &cif->If->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER)) &&
133 (check_object == FALSE || UuidEqual(MgrType, &cif->MgrTypeUuid, &status)) &&
135 InterlockedIncrement(&cif->CurrentCalls);
139 LeaveCriticalSection(&server_cs);
140 if (&cif->entry == &server_interfaces) cif = NULL;
141 TRACE("returning %p for object %s, if_id { %d.%d %s }\n", cif,
142 debugstr_guid(object), if_id->SyntaxVersion.MajorVersion,
143 if_id->SyntaxVersion.MinorVersion, debugstr_guid(&if_id->SyntaxGUID));
147 static void RPCRT4_release_server_interface(RpcServerInterface *sif)
149 if (!InterlockedDecrement(&sif->CurrentCalls) &&
151 /* sif must have been removed from server_interfaces before
152 * CallsCompletedEvent is set */
153 if (sif->CallsCompletedEvent)
154 SetEvent(sif->CallsCompletedEvent);
155 HeapFree(GetProcessHeap(), 0, sif);
159 static RPC_STATUS process_bind_packet(RpcConnection *conn, RpcPktBindHdr *hdr, RPC_MESSAGE *msg)
162 RpcServerInterface* sif;
163 RpcPktHdr *response = NULL;
165 /* FIXME: do more checks! */
166 if (hdr->max_tsize < RPC_MIN_PACKET_SIZE ||
167 !UuidIsNil(&conn->ActiveInterface.SyntaxGUID, &status) ||
168 conn->server_binding) {
169 TRACE("packet size less than min size, or active interface syntax guid non-null\n");
172 /* create temporary binding */
173 if (RPCRT4_MakeBinding(&conn->server_binding, conn) == RPC_S_OK &&
174 RpcServerAssoc_GetAssociation(rpcrt4_conn_get_name(conn),
175 conn->NetworkAddr, conn->Endpoint,
176 conn->NetworkOptions,
178 &conn->server_binding->Assoc) == RPC_S_OK)
179 sif = RPCRT4_find_interface(NULL, &hdr->abstract, FALSE);
184 TRACE("rejecting bind request on connection %p\n", conn);
185 /* Report failure to client. */
186 response = RPCRT4_BuildBindNackHeader(NDR_LOCAL_DATA_REPRESENTATION,
187 RPC_VER_MAJOR, RPC_VER_MINOR);
189 TRACE("accepting bind request on connection %p for %s\n", conn,
190 debugstr_guid(&hdr->abstract.SyntaxGUID));
193 response = RPCRT4_BuildBindAckHeader(NDR_LOCAL_DATA_REPRESENTATION,
196 conn->server_binding->Assoc->assoc_group_id,
198 RESULT_ACCEPT, REASON_NONE,
199 &sif->If->TransferSyntax);
201 /* save the interface for later use */
202 conn->ActiveInterface = hdr->abstract;
203 conn->MaxTransmissionSize = hdr->max_tsize;
205 RPCRT4_release_server_interface(sif);
209 status = RPCRT4_Send(conn, response, NULL, 0);
211 status = ERROR_OUTOFMEMORY;
212 RPCRT4_FreeHeader(response);
217 static RPC_STATUS process_request_packet(RpcConnection *conn, RpcPktRequestHdr *hdr, RPC_MESSAGE *msg)
220 RpcPktHdr *response = NULL;
221 RpcServerInterface* sif;
222 RPC_DISPATCH_FUNCTION func;
225 NDR_SCONTEXT context_handle;
226 void *buf = msg->Buffer;
228 /* fail if the connection isn't bound with an interface */
229 if (UuidIsNil(&conn->ActiveInterface.SyntaxGUID, &status)) {
230 /* FIXME: should send BindNack instead */
231 response = RPCRT4_BuildFaultHeader(NDR_LOCAL_DATA_REPRESENTATION,
234 RPCRT4_Send(conn, response, NULL, 0);
235 RPCRT4_FreeHeader(response);
239 if (hdr->common.flags & RPC_FLG_OBJECT_UUID) {
240 object_uuid = (UUID*)(hdr + 1);
245 sif = RPCRT4_find_interface(object_uuid, &conn->ActiveInterface, TRUE);
247 WARN("interface %s no longer registered, returning fault packet\n", debugstr_guid(&conn->ActiveInterface.SyntaxGUID));
248 response = RPCRT4_BuildFaultHeader(NDR_LOCAL_DATA_REPRESENTATION,
251 RPCRT4_Send(conn, response, NULL, 0);
252 RPCRT4_FreeHeader(response);
255 msg->RpcInterfaceInformation = sif->If;
256 /* copy the endpoint vector from sif to msg so that midl-generated code will use it */
257 msg->ManagerEpv = sif->MgrEpv;
258 if (object_uuid != NULL) {
259 RPCRT4_SetBindingObject(msg->Handle, object_uuid);
262 /* find dispatch function */
263 msg->ProcNum = hdr->opnum;
264 if (sif->Flags & RPC_IF_OLE) {
265 /* native ole32 always gives us a dispatch table with a single entry
266 * (I assume that's a wrapper for IRpcStubBuffer::Invoke) */
267 func = *sif->If->DispatchTable->DispatchTable;
269 if (msg->ProcNum >= sif->If->DispatchTable->DispatchTableCount) {
270 WARN("invalid procnum (%d/%d)\n", msg->ProcNum, sif->If->DispatchTable->DispatchTableCount);
271 response = RPCRT4_BuildFaultHeader(NDR_LOCAL_DATA_REPRESENTATION,
274 RPCRT4_Send(conn, response, NULL, 0);
275 RPCRT4_FreeHeader(response);
277 func = sif->If->DispatchTable->DispatchTable[msg->ProcNum];
280 /* put in the drep. FIXME: is this more universally applicable?
281 perhaps we should move this outward... */
282 msg->DataRepresentation =
283 MAKELONG( MAKEWORD(hdr->common.drep[0], hdr->common.drep[1]),
284 MAKEWORD(hdr->common.drep[2], hdr->common.drep[3]));
289 RPCRT4_SetThreadCurrentCallHandle(msg->Handle);
293 WARN("exception caught with code 0x%08x = %d\n", GetExceptionCode(), GetExceptionCode());
295 if (GetExceptionCode() == STATUS_ACCESS_VIOLATION)
296 status = ERROR_NOACCESS;
298 status = GetExceptionCode();
299 response = RPCRT4_BuildFaultHeader(msg->DataRepresentation,
300 RPC2NCA_STATUS(status));
302 RPCRT4_SetThreadCurrentCallHandle(NULL);
304 /* release any unmarshalled context handles */
305 while ((context_handle = RPCRT4_PopThreadContextHandle()) != NULL)
306 RpcServerAssoc_ReleaseContextHandle(conn->server_binding->Assoc, context_handle, TRUE);
309 response = RPCRT4_BuildResponseHeader(msg->DataRepresentation,
312 /* send response packet */
314 status = RPCRT4_Send(conn, response, exception ? NULL : msg->Buffer,
315 exception ? 0 : msg->BufferLength);
316 RPCRT4_FreeHeader(response);
318 ERR("out of memory\n");
320 msg->RpcInterfaceInformation = NULL;
321 RPCRT4_release_server_interface(sif);
323 if (msg->Buffer == buf) buf = NULL;
324 TRACE("freeing Buffer=%p\n", buf);
330 static void RPCRT4_process_packet(RpcConnection* conn, RpcPktHdr* hdr, RPC_MESSAGE* msg)
334 msg->Handle = (RPC_BINDING_HANDLE)conn->server_binding;
336 switch (hdr->common.ptype) {
338 TRACE("got bind packet\n");
340 status = process_bind_packet(conn, &hdr->bind, msg);
344 TRACE("got request packet\n");
346 status = process_request_packet(conn, &hdr->request, msg);
350 FIXME("unhandled packet type %u\n", hdr->common.ptype);
355 I_RpcFreeBuffer(msg);
356 RPCRT4_FreeHeader(hdr);
357 HeapFree(GetProcessHeap(), 0, msg);
360 static DWORD CALLBACK RPCRT4_worker_thread(LPVOID the_arg)
362 RpcPacket *pkt = the_arg;
363 RPCRT4_process_packet(pkt->conn, pkt->hdr, pkt->msg);
364 HeapFree(GetProcessHeap(), 0, pkt);
368 static DWORD CALLBACK RPCRT4_io_thread(LPVOID the_arg)
370 RpcConnection* conn = (RpcConnection*)the_arg;
376 TRACE("(%p)\n", conn);
379 msg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RPC_MESSAGE));
381 status = RPCRT4_Receive(conn, &hdr, msg);
382 if (status != RPC_S_OK) {
383 WARN("receive failed with error %lx\n", status);
384 HeapFree(GetProcessHeap(), 0, msg);
388 packet = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcPacket));
390 I_RpcFree(msg->Buffer);
391 HeapFree(GetProcessHeap(), 0, msg);
397 if (!QueueUserWorkItem(RPCRT4_worker_thread, packet, WT_EXECUTELONGFUNCTION)) {
398 ERR("couldn't queue work item for worker thread, error was %d\n", GetLastError());
399 I_RpcFree(msg->Buffer);
400 HeapFree(GetProcessHeap(), 0, msg);
401 HeapFree(GetProcessHeap(), 0, packet);
407 RPCRT4_DestroyConnection(conn);
411 void RPCRT4_new_client(RpcConnection* conn)
413 HANDLE thread = CreateThread(NULL, 0, RPCRT4_io_thread, conn, 0, NULL);
415 DWORD err = GetLastError();
416 ERR("failed to create thread, error=%08x\n", err);
417 RPCRT4_DestroyConnection(conn);
419 /* we could set conn->thread, but then we'd have to make the io_thread wait
420 * for that, otherwise the thread might finish, destroy the connection, and
421 * free the memory we'd write to before we did, causing crashes and stuff -
422 * so let's implement that later, when we really need conn->thread */
424 CloseHandle( thread );
427 static DWORD CALLBACK RPCRT4_server_thread(LPVOID the_arg)
432 RpcServerProtseq* cps = the_arg;
434 BOOL set_ready_event = FALSE;
436 TRACE("(the_arg == ^%p)\n", the_arg);
439 objs = cps->ops->get_wait_array(cps, objs, &count);
443 /* signal to function that changed state that we are now sync'ed */
444 SetEvent(cps->server_ready_event);
445 set_ready_event = FALSE;
449 res = cps->ops->wait_for_new_connection(cps, count, objs);
456 SetEvent(cps->server_ready_event);
459 set_ready_event = TRUE;
462 cps->ops->free_wait_array(cps, objs);
463 EnterCriticalSection(&cps->cs);
464 /* close connections */
467 RPCRT4_CloseConnection(conn);
470 LeaveCriticalSection(&cps->cs);
474 /* tells the server thread that the state has changed and waits for it to
475 * make the changes */
476 static void RPCRT4_sync_with_server_thread(RpcServerProtseq *ps)
478 /* make sure we are the only thread sync'ing the server state, otherwise
479 * there is a race with the server thread setting an older state and setting
480 * the server_ready_event when the new state hasn't yet been applied */
481 WaitForSingleObject(ps->mgr_mutex, INFINITE);
483 ps->ops->signal_state_changed(ps);
485 /* wait for server thread to make the requested changes before returning */
486 WaitForSingleObject(ps->server_ready_event, INFINITE);
488 ReleaseMutex(ps->mgr_mutex);
491 static RPC_STATUS RPCRT4_start_listen_protseq(RpcServerProtseq *ps, BOOL auto_listen)
493 RPC_STATUS status = RPC_S_OK;
494 HANDLE server_thread;
496 EnterCriticalSection(&listen_cs);
497 if (ps->is_listening) goto done;
499 if (!ps->mgr_mutex) ps->mgr_mutex = CreateMutexW(NULL, FALSE, NULL);
500 if (!ps->server_ready_event) ps->server_ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
501 server_thread = CreateThread(NULL, 0, RPCRT4_server_thread, ps, 0, NULL);
504 status = RPC_S_OUT_OF_RESOURCES;
507 ps->is_listening = TRUE;
508 CloseHandle(server_thread);
511 LeaveCriticalSection(&listen_cs);
515 static RPC_STATUS RPCRT4_start_listen(BOOL auto_listen)
517 RPC_STATUS status = RPC_S_ALREADY_LISTENING;
518 RpcServerProtseq *cps;
522 EnterCriticalSection(&listen_cs);
523 if (auto_listen || (manual_listen_count++ == 0))
526 if (++listen_count == 1)
529 LeaveCriticalSection(&listen_cs);
533 EnterCriticalSection(&server_cs);
534 LIST_FOR_EACH_ENTRY(cps, &protseqs, RpcServerProtseq, entry)
536 status = RPCRT4_start_listen_protseq(cps, TRUE);
537 if (status != RPC_S_OK)
540 /* make sure server is actually listening on the interface before
542 RPCRT4_sync_with_server_thread(cps);
544 LeaveCriticalSection(&server_cs);
550 static void RPCRT4_stop_listen(BOOL auto_listen)
552 EnterCriticalSection(&listen_cs);
553 if (auto_listen || (--manual_listen_count == 0))
555 if (listen_count != 0 && --listen_count == 0) {
556 RpcServerProtseq *cps;
559 LeaveCriticalSection(&listen_cs);
561 LIST_FOR_EACH_ENTRY(cps, &protseqs, RpcServerProtseq, entry)
562 RPCRT4_sync_with_server_thread(cps);
566 assert(listen_count >= 0);
568 LeaveCriticalSection(&listen_cs);
571 static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq* ps, LPSTR endpoint)
575 status = ps->ops->open_endpoint(ps, endpoint);
576 if (status != RPC_S_OK)
581 status = RPCRT4_start_listen_protseq(ps, FALSE);
582 if (status == RPC_S_OK)
583 RPCRT4_sync_with_server_thread(ps);
589 /***********************************************************************
590 * RpcServerInqBindings (RPCRT4.@)
592 RPC_STATUS WINAPI RpcServerInqBindings( RPC_BINDING_VECTOR** BindingVector )
596 RpcServerProtseq* ps;
600 TRACE("(*BindingVector == ^%p)\n", *BindingVector);
602 ERR("(BindingVector == NULL!!?)\n");
604 EnterCriticalSection(&server_cs);
605 /* count connections */
607 LIST_FOR_EACH_ENTRY(ps, &protseqs, RpcServerProtseq, entry) {
608 EnterCriticalSection(&ps->cs);
614 LeaveCriticalSection(&ps->cs);
617 /* export bindings */
618 *BindingVector = HeapAlloc(GetProcessHeap(), 0,
619 sizeof(RPC_BINDING_VECTOR) +
620 sizeof(RPC_BINDING_HANDLE)*(count-1));
621 (*BindingVector)->Count = count;
623 LIST_FOR_EACH_ENTRY(ps, &protseqs, RpcServerProtseq, entry) {
624 EnterCriticalSection(&ps->cs);
627 RPCRT4_MakeBinding((RpcBinding**)&(*BindingVector)->BindingH[count],
632 LeaveCriticalSection(&ps->cs);
636 *BindingVector = NULL;
637 status = RPC_S_NO_BINDINGS;
639 LeaveCriticalSection(&server_cs);
643 /***********************************************************************
644 * RpcServerUseProtseqEpA (RPCRT4.@)
646 RPC_STATUS WINAPI RpcServerUseProtseqEpA( RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor )
650 TRACE( "(%s,%u,%s,%p)\n", Protseq, MaxCalls, Endpoint, SecurityDescriptor );
652 /* This should provide the default behaviour */
653 policy.Length = sizeof( policy );
654 policy.EndpointFlags = 0;
657 return RpcServerUseProtseqEpExA( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
660 /***********************************************************************
661 * RpcServerUseProtseqEpW (RPCRT4.@)
663 RPC_STATUS WINAPI RpcServerUseProtseqEpW( RPC_WSTR Protseq, UINT MaxCalls, RPC_WSTR Endpoint, LPVOID SecurityDescriptor )
667 TRACE( "(%s,%u,%s,%p)\n", debugstr_w( Protseq ), MaxCalls, debugstr_w( Endpoint ), SecurityDescriptor );
669 /* This should provide the default behaviour */
670 policy.Length = sizeof( policy );
671 policy.EndpointFlags = 0;
674 return RpcServerUseProtseqEpExW( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
677 /***********************************************************************
678 * alloc_serverprotoseq (internal)
680 * Must be called with server_cs held.
682 static RPC_STATUS alloc_serverprotoseq(UINT MaxCalls, char *Protseq, RpcServerProtseq **ps)
684 const struct protseq_ops *ops = rpcrt4_get_protseq_ops(Protseq);
688 FIXME("protseq %s not supported\n", debugstr_a(Protseq));
689 return RPC_S_PROTSEQ_NOT_SUPPORTED;
694 return RPC_S_OUT_OF_RESOURCES;
695 (*ps)->MaxCalls = MaxCalls;
696 (*ps)->Protseq = Protseq;
700 InitializeCriticalSection(&(*ps)->cs);
701 (*ps)->is_listening = FALSE;
702 (*ps)->mgr_mutex = NULL;
703 (*ps)->server_ready_event = NULL;
705 list_add_head(&protseqs, &(*ps)->entry);
707 TRACE("new protseq %p created for %s\n", *ps, Protseq);
712 /* Finds a given protseq or creates a new one if one doesn't already exist */
713 static RPC_STATUS RPCRT4_get_or_create_serverprotseq(UINT MaxCalls, char *Protseq, RpcServerProtseq **ps)
716 RpcServerProtseq *cps;
718 EnterCriticalSection(&server_cs);
720 LIST_FOR_EACH_ENTRY(cps, &protseqs, RpcServerProtseq, entry)
721 if (!strcmp(cps->Protseq, Protseq))
723 TRACE("found existing protseq object for %s\n", Protseq);
725 LeaveCriticalSection(&server_cs);
729 status = alloc_serverprotoseq(MaxCalls, Protseq, ps);
731 LeaveCriticalSection(&server_cs);
736 /***********************************************************************
737 * RpcServerUseProtseqEpExA (RPCRT4.@)
739 RPC_STATUS WINAPI RpcServerUseProtseqEpExA( RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor,
740 PRPC_POLICY lpPolicy )
742 char *szps = (char*)Protseq, *szep = (char*)Endpoint;
743 RpcServerProtseq* ps;
746 TRACE("(%s,%u,%s,%p,{%u,%lu,%lu})\n", debugstr_a(szps), MaxCalls,
747 debugstr_a(szep), SecurityDescriptor,
748 lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
750 status = RPCRT4_get_or_create_serverprotseq(MaxCalls, RPCRT4_strdupA(szps), &ps);
751 if (status != RPC_S_OK)
754 return RPCRT4_use_protseq(ps, szep);
757 /***********************************************************************
758 * RpcServerUseProtseqEpExW (RPCRT4.@)
760 RPC_STATUS WINAPI RpcServerUseProtseqEpExW( RPC_WSTR Protseq, UINT MaxCalls, RPC_WSTR Endpoint, LPVOID SecurityDescriptor,
761 PRPC_POLICY lpPolicy )
763 RpcServerProtseq* ps;
767 TRACE("(%s,%u,%s,%p,{%u,%lu,%lu})\n", debugstr_w( Protseq ), MaxCalls,
768 debugstr_w( Endpoint ), SecurityDescriptor,
769 lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
771 status = RPCRT4_get_or_create_serverprotseq(MaxCalls, RPCRT4_strdupWtoA(Protseq), &ps);
772 if (status != RPC_S_OK)
775 EndpointA = RPCRT4_strdupWtoA(Endpoint);
776 status = RPCRT4_use_protseq(ps, EndpointA);
777 RPCRT4_strfree(EndpointA);
781 /***********************************************************************
782 * RpcServerUseProtseqA (RPCRT4.@)
784 RPC_STATUS WINAPI RpcServerUseProtseqA(RPC_CSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
786 TRACE("(Protseq == %s, MaxCalls == %d, SecurityDescriptor == ^%p)\n", debugstr_a((char*)Protseq), MaxCalls, SecurityDescriptor);
787 return RpcServerUseProtseqEpA(Protseq, MaxCalls, NULL, SecurityDescriptor);
790 /***********************************************************************
791 * RpcServerUseProtseqW (RPCRT4.@)
793 RPC_STATUS WINAPI RpcServerUseProtseqW(RPC_WSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
795 TRACE("Protseq == %s, MaxCalls == %d, SecurityDescriptor == ^%p)\n", debugstr_w(Protseq), MaxCalls, SecurityDescriptor);
796 return RpcServerUseProtseqEpW(Protseq, MaxCalls, NULL, SecurityDescriptor);
799 /***********************************************************************
800 * RpcServerRegisterIf (RPCRT4.@)
802 RPC_STATUS WINAPI RpcServerRegisterIf( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv )
804 TRACE("(%p,%s,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv);
805 return RpcServerRegisterIf2( IfSpec, MgrTypeUuid, MgrEpv, 0, RPC_C_LISTEN_MAX_CALLS_DEFAULT, (UINT)-1, NULL );
808 /***********************************************************************
809 * RpcServerRegisterIfEx (RPCRT4.@)
811 RPC_STATUS WINAPI RpcServerRegisterIfEx( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
812 UINT Flags, UINT MaxCalls, RPC_IF_CALLBACK_FN* IfCallbackFn )
814 TRACE("(%p,%s,%p,%u,%u,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv, Flags, MaxCalls, IfCallbackFn);
815 return RpcServerRegisterIf2( IfSpec, MgrTypeUuid, MgrEpv, Flags, MaxCalls, (UINT)-1, IfCallbackFn );
818 /***********************************************************************
819 * RpcServerRegisterIf2 (RPCRT4.@)
821 RPC_STATUS WINAPI RpcServerRegisterIf2( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
822 UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN* IfCallbackFn )
824 PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
825 RpcServerInterface* sif;
828 TRACE("(%p,%s,%p,%u,%u,%u,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv, Flags, MaxCalls,
829 MaxRpcSize, IfCallbackFn);
830 TRACE(" interface id: %s %d.%d\n", debugstr_guid(&If->InterfaceId.SyntaxGUID),
831 If->InterfaceId.SyntaxVersion.MajorVersion,
832 If->InterfaceId.SyntaxVersion.MinorVersion);
833 TRACE(" transfer syntax: %s %d.%d\n", debugstr_guid(&If->TransferSyntax.SyntaxGUID),
834 If->TransferSyntax.SyntaxVersion.MajorVersion,
835 If->TransferSyntax.SyntaxVersion.MinorVersion);
836 TRACE(" dispatch table: %p\n", If->DispatchTable);
837 if (If->DispatchTable) {
838 TRACE(" dispatch table count: %d\n", If->DispatchTable->DispatchTableCount);
839 for (i=0; i<If->DispatchTable->DispatchTableCount; i++) {
840 TRACE(" entry %d: %p\n", i, If->DispatchTable->DispatchTable[i]);
842 TRACE(" reserved: %ld\n", If->DispatchTable->Reserved);
844 TRACE(" protseq endpoint count: %d\n", If->RpcProtseqEndpointCount);
845 TRACE(" default manager epv: %p\n", If->DefaultManagerEpv);
846 TRACE(" interpreter info: %p\n", If->InterpreterInfo);
848 sif = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcServerInterface));
851 sif->MgrTypeUuid = *MgrTypeUuid;
852 sif->MgrEpv = MgrEpv;
854 memset(&sif->MgrTypeUuid, 0, sizeof(UUID));
855 sif->MgrEpv = If->DefaultManagerEpv;
858 sif->MaxCalls = MaxCalls;
859 sif->MaxRpcSize = MaxRpcSize;
860 sif->IfCallbackFn = IfCallbackFn;
862 EnterCriticalSection(&server_cs);
863 list_add_head(&server_interfaces, &sif->entry);
864 LeaveCriticalSection(&server_cs);
866 if (sif->Flags & RPC_IF_AUTOLISTEN)
867 RPCRT4_start_listen(TRUE);
872 /***********************************************************************
873 * RpcServerUnregisterIf (RPCRT4.@)
875 RPC_STATUS WINAPI RpcServerUnregisterIf( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, UINT WaitForCallsToComplete )
877 PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
880 BOOL completed = TRUE;
881 RpcServerInterface *cif;
884 TRACE("(IfSpec == (RPC_IF_HANDLE)^%p (%s), MgrTypeUuid == %s, WaitForCallsToComplete == %u)\n",
885 IfSpec, debugstr_guid(&If->InterfaceId.SyntaxGUID), debugstr_guid(MgrTypeUuid), WaitForCallsToComplete);
887 EnterCriticalSection(&server_cs);
888 LIST_FOR_EACH_ENTRY(cif, &server_interfaces, RpcServerInterface, entry) {
889 if ((!IfSpec || !memcmp(&If->InterfaceId, &cif->If->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER))) &&
890 UuidEqual(MgrTypeUuid, &cif->MgrTypeUuid, &status)) {
891 list_remove(&cif->entry);
892 TRACE("unregistering cif %p\n", cif);
893 if (cif->CurrentCalls) {
896 if (WaitForCallsToComplete)
897 cif->CallsCompletedEvent = event = CreateEventW(NULL, FALSE, FALSE, NULL);
903 LeaveCriticalSection(&server_cs);
906 ERR("not found for object %s\n", debugstr_guid(MgrTypeUuid));
907 return RPC_S_UNKNOWN_IF;
911 HeapFree(GetProcessHeap(), 0, cif);
913 /* sif will be freed when the last call is completed, so be careful not to
914 * touch that memory here as that could happen before we get here */
915 WaitForSingleObject(event, INFINITE);
922 /***********************************************************************
923 * RpcServerUnregisterIfEx (RPCRT4.@)
925 RPC_STATUS WINAPI RpcServerUnregisterIfEx( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, int RundownContextHandles )
927 FIXME("(IfSpec == (RPC_IF_HANDLE)^%p, MgrTypeUuid == %s, RundownContextHandles == %d): stub\n",
928 IfSpec, debugstr_guid(MgrTypeUuid), RundownContextHandles);
933 /***********************************************************************
934 * RpcObjectSetType (RPCRT4.@)
937 * ObjUuid [I] "Object" UUID
938 * TypeUuid [I] "Type" UUID
941 * RPC_S_OK The call succeeded
942 * RPC_S_INVALID_OBJECT The provided object (nil) is not valid
943 * RPC_S_ALREADY_REGISTERED The provided object is already registered
945 * Maps "Object" UUIDs to "Type" UUID's. Passing the nil UUID as the type
946 * resets the mapping for the specified object UUID to nil (the default).
947 * The nil object is always associated with the nil type and cannot be
948 * reassigned. Servers can support multiple implementations on the same
949 * interface by registering different end-point vectors for the different
950 * types. There's no need to call this if a server only supports the nil
951 * type, as is typical.
953 RPC_STATUS WINAPI RpcObjectSetType( UUID* ObjUuid, UUID* TypeUuid )
955 RpcObjTypeMap *map = RpcObjTypeMaps, *prev = NULL;
958 TRACE("(ObjUUID == %s, TypeUuid == %s).\n", debugstr_guid(ObjUuid), debugstr_guid(TypeUuid));
959 if ((! ObjUuid) || UuidIsNil(ObjUuid, &dummy)) {
960 /* nil uuid cannot be remapped */
961 return RPC_S_INVALID_OBJECT;
964 /* find the mapping for this object if there is one ... */
966 if (! UuidCompare(ObjUuid, &map->Object, &dummy)) break;
970 if ((! TypeUuid) || UuidIsNil(TypeUuid, &dummy)) {
971 /* ... and drop it from the list */
974 prev->next = map->next;
976 RpcObjTypeMaps = map->next;
977 HeapFree(GetProcessHeap(), 0, map);
980 /* ... , fail if we found it ... */
982 return RPC_S_ALREADY_REGISTERED;
983 /* ... otherwise create a new one and add it in. */
984 map = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcObjTypeMap));
985 map->Object = *ObjUuid;
986 map->Type = *TypeUuid;
989 prev->next = map; /* prev is the last map in the linklist */
991 RpcObjTypeMaps = map;
997 /***********************************************************************
998 * RpcServerRegisterAuthInfoA (RPCRT4.@)
1000 RPC_STATUS WINAPI RpcServerRegisterAuthInfoA( RPC_CSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
1003 FIXME( "(%s,%u,%p,%p): stub\n", ServerPrincName, AuthnSvc, GetKeyFn, Arg );
1005 return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
1008 /***********************************************************************
1009 * RpcServerRegisterAuthInfoW (RPCRT4.@)
1011 RPC_STATUS WINAPI RpcServerRegisterAuthInfoW( RPC_WSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
1014 FIXME( "(%s,%u,%p,%p): stub\n", debugstr_w( ServerPrincName ), AuthnSvc, GetKeyFn, Arg );
1016 return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
1019 /***********************************************************************
1020 * RpcServerListen (RPCRT4.@)
1022 RPC_STATUS WINAPI RpcServerListen( UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait )
1024 RPC_STATUS status = RPC_S_OK;
1026 TRACE("(%u,%u,%u)\n", MinimumCallThreads, MaxCalls, DontWait);
1028 if (list_empty(&protseqs))
1029 return RPC_S_NO_PROTSEQS_REGISTERED;
1031 status = RPCRT4_start_listen(FALSE);
1033 if (DontWait || (status != RPC_S_OK)) return status;
1035 return RpcMgmtWaitServerListen();
1038 /***********************************************************************
1039 * RpcMgmtServerWaitListen (RPCRT4.@)
1041 RPC_STATUS WINAPI RpcMgmtWaitServerListen( void )
1045 EnterCriticalSection(&listen_cs);
1048 LeaveCriticalSection(&listen_cs);
1049 return RPC_S_NOT_LISTENING;
1052 LeaveCriticalSection(&listen_cs);
1054 FIXME("not waiting for server calls to finish\n");
1059 /***********************************************************************
1060 * RpcMgmtStopServerListening (RPCRT4.@)
1062 RPC_STATUS WINAPI RpcMgmtStopServerListening ( RPC_BINDING_HANDLE Binding )
1064 TRACE("(Binding == (RPC_BINDING_HANDLE)^%p)\n", Binding);
1067 FIXME("client-side invocation not implemented.\n");
1068 return RPC_S_WRONG_KIND_OF_BINDING;
1071 RPCRT4_stop_listen(FALSE);
1076 /***********************************************************************
1077 * RpcMgmtEnableIdleCleanup (RPCRT4.@)
1079 RPC_STATUS WINAPI RpcMgmtEnableIdleCleanup(void)
1081 FIXME("(): stub\n");
1085 /***********************************************************************
1086 * I_RpcServerStartListening (RPCRT4.@)
1088 RPC_STATUS WINAPI I_RpcServerStartListening( HWND hWnd )
1090 FIXME( "(%p): stub\n", hWnd );
1095 /***********************************************************************
1096 * I_RpcServerStopListening (RPCRT4.@)
1098 RPC_STATUS WINAPI I_RpcServerStopListening( void )
1100 FIXME( "(): stub\n" );
1105 /***********************************************************************
1106 * I_RpcWindowProc (RPCRT4.@)
1108 UINT WINAPI I_RpcWindowProc( void *hWnd, UINT Message, UINT wParam, ULONG lParam )
1110 FIXME( "(%p,%08x,%08x,%08x): stub\n", hWnd, Message, wParam, lParam );
1115 /***********************************************************************
1116 * RpcMgmtInqIfIds (RPCRT4.@)
1118 RPC_STATUS WINAPI RpcMgmtInqIfIds(RPC_BINDING_HANDLE Binding, RPC_IF_ID_VECTOR **IfIdVector)
1120 FIXME("(%p,%p): stub\n", Binding, IfIdVector);
1121 return RPC_S_INVALID_BINDING;
1124 /***********************************************************************
1125 * RpcMgmtEpEltInqBegin (RPCRT4.@)
1127 RPC_STATUS WINAPI RpcMgmtEpEltInqBegin(RPC_BINDING_HANDLE Binding, ULONG InquiryType,
1128 RPC_IF_ID *IfId, ULONG VersOption, UUID *ObjectUuid, RPC_EP_INQ_HANDLE* InquiryContext)
1130 FIXME("(%p,%u,%p,%u,%p,%p): stub\n",
1131 Binding, InquiryType, IfId, VersOption, ObjectUuid, InquiryContext);
1132 return RPC_S_INVALID_BINDING;
1135 /***********************************************************************
1136 * RpcMgmtIsServerListening (RPCRT4.@)
1138 RPC_STATUS WINAPI RpcMgmtIsServerListening(RPC_BINDING_HANDLE Binding)
1140 FIXME("(%p): stub\n", Binding);
1141 return RPC_S_INVALID_BINDING;
1144 /***********************************************************************
1145 * RpcMgmtSetServerStackSize (RPCRT4.@)
1147 RPC_STATUS WINAPI RpcMgmtSetServerStackSize(ULONG ThreadStackSize)
1149 FIXME("(0x%x): stub\n", ThreadStackSize);
1153 /***********************************************************************
1154 * I_RpcGetCurrentCallHandle (RPCRT4.@)
1156 RPC_BINDING_HANDLE WINAPI I_RpcGetCurrentCallHandle(void)
1159 return RPCRT4_GetThreadCurrentCallHandle();