ReactOS  0.4.14-dev-593-g1793dcc
rpc_server.c File Reference
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "rpc.h"
#include "rpcndr.h"
#include "excpt.h"
#include "wine/debug.h"
#include "wine/exception.h"
#include "rpc_server.h"
#include "rpc_assoc.h"
#include "rpc_message.h"
#include "rpc_defs.h"
#include "ncastatus.h"
#include "secext.h"
Include dependency graph for rpc_server.c:

Go to the source code of this file.

Classes

struct  _RpcPacket
 
struct  _RpcObjTypeMap
 
struct  rpc_server_registered_auth_info
 

Typedefs

typedef struct _RpcPacket RpcPacket
 
typedef struct _RpcObjTypeMap RpcObjTypeMap
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (rpc)
 
static RpcObjTypeMapLookupObjTypeMap (UUID *ObjUuid)
 
static UUIDLookupObjType (UUID *ObjUuid)
 
static RpcServerInterfaceRPCRT4_find_interface (UUID *object, const RPC_SYNTAX_IDENTIFIER *if_id, const RPC_SYNTAX_IDENTIFIER *transfer_syntax, BOOL check_object)
 
static void RPCRT4_release_server_interface (RpcServerInterface *sif)
 
static RpcPktHdrhandle_bind_error (RpcConnection *conn, RPC_STATUS error)
 
static RPC_STATUS process_bind_packet_no_send (RpcConnection *conn, RpcPktBindHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length, RpcPktHdr **ack_response, unsigned char **auth_data_out, ULONG *auth_length_out)
 
static RPC_STATUS process_bind_packet (RpcConnection *conn, RpcPktBindHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length)
 
static RPC_STATUS process_request_packet (RpcConnection *conn, RpcPktRequestHdr *hdr, RPC_MESSAGE *msg)
 
static RPC_STATUS process_auth3_packet (RpcConnection *conn, RpcPktCommonHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length)
 
static void RPCRT4_process_packet (RpcConnection *conn, RpcPktHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length)
 
static DWORD CALLBACK RPCRT4_worker_thread (LPVOID the_arg)
 
static DWORD CALLBACK RPCRT4_io_thread (LPVOID the_arg)
 
void RPCRT4_new_client (RpcConnection *conn)
 
static DWORD CALLBACK RPCRT4_server_thread (LPVOID the_arg)
 
static void RPCRT4_sync_with_server_thread (RpcServerProtseq *ps)
 
static RPC_STATUS RPCRT4_start_listen_protseq (RpcServerProtseq *ps, BOOL auto_listen)
 
static RPC_STATUS RPCRT4_start_listen (BOOL auto_listen)
 
static RPC_STATUS RPCRT4_stop_listen (BOOL auto_listen)
 
static BOOL RPCRT4_protseq_is_endpoint_registered (RpcServerProtseq *protseq, const char *endpoint)
 
static RPC_STATUS RPCRT4_use_protseq (RpcServerProtseq *ps, const char *endpoint)
 
RPC_STATUS WINAPI RpcServerInqBindings (RPC_BINDING_VECTOR **BindingVector)
 
RPC_STATUS WINAPI RpcServerUseProtseqEpA (RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor)
 
RPC_STATUS WINAPI RpcServerUseProtseqEpW (RPC_WSTR Protseq, UINT MaxCalls, RPC_WSTR Endpoint, LPVOID SecurityDescriptor)
 
static RPC_STATUS alloc_serverprotoseq (UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
 
static void destroy_serverprotoseq (RpcServerProtseq *ps)
 
static RPC_STATUS RPCRT4_get_or_create_serverprotseq (UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
 
RPC_STATUS WINAPI RpcServerUseProtseqEpExA (RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor, PRPC_POLICY lpPolicy)
 
RPC_STATUS WINAPI RpcServerUseProtseqEpExW (RPC_WSTR Protseq, UINT MaxCalls, RPC_WSTR Endpoint, LPVOID SecurityDescriptor, PRPC_POLICY lpPolicy)
 
RPC_STATUS WINAPI RpcServerUseProtseqA (RPC_CSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
 
RPC_STATUS WINAPI RpcServerUseProtseqW (RPC_WSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
 
void RPCRT4_destroy_all_protseqs (void)
 
RPC_STATUS WINAPI RpcServerRegisterIf (RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv)
 
RPC_STATUS WINAPI RpcServerRegisterIfEx (RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv, UINT Flags, UINT MaxCalls, RPC_IF_CALLBACK_FN *IfCallbackFn)
 
RPC_STATUS WINAPI RpcServerRegisterIf2 (RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv, UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN *IfCallbackFn)
 
RPC_STATUS WINAPI RpcServerRegisterIf3 (RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv, UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN *IfCallbackFn, void *SecurityDescriptor)
 
RPC_STATUS WINAPI RpcServerUnregisterIf (RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, UINT WaitForCallsToComplete)
 
RPC_STATUS WINAPI RpcServerUnregisterIfEx (RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, int RundownContextHandles)
 
RPC_STATUS WINAPI RpcObjectSetType (UUID *ObjUuid, UUID *TypeUuid)
 
static RPC_STATUS find_security_package (ULONG auth_type, SecPkgInfoW **packages_buf, SecPkgInfoW **ret)
 
RPC_STATUS RPCRT4_ServerGetRegisteredAuthInfo (USHORT auth_type, CredHandle *cred, TimeStamp *exp, ULONG *max_token)
 
void RPCRT4_ServerFreeAllRegisteredAuthInfo (void)
 
RPC_STATUS WINAPI RpcServerRegisterAuthInfoA (RPC_CSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, LPVOID Arg)
 
RPC_STATUS WINAPI RpcServerRegisterAuthInfoW (RPC_WSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, LPVOID Arg)
 
RPC_STATUS RPC_ENTRY RpcServerInqDefaultPrincNameA (ULONG AuthnSvc, RPC_CSTR *PrincName)
 
RPC_STATUS RPC_ENTRY RpcServerInqDefaultPrincNameW (ULONG AuthnSvc, RPC_WSTR *PrincName)
 
RPC_STATUS WINAPI RpcServerListen (UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait)
 
RPC_STATUS WINAPI RpcMgmtWaitServerListen (void)
 
RPC_STATUS WINAPI RpcMgmtStopServerListening (RPC_BINDING_HANDLE Binding)
 
RPC_STATUS WINAPI RpcMgmtEnableIdleCleanup (void)
 
RPC_STATUS WINAPI I_RpcServerStartListening (HWND hWnd)
 
RPC_STATUS WINAPI I_RpcServerStopListening (void)
 
UINT WINAPI I_RpcWindowProc (void *hWnd, UINT Message, UINT wParam, ULONG lParam)
 
RPC_STATUS WINAPI RpcMgmtInqIfIds (RPC_BINDING_HANDLE Binding, RPC_IF_ID_VECTOR **IfIdVector)
 
RPC_STATUS WINAPI RpcMgmtInqStats (RPC_BINDING_HANDLE Binding, RPC_STATS_VECTOR **Statistics)
 
RPC_STATUS WINAPI RpcMgmtStatsVectorFree (RPC_STATS_VECTOR **StatsVector)
 
RPC_STATUS WINAPI RpcMgmtEpEltInqBegin (RPC_BINDING_HANDLE Binding, ULONG InquiryType, RPC_IF_ID *IfId, ULONG VersOption, UUID *ObjectUuid, RPC_EP_INQ_HANDLE *InquiryContext)
 
RPC_STATUS WINAPI RpcMgmtIsServerListening (RPC_BINDING_HANDLE Binding)
 
RPC_STATUS WINAPI RpcMgmtSetAuthorizationFn (RPC_MGMT_AUTHORIZATION_FN fn)
 
RPC_STATUS WINAPI RpcMgmtSetServerStackSize (ULONG ThreadStackSize)
 
RPC_BINDING_HANDLE WINAPI I_RpcGetCurrentCallHandle (void)
 

Variables

static RpcObjTypeMapRpcObjTypeMaps
 
static struct list protseqs = LIST_INIT(protseqs)
 
static struct list server_interfaces = LIST_INIT(server_interfaces)
 
static struct list server_registered_auth_info = LIST_INIT(server_registered_auth_info)
 
static CRITICAL_SECTION server_cs = { &server_cs_debug, -1, 0, 0, 0, 0 }
 
static CRITICAL_SECTION_DEBUG server_cs_debug
 
static CRITICAL_SECTION listen_cs = { &listen_cs_debug, -1, 0, 0, 0, 0 }
 
static CRITICAL_SECTION_DEBUG listen_cs_debug
 
static CRITICAL_SECTION server_auth_info_cs = { &server_auth_info_cs_debug, -1, 0, 0, 0, 0 }
 
static CRITICAL_SECTION_DEBUG server_auth_info_cs_debug
 
static BOOL std_listen
 
static LONG listen_count
 
static HANDLE listen_done_event
 
static UUID uuid_nil
 

Typedef Documentation

◆ RpcObjTypeMap

◆ RpcPacket

Function Documentation

◆ alloc_serverprotoseq()

static RPC_STATUS alloc_serverprotoseq ( UINT  MaxCalls,
const char Protseq,
RpcServerProtseq **  ps 
)
static

Definition at line 946 of file rpc_server.c.

947 {
948  const struct protseq_ops *ops = rpcrt4_get_protseq_ops(Protseq);
949 
950  if (!ops)
951  {
952  FIXME("protseq %s not supported\n", debugstr_a(Protseq));
954  }
955 
956  *ps = ops->alloc();
957  if (!*ps)
958  return RPC_S_OUT_OF_RESOURCES;
959  (*ps)->MaxCalls = MaxCalls;
960  (*ps)->Protseq = RPCRT4_strdupA(Protseq);
961  (*ps)->ops = ops;
962  list_init(&(*ps)->listeners);
963  list_init(&(*ps)->connections);
964  InitializeCriticalSection(&(*ps)->cs);
965  (*ps)->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RpcServerProtseq.cs");
966 
967  list_add_head(&protseqs, &(*ps)->entry);
968 
969  TRACE("new protseq %p created for %s\n", *ps, Protseq);
970 
971  return RPC_S_OK;
972 }
static struct list protseqs
Definition: rpc_server.c:68
RpcServerProtseq *(* alloc)(void)
Definition: rpc_server.h:51
#define DWORD_PTR
Definition: treelist.c:76
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
Definition: list.h:96
const struct protseq_ops * rpcrt4_get_protseq_ops(const char *protseq) DECLSPEC_HIDDEN
#define FIXME(fmt,...)
Definition: debug.h:110
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define RPC_S_PROTSEQ_NOT_SUPPORTED
Definition: winerror.h:1014
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define RPCRT4_strdupA(x)
Definition: rpc_binding.h:151
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
#define RPC_S_OK
Definition: rpcnterr.h:22

Referenced by RPCRT4_get_or_create_serverprotseq().

◆ destroy_serverprotoseq()

static void destroy_serverprotoseq ( RpcServerProtseq ps)
static

Definition at line 975 of file rpc_server.c.

976 {
977  RPCRT4_strfree(ps->Protseq);
978  ps->cs.DebugInfo->Spare[0] = 0;
980  CloseHandle(ps->mgr_mutex);
982  list_remove(&ps->entry);
983  HeapFree(GetProcessHeap(), 0, ps);
984 }
HANDLE server_ready_event
Definition: rpc_server.h:45
#define CloseHandle
Definition: compat.h:406
struct list entry
Definition: rpc_server.h:32
void RPCRT4_strfree(LPSTR src)
Definition: rpc_binding.c:104
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
CRITICAL_SECTION cs
Definition: rpc_server.h:38
#define GetProcessHeap()
Definition: compat.h:403
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:866
#define HeapFree(x, y, z)
Definition: compat.h:402
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:859

Referenced by RPCRT4_destroy_all_protseqs().

◆ find_security_package()

static RPC_STATUS find_security_package ( ULONG  auth_type,
SecPkgInfoW **  packages_buf,
SecPkgInfoW **  ret 
)
static

Definition at line 1334 of file rpc_server.c.

1335 {
1336  SECURITY_STATUS sec_status;
1337  SecPkgInfoW *packages;
1338  ULONG package_count;
1339  ULONG i;
1340 
1341  sec_status = EnumerateSecurityPackagesW(&package_count, &packages);
1342  if (sec_status != SEC_E_OK)
1343  {
1344  ERR("EnumerateSecurityPackagesW failed with error 0x%08x\n", sec_status);
1345  return RPC_S_SEC_PKG_ERROR;
1346  }
1347 
1348  for (i = 0; i < package_count; i++)
1349  if (packages[i].wRPCID == auth_type)
1350  break;
1351 
1352  if (i == package_count)
1353  {
1354  WARN("unsupported AuthnSvc %u\n", auth_type);
1355  FreeContextBuffer(packages);
1357  }
1358 
1359  TRACE("found package %s for service %u\n", debugstr_w(packages[i].Name), auth_type);
1360  *packages_buf = packages;
1361  *ret = packages + i;
1362  return RPC_S_OK;
1363 }
SECURITY_STATUS WINAPI FreeContextBuffer(PVOID pv)
Definition: sspi.c:699
#define WARN(fmt,...)
Definition: debug.h:111
SECURITY_STATUS WINAPI EnumerateSecurityPackagesW(PULONG pcPackages, PSecPkgInfoW *ppPackageInfo)
Definition: sspi.c:709
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define debugstr_w
Definition: kernel32.h:32
#define RPC_S_SEC_PKG_ERROR
Definition: winerror.h:1132
LONG SECURITY_STATUS
Definition: sspi.h:34
#define TRACE(s)
Definition: solgame.cpp:4
int ret
#define RPC_S_UNKNOWN_AUTHN_SERVICE
Definition: winerror.h:1055
#define SEC_E_OK
Definition: winerror.h:2356
#define ERR(fmt,...)
Definition: debug.h:109
unsigned int ULONG
Definition: retypes.h:1
#define RPC_S_OK
Definition: rpcnterr.h:22

Referenced by RpcServerRegisterAuthInfoW().

◆ handle_bind_error()

static RpcPktHdr* handle_bind_error ( RpcConnection conn,
RPC_STATUS  error 
)
static

Definition at line 171 of file rpc_server.c.

172 {
173  unsigned int reject_reason;
174  switch (error)
175  {
177  reject_reason = REJECT_TEMPORARY_CONGESTION;
178  break;
179  case ERROR_OUTOFMEMORY:
181  reject_reason = REJECT_LOCAL_LIMIT_EXCEEDED;
182  break;
185  break;
187  reject_reason = REJECT_UNKNOWN_AUTHN_SERVICE;
188  break;
189  case ERROR_ACCESS_DENIED:
190  reject_reason = REJECT_INVALID_CHECKSUM;
191  break;
192  default:
193  FIXME("unexpected status value %d\n", error);
194  /* fall through */
195  case RPC_S_INVALID_BOUND:
196  reject_reason = REJECT_REASON_NOT_SPECIFIED;
197  break;
198  }
201  reject_reason);
202 }
RpcPktHdr * RPCRT4_BuildBindNackHeader(ULONG DataRepresentation, unsigned char RpcVersion, unsigned char RpcVersionMinor, unsigned short RejectReason)
Definition: rpc_message.c:231
#define RPC_S_INVALID_BOUND
Definition: winerror.h:1043
#define error(str)
Definition: mkdosfs.c:1605
#define REJECT_LOCAL_LIMIT_EXCEEDED
Definition: rpc_defs.h:222
#define REJECT_UNKNOWN_AUTHN_SERVICE
Definition: rpc_defs.h:228
#define REJECT_TEMPORARY_CONGESTION
Definition: rpc_defs.h:221
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
#define REJECT_REASON_NOT_SPECIFIED
Definition: rpc_defs.h:220
#define FIXME(fmt,...)
Definition: debug.h:110
#define RPC_VER_MAJOR
Definition: rpc_defs.h:176
#define RPC_S_PROTOCOL_ERROR
Definition: winerror.h:1039
#define REJECT_INVALID_CHECKSUM
Definition: rpc_defs.h:229
#define RPC_S_UNKNOWN_AUTHN_SERVICE
Definition: winerror.h:1055
#define RPC_S_SERVER_TOO_BUSY
Definition: winerror.h:1034
#define NDR_LOCAL_DATA_REPRESENTATION
Definition: rpcndr.h:107
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
#define REJECT_PROTOCOL_VERSION_NOT_SUPPORTED
Definition: rpc_defs.h:224
#define RPC_VER_MINOR
Definition: rpc_defs.h:177
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13

Referenced by process_bind_packet().

◆ I_RpcGetCurrentCallHandle()

RPC_BINDING_HANDLE WINAPI I_RpcGetCurrentCallHandle ( void  )

Definition at line 1743 of file rpc_server.c.

1744 {
1745  TRACE("\n");
1747 }
#define TRACE(s)
Definition: solgame.cpp:4
RpcBinding * RPCRT4_GetThreadCurrentCallHandle(void) DECLSPEC_HIDDEN
Definition: rpcrt4_main.c:970

Referenced by client_get_handle(), NDRSContextMarshall(), NDRSContextUnmarshall(), RpcBindingInqAuthClientExW(), RpcBindingServerFromClient(), RpcImpersonateClient(), RpcRevertToSelfEx(), s_authinfo_test(), and s_context_handle_test().

◆ I_RpcServerStartListening()

RPC_STATUS WINAPI I_RpcServerStartListening ( HWND  hWnd)

Definition at line 1620 of file rpc_server.c.

1621 {
1622  FIXME( "(%p): stub\n", hWnd );
1623 
1624  return RPC_S_OK;
1625 }
HWND hWnd
Definition: settings.c:17
#define FIXME(fmt,...)
Definition: debug.h:110
#define RPC_S_OK
Definition: rpcnterr.h:22

◆ I_RpcServerStopListening()

RPC_STATUS WINAPI I_RpcServerStopListening ( void  )

Definition at line 1630 of file rpc_server.c.

1631 {
1632  FIXME( "(): stub\n" );
1633 
1634  return RPC_S_OK;
1635 }
#define FIXME(fmt,...)
Definition: debug.h:110
#define RPC_S_OK
Definition: rpcnterr.h:22

◆ I_RpcWindowProc()

UINT WINAPI I_RpcWindowProc ( void hWnd,
UINT  Message,
UINT  wParam,
ULONG  lParam 
)

Definition at line 1640 of file rpc_server.c.

1641 {
1642  FIXME( "(%p,%08x,%08x,%08x): stub\n", hWnd, Message, wParam, lParam );
1643 
1644  return 0;
1645 }
HWND hWnd
Definition: settings.c:17
WPARAM wParam
Definition: combotst.c:138
#define FIXME(fmt,...)
Definition: debug.h:110
CHAR Message[80]
Definition: alive.c:5
LPARAM lParam
Definition: combotst.c:139

◆ LookupObjType()

static UUID* LookupObjType ( UUID ObjUuid)
inlinestatic

Definition at line 121 of file rpc_server.c.

122 {
123  RpcObjTypeMap *map = LookupObjTypeMap(ObjUuid);
124  if (map)
125  return &map->Type;
126  else
127  return &uuid_nil;
128 }
Definition: _map.h:44
static RpcObjTypeMap * LookupObjTypeMap(UUID *ObjUuid)
Definition: rpc_server.c:108
static UUID uuid_nil
Definition: rpc_server.c:106

Referenced by RPCRT4_find_interface().

◆ LookupObjTypeMap()

static RpcObjTypeMap* LookupObjTypeMap ( UUID ObjUuid)
inlinestatic

Definition at line 108 of file rpc_server.c.

109 {
112 
113  while (rslt) {
114  if (! UuidCompare(ObjUuid, &rslt->Object, &dummy)) break;
115  rslt = rslt->next;
116  }
117 
118  return rslt;
119 }
int WINAPI UuidCompare(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
Definition: rpcrt4_main.c:207
long RPC_STATUS
Definition: rpc.h:52
struct _RpcObjTypeMap * next
Definition: rpc_server.c:60
unsigned char dummy
Definition: maze.c:118
static RpcObjTypeMap * RpcObjTypeMaps
Definition: rpc_server.c:65

Referenced by LookupObjType().

◆ process_auth3_packet()

static RPC_STATUS process_auth3_packet ( RpcConnection conn,
RpcPktCommonHdr hdr,
RPC_MESSAGE msg,
unsigned char auth_data,
ULONG  auth_length 
)
static

Definition at line 475 of file rpc_server.c.

480 {
482 
483  if (UuidIsNil(&conn->ActiveInterface.SyntaxGUID, &status) ||
484  !auth_length || msg->BufferLength != 0)
486  else
487  {
489  (RpcAuthVerifier *)auth_data,
490  auth_length, NULL, NULL);
491  }
492 
493  /* FIXME: client doesn't expect a response to this message so must store
494  * status in connection so that fault packet can be returned when next
495  * packet is received */
496 
497  return RPC_S_OK;
498 }
int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
Definition: rpcrt4_main.c:266
long RPC_STATUS
Definition: rpc.h:52
smooth NULL
Definition: ftsmooth.c:416
#define RPC_S_PROTOCOL_ERROR
Definition: winerror.h:1039
RPC_STATUS RPCRT4_ServerConnectionAuth(RpcConnection *conn, BOOL start, RpcAuthVerifier *auth_data_in, ULONG auth_length_in, unsigned char **auth_data_out, ULONG *auth_length_out)
Definition: rpc_message.c:1025
#define msg(x)
Definition: auth_time.c:54
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
RPC_SYNTAX_IDENTIFIER ActiveInterface
Definition: rpc_binding.h:92
Definition: ps.c:97

Referenced by RPCRT4_io_thread(), and RPCRT4_process_packet().

◆ process_bind_packet()

static RPC_STATUS process_bind_packet ( RpcConnection conn,
RpcPktBindHdr hdr,
RPC_MESSAGE msg,
unsigned char auth_data,
ULONG  auth_length 
)
static

Definition at line 337 of file rpc_server.c.

341 {
343  RpcPktHdr *response = NULL;
344  unsigned char *auth_data_out = NULL;
345  ULONG auth_length_out = 0;
346 
347  status = process_bind_packet_no_send(conn, hdr, msg, auth_data, auth_length,
348  &response, &auth_data_out,
349  &auth_length_out);
350  if (status != RPC_S_OK)
351  response = handle_bind_error(conn, status);
352  if (response)
353  status = RPCRT4_SendWithAuth(conn, response, NULL, 0, auth_data_out, auth_length_out);
354  else
356  RPCRT4_FreeHeader(response);
357 
358  return status;
359 }
char hdr[14]
Definition: iptest.cpp:33
VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
Definition: rpc_message.c:403
long RPC_STATUS
Definition: rpc.h:52
smooth NULL
Definition: ftsmooth.c:416
static RpcPktHdr * handle_bind_error(RpcConnection *conn, RPC_STATUS error)
Definition: rpc_server.c:171
RPC_STATUS RPCRT4_SendWithAuth(RpcConnection *Connection, RpcPktHdr *Header, void *Buffer, unsigned int BufferLength, const void *Auth, unsigned int AuthLength)
Definition: rpc_message.c:761
#define msg(x)
Definition: auth_time.c:54
unsigned int ULONG
Definition: retypes.h:1
static RPC_STATUS process_bind_packet_no_send(RpcConnection *conn, RpcPktBindHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length, RpcPktHdr **ack_response, unsigned char **auth_data_out, ULONG *auth_length_out)
Definition: rpc_server.c:204
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
Definition: ps.c:97

Referenced by RPCRT4_io_thread(), and RPCRT4_process_packet().

◆ process_bind_packet_no_send()

static RPC_STATUS process_bind_packet_no_send ( RpcConnection conn,
RpcPktBindHdr hdr,
RPC_MESSAGE msg,
unsigned char auth_data,
ULONG  auth_length,
RpcPktHdr **  ack_response,
unsigned char **  auth_data_out,
ULONG auth_length_out 
)
static

Definition at line 204 of file rpc_server.c.

208 {
210  RpcContextElement *ctxt_elem;
211  unsigned int i;
213 
214  /* validate data */
215  for (i = 0, ctxt_elem = msg->Buffer;
216  i < hdr->num_elements;
217  i++, ctxt_elem = (RpcContextElement *)&ctxt_elem->transfer_syntaxes[ctxt_elem->num_syntaxes])
218  {
219  if (((char *)ctxt_elem - (char *)msg->Buffer) > msg->BufferLength ||
220  ((char *)&ctxt_elem->transfer_syntaxes[ctxt_elem->num_syntaxes] - (char *)msg->Buffer) > msg->BufferLength)
221  {
222  ERR("inconsistent data in packet - packet length %d, num elements %d\n",
223  msg->BufferLength, hdr->num_elements);
224  return RPC_S_INVALID_BOUND;
225  }
226  }
227 
228  if (hdr->max_tsize < RPC_MIN_PACKET_SIZE ||
230  conn->server_binding)
231  {
232  TRACE("packet size less than min size, or active interface syntax guid non-null\n");
233 
234  return RPC_S_INVALID_BOUND;
235  }
236 
238  hdr->num_elements * sizeof(*results));
239  if (!results)
240  return RPC_S_OUT_OF_RESOURCES;
241 
242  for (i = 0, ctxt_elem = (RpcContextElement *)msg->Buffer;
243  i < hdr->num_elements;
244  i++, ctxt_elem = (RpcContextElement *)&ctxt_elem->transfer_syntaxes[ctxt_elem->num_syntaxes])
245  {
246  RpcServerInterface* sif = NULL;
247  unsigned int j;
248 
249  for (j = 0; !sif && j < ctxt_elem->num_syntaxes; j++)
250  {
251  sif = RPCRT4_find_interface(NULL, &ctxt_elem->abstract_syntax,
252  &ctxt_elem->transfer_syntaxes[j], FALSE);
253  if (sif)
254  break;
255  }
256  if (sif)
257  {
259  TRACE("accepting bind request on connection %p for %s\n", conn,
261  results[i].result = RESULT_ACCEPT;
262  results[i].reason = REASON_NONE;
263  results[i].transfer_syntax = ctxt_elem->transfer_syntaxes[j];
264 
265  /* save the interface for later use */
266  /* FIXME: save linked list */
267  conn->ActiveInterface = ctxt_elem->abstract_syntax;
268  }
269  else if ((sif = RPCRT4_find_interface(NULL, &ctxt_elem->abstract_syntax,
270  NULL, FALSE)) != NULL)
271  {
273  TRACE("not accepting bind request on connection %p for %s - no transfer syntaxes supported\n",
274  conn, debugstr_guid(&ctxt_elem->abstract_syntax.SyntaxGUID));
277  memset(&results[i].transfer_syntax, 0, sizeof(results[i].transfer_syntax));
278  }
279  else
280  {
281  TRACE("not accepting bind request on connection %p for %s - abstract syntax not supported\n",
282  conn, debugstr_guid(&ctxt_elem->abstract_syntax.SyntaxGUID));
285  memset(&results[i].transfer_syntax, 0, sizeof(results[i].transfer_syntax));
286  }
287  }
288 
289  /* create temporary binding */
290  status = RPCRT4_MakeBinding(&conn->server_binding, conn);
291  if (status != RPC_S_OK)
292  {
294  return status;
295  }
296 
298  conn->NetworkAddr, conn->Endpoint,
299  conn->NetworkOptions,
300  hdr->assoc_gid,
301  &conn->server_binding->Assoc);
302  if (status != RPC_S_OK)
303  {
305  return status;
306  }
307 
308  if (auth_length)
309  {
311  (RpcAuthVerifier *)auth_data,
312  auth_length, auth_data_out,
313  auth_length_out);
314  if (status != RPC_S_OK)
315  {
317  return status;
318  }
319  }
320 
324  conn->server_binding->Assoc->assoc_group_id,
325  conn->Endpoint, hdr->num_elements,
326  results);
328 
329  if (*ack_response)
330  conn->MaxTransmissionSize = hdr->max_tsize;
331  else
333 
334  return status;
335 }
USHORT MaxTransmissionSize
Definition: rpc_binding.h:71
#define RESULT_PROVIDER_REJECTION
Definition: rpc_defs.h:213
#define REASON_NONE
Definition: rpc_defs.h:215
#define TRUE
Definition: types.h:120
static RpcServerInterface * RPCRT4_find_interface(UUID *object, const RPC_SYNTAX_IDENTIFIER *if_id, const RPC_SYNTAX_IDENTIFIER *transfer_syntax, BOOL check_object)
Definition: rpc_server.c:130
char hdr[14]
Definition: iptest.cpp:33
static const char * rpcrt4_conn_get_name(const RpcConnection *Connection)
Definition: rpc_binding.h:183
#define RPC_S_INVALID_BOUND
Definition: winerror.h:1043
#define RESULT_ACCEPT
Definition: rpc_defs.h:211
int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
Definition: rpcrt4_main.c:266
long RPC_STATUS
Definition: rpc.h:52
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned char num_syntaxes
Definition: rpc_defs.h:69
smooth NULL
Definition: ftsmooth.c:416
#define debugstr_guid
Definition: kernel32.h:35
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
RpcPktHdr * RPCRT4_BuildBindAckHeader(ULONG DataRepresentation, unsigned short MaxTransmissionSize, unsigned short MaxReceiveSize, ULONG AssocGroupId, LPCSTR ServerAddress, unsigned char ResultCount, const RpcResult *Results)
Definition: rpc_message.c:253
LPWSTR NetworkOptions
Definition: rpc_binding.h:69
#define RPC_MIN_PACKET_SIZE
Definition: rpc_defs.h:183
LPSTR NetworkAddr
Definition: rpc_binding.h:67
struct _test_info results[8]
Definition: SetCursorPos.c:29
RPC_STATUS RPCRT4_ServerConnectionAuth(RpcConnection *conn, BOOL start, RpcAuthVerifier *auth_data_in, ULONG auth_length_in, unsigned char **auth_data_out, ULONG *auth_length_out)
Definition: rpc_message.c:1025
RPC_STATUS RPCRT4_MakeBinding(RpcBinding **Binding, RpcConnection *Connection)
Definition: rpc_binding.c:232
static void RPCRT4_release_server_interface(RpcServerInterface *sif)
Definition: rpc_server.c:159
struct _RpcBinding * server_binding
Definition: rpc_binding.h:96
#define ERR(fmt,...)
Definition: debug.h:109
#define NDR_LOCAL_DATA_REPRESENTATION
Definition: rpcndr.h:107
RPC_SYNTAX_IDENTIFIER transfer_syntaxes[ANYSIZE_ARRAY]
Definition: rpc_defs.h:72
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
#define msg(x)
Definition: auth_time.c:54
RPC_STATUS RpcServerAssoc_GetAssociation(LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, ULONG assoc_gid, RpcAssoc **assoc_out)
Definition: rpc_assoc.c:137
#define REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED
Definition: rpc_defs.h:216
#define REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED
Definition: rpc_defs.h:217
#define RPC_MAX_PACKET_SIZE
Definition: rpc_defs.h:184
RPC_SYNTAX_IDENTIFIER abstract_syntax
Definition: rpc_defs.h:71
#define memset(x, y, z)
Definition: compat.h:39
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:402
#define RPC_S_OK
Definition: rpcnterr.h:22
RPC_SYNTAX_IDENTIFIER ActiveInterface
Definition: rpc_binding.h:92
Definition: ps.c:97

Referenced by process_bind_packet().

◆ process_request_packet()

static RPC_STATUS process_request_packet ( RpcConnection conn,
RpcPktRequestHdr hdr,
RPC_MESSAGE msg 
)
static

Definition at line 362 of file rpc_server.c.

363 {
365  RpcPktHdr *response = NULL;
366  RpcServerInterface* sif;
368  BOOL exception;
369  UUID *object_uuid;
370  NDR_SCONTEXT context_handle;
371  void *buf = msg->Buffer;
372 
373  /* fail if the connection isn't bound with an interface */
374  if (UuidIsNil(&conn->ActiveInterface.SyntaxGUID, &status)) {
375  /* FIXME: should send BindNack instead */
377  status);
378 
379  RPCRT4_Send(conn, response, NULL, 0);
380  RPCRT4_FreeHeader(response);
381  return RPC_S_OK;
382  }
383 
384  if (hdr->common.flags & RPC_FLG_OBJECT_UUID) {
385  object_uuid = (UUID*)(hdr + 1);
386  } else {
387  object_uuid = NULL;
388  }
389 
390  sif = RPCRT4_find_interface(object_uuid, &conn->ActiveInterface, NULL, TRUE);
391  if (!sif) {
392  WARN("interface %s no longer registered, returning fault packet\n", debugstr_guid(&conn->ActiveInterface.SyntaxGUID));
394  NCA_S_UNK_IF);
395 
396  RPCRT4_Send(conn, response, NULL, 0);
397  RPCRT4_FreeHeader(response);
398  return RPC_S_OK;
399  }
400  msg->RpcInterfaceInformation = sif->If;
401  /* copy the endpoint vector from sif to msg so that midl-generated code will use it */
402  msg->ManagerEpv = sif->MgrEpv;
403  if (object_uuid != NULL) {
404  RPCRT4_SetBindingObject(msg->Handle, object_uuid);
405  }
406 
407  /* find dispatch function */
408  msg->ProcNum = hdr->opnum;
409  if (sif->Flags & RPC_IF_OLE) {
410  /* native ole32 always gives us a dispatch table with a single entry
411  * (I assume that's a wrapper for IRpcStubBuffer::Invoke) */
413  } else {
414  if (msg->ProcNum >= sif->If->DispatchTable->DispatchTableCount) {
415  WARN("invalid procnum (%d/%d)\n", msg->ProcNum, sif->If->DispatchTable->DispatchTableCount);
418 
419  RPCRT4_Send(conn, response, NULL, 0);
420  RPCRT4_FreeHeader(response);
421  }
422  func = sif->If->DispatchTable->DispatchTable[msg->ProcNum];
423  }
424 
425  /* put in the drep. FIXME: is this more universally applicable?
426  perhaps we should move this outward... */
427  msg->DataRepresentation =
428  MAKELONG( MAKEWORD(hdr->common.drep[0], hdr->common.drep[1]),
429  MAKEWORD(hdr->common.drep[2], hdr->common.drep[3]));
430 
431  exception = FALSE;
432 
433  /* dispatch */
435  __TRY {
436  if (func) func(msg);
437  } __EXCEPT_ALL {
438  WARN("exception caught with code 0x%08x = %d\n", GetExceptionCode(), GetExceptionCode());
439  exception = TRUE;
442  else
444  response = RPCRT4_BuildFaultHeader(msg->DataRepresentation,
446  } __ENDTRY
448 
449  /* release any unmarshalled context handles */
450  while ((context_handle = RPCRT4_PopThreadContextHandle()) != NULL)
451  RpcServerAssoc_ReleaseContextHandle(conn->server_binding->Assoc, context_handle, TRUE);
452 
453  if (!exception)
454  response = RPCRT4_BuildResponseHeader(msg->DataRepresentation,
455  msg->BufferLength);
456 
457  /* send response packet */
458  if (response) {
459  status = RPCRT4_Send(conn, response, exception ? NULL : msg->Buffer,
460  exception ? 0 : msg->BufferLength);
461  RPCRT4_FreeHeader(response);
462  } else
463  ERR("out of memory\n");
464 
465  msg->RpcInterfaceInformation = NULL;
467 
468  if (msg->Buffer == buf) buf = NULL;
469  TRACE("freeing Buffer=%p\n", buf);
470  I_RpcFree(buf);
471 
472  return status;
473 }
GLenum func
Definition: glext.h:6028
#define TRUE
Definition: types.h:120
static RpcServerInterface * RPCRT4_find_interface(UUID *object, const RPC_SYNTAX_IDENTIFIER *if_id, const RPC_SYNTAX_IDENTIFIER *transfer_syntax, BOOL check_object)
Definition: rpc_server.c:130
char hdr[14]
Definition: iptest.cpp:33
PRPC_DISPATCH_TABLE DispatchTable
Definition: rpcdcep.h:106
#define NCA_S_UNK_IF
Definition: ncastatus.h:25
void WINAPI I_RpcFree(void *Object)
Definition: rpcrt4_main.c:722
#define MAKEWORD(a, b)
Definition: typedefs.h:247
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define exception
Definition: math.h:26
void(__RPC_STUB * RPC_DISPATCH_FUNCTION)(PRPC_MESSAGE Message)
Definition: rpcdcep.h:82
#define WARN(fmt,...)
Definition: debug.h:111
#define NCA_S_OP_RNG_ERROR
Definition: ncastatus.h:24
VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
Definition: rpc_message.c:403
#define RPC_IF_OLE
Definition: rpcdce.h:314
RpcPktHdr * RPCRT4_BuildFaultHeader(ULONG DataRepresentation, RPC_STATUS Status)
Definition: rpc_message.c:170
RPC_DISPATCH_FUNCTION * DispatchTable
Definition: rpcdcep.h:88
int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
Definition: rpcrt4_main.c:266
long RPC_STATUS
Definition: rpc.h:52
#define ERROR_NOACCESS
Definition: winerror.h:578
unsigned int BOOL
Definition: ntddk_ex.h:94
#define MAKELONG(a, b)
Definition: typedefs.h:248
unsigned int DispatchTableCount
Definition: rpcdcep.h:87
smooth NULL
Definition: ftsmooth.c:416
#define __TRY
Definition: compat.h:70
#define debugstr_guid
Definition: kernel32.h:35
#define GetExceptionCode()
Definition: exception.h:66
#define TRACE(s)
Definition: solgame.cpp:4
NCA_STATUS RPC2NCA_STATUS(RPC_STATUS status)
Definition: rpc_message.c:408
RPC_MGR_EPV * MgrEpv
Definition: rpc_server.h:68
NDR_SCONTEXT RPCRT4_PopThreadContextHandle(void) DECLSPEC_HIDDEN
Definition: rpcrt4_main.c:1014
#define RPC_FLG_OBJECT_UUID
Definition: rpc_defs.h:181
#define __ENDTRY
Definition: compat.h:72
static void RPCRT4_release_server_interface(RpcServerInterface *sif)
Definition: rpc_server.c:159
RPC_SERVER_INTERFACE * If
Definition: rpc_server.h:66
struct _RpcBinding * server_binding
Definition: rpc_binding.h:96
#define ERR(fmt,...)
Definition: debug.h:109
unsigned int RpcServerAssoc_ReleaseContextHandle(RpcAssoc *assoc, NDR_SCONTEXT SContext, BOOL release_lock)
Definition: rpc_assoc.c:563
#define NDR_LOCAL_DATA_REPRESENTATION
Definition: rpcndr.h:107
RPC_STATUS RPCRT4_SetBindingObject(RpcBinding *Binding, const UUID *ObjectUuid)
Definition: rpc_binding.c:224
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:228
RPC_STATUS RPCRT4_Send(RpcConnection *Connection, RpcPktHdr *Header, void *Buffer, unsigned int BufferLength)
Definition: rpc_message.c:1223
#define msg(x)
Definition: auth_time.c:54
void RPCRT4_SetThreadCurrentCallHandle(RpcBinding *Binding) DECLSPEC_HIDDEN
Definition: rpcrt4_main.c:962
static SERVICE_STATUS status
Definition: service.c:31
RpcPktHdr * RPCRT4_BuildResponseHeader(ULONG DataRepresentation, ULONG BufferLength)
Definition: rpc_message.c:154
#define RPC_S_OK
Definition: rpcnterr.h:22
RPC_SYNTAX_IDENTIFIER ActiveInterface
Definition: rpc_binding.h:92
#define __EXCEPT_ALL
Definition: exception.h:60
Definition: ps.c:97

Referenced by RPCRT4_process_packet().

◆ RpcMgmtEnableIdleCleanup()

RPC_STATUS WINAPI RpcMgmtEnableIdleCleanup ( void  )

Definition at line 1611 of file rpc_server.c.

1612 {
1613  FIXME("(): stub\n");
1614  return RPC_S_OK;
1615 }
#define FIXME(fmt,...)
Definition: debug.h:110
#define RPC_S_OK
Definition: rpcnterr.h:22

◆ RpcMgmtEpEltInqBegin()

RPC_STATUS WINAPI RpcMgmtEpEltInqBegin ( RPC_BINDING_HANDLE  Binding,
ULONG  InquiryType,
RPC_IF_ID IfId,
ULONG  VersOption,
UUID ObjectUuid,
RPC_EP_INQ_HANDLE InquiryContext 
)

Definition at line 1693 of file rpc_server.c.

1695 {
1696  FIXME("(%p,%u,%p,%u,%p,%p): stub\n",
1697  Binding, InquiryType, IfId, VersOption, ObjectUuid, InquiryContext);
1698  return RPC_S_INVALID_BINDING;
1699 }
#define FIXME(fmt,...)
Definition: debug.h:110
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013

◆ RpcMgmtInqIfIds()

RPC_STATUS WINAPI RpcMgmtInqIfIds ( RPC_BINDING_HANDLE  Binding,
RPC_IF_ID_VECTOR **  IfIdVector 
)

Definition at line 1650 of file rpc_server.c.

1651 {
1652  FIXME("(%p,%p): stub\n", Binding, IfIdVector);
1653  return RPC_S_INVALID_BINDING;
1654 }
#define FIXME(fmt,...)
Definition: debug.h:110
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013

◆ RpcMgmtInqStats()

RPC_STATUS WINAPI RpcMgmtInqStats ( RPC_BINDING_HANDLE  Binding,
RPC_STATS_VECTOR **  Statistics 
)

Definition at line 1659 of file rpc_server.c.

1660 {
1661  RPC_STATS_VECTOR *stats;
1662 
1663  FIXME("(%p,%p)\n", Binding, Statistics);
1664 
1665  if ((stats = HeapAlloc(GetProcessHeap(), 0, sizeof(RPC_STATS_VECTOR))))
1666  {
1667  stats->Count = 1;
1668  stats->Stats[0] = 0;
1669  *Statistics = stats;
1670  return RPC_S_OK;
1671  }
1672  return RPC_S_OUT_OF_RESOURCES;
1673 }
unsigned int Count
Definition: rpcdce.h:84
#define FIXME(fmt,...)
Definition: debug.h:110
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
ULONG Stats[1]
Definition: rpcdce.h:85
#define RPC_S_OK
Definition: rpcnterr.h:22

◆ RpcMgmtIsServerListening()

RPC_STATUS WINAPI RpcMgmtIsServerListening ( RPC_BINDING_HANDLE  Binding)

Definition at line 1704 of file rpc_server.c.

1705 {
1707 
1708  TRACE("(%p)\n", Binding);
1709 
1710  if (Binding) {
1711  RpcBinding *rpc_binding = (RpcBinding*)Binding;
1712  status = RPCRT4_IsServerListening(rpc_binding->Protseq, rpc_binding->Endpoint);
1713  }else {
1717  }
1718 
1719  return status;
1720 }
LPSTR Protseq
Definition: rpc_binding.h:130
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
long RPC_STATUS
Definition: rpc.h:52
LPSTR Endpoint
Definition: rpc_binding.h:132
#define RPC_S_NOT_LISTENING
Definition: winerror.h:1026
RPC_STATUS RPCRT4_IsServerListening(const char *protseq, const char *endpoint) DECLSPEC_HIDDEN
#define TRACE(s)
Definition: solgame.cpp:4
static CRITICAL_SECTION listen_cs
Definition: rpc_server.c:81
static HANDLE listen_done_event
Definition: rpc_server.c:104
static BOOL std_listen
Definition: rpc_server.c:100
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by _test_is_server_listening(), and _test_is_server_listening2().

◆ RpcMgmtSetAuthorizationFn()

RPC_STATUS WINAPI RpcMgmtSetAuthorizationFn ( RPC_MGMT_AUTHORIZATION_FN  fn)

Definition at line 1725 of file rpc_server.c.

1726 {
1727  FIXME("(%p): stub\n", fn);
1728  return RPC_S_OK;
1729 }
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
#define FIXME(fmt,...)
Definition: debug.h:110
#define RPC_S_OK
Definition: rpcnterr.h:22

◆ RpcMgmtSetServerStackSize()

RPC_STATUS WINAPI RpcMgmtSetServerStackSize ( ULONG  ThreadStackSize)

Definition at line 1734 of file rpc_server.c.

1735 {
1736  FIXME("(0x%x): stub\n", ThreadStackSize);
1737  return RPC_S_OK;
1738 }
#define FIXME(fmt,...)
Definition: debug.h:110
#define RPC_S_OK
Definition: rpcnterr.h:22

Referenced by CallPerInstanceInitFunctions().

◆ RpcMgmtStatsVectorFree()

RPC_STATUS WINAPI RpcMgmtStatsVectorFree ( RPC_STATS_VECTOR **  StatsVector)

Definition at line 1678 of file rpc_server.c.

1679 {
1680  FIXME("(%p)\n", StatsVector);
1681 
1682  if (StatsVector)
1683  {
1684  HeapFree(GetProcessHeap(), 0, *StatsVector);
1685  *StatsVector = NULL;
1686  }
1687  return RPC_S_OK;
1688 }
#define FIXME(fmt,...)
Definition: debug.h:110
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:403
#define HeapFree(x, y, z)
Definition: compat.h:402
#define RPC_S_OK
Definition: rpcnterr.h:22

◆ RpcMgmtStopServerListening()

RPC_STATUS WINAPI RpcMgmtStopServerListening ( RPC_BINDING_HANDLE  Binding)

Definition at line 1596 of file rpc_server.c.

1597 {
1598  TRACE("(Binding == (RPC_BINDING_HANDLE)^%p)\n", Binding);
1599 
1600  if (Binding) {
1601  FIXME("client-side invocation not implemented.\n");
1603  }
1604 
1605  return RPCRT4_stop_listen(FALSE);
1606 }
#define RPC_S_WRONG_KIND_OF_BINDING
Definition: winerror.h:1012
#define FIXME(fmt,...)
Definition: debug.h:110
#define TRACE(s)
Definition: solgame.cpp:4
static RPC_STATUS RPCRT4_stop_listen(BOOL auto_listen)
Definition: rpc_server.c:779

Referenced by _ServiceControlHandlerEx(), RpcpStopRpcServer(), RpcpStopRpcServerEx(), s_stop(), SamrShutdownSamServer(), service_handler(), ServiceControlHandler(), test_rpc_ncacn_ip_tcp(), test_server_listening(), and test_stop_wait_for_call().

◆ RpcMgmtWaitServerListen()

RPC_STATUS WINAPI RpcMgmtWaitServerListen ( void  )

Definition at line 1539 of file rpc_server.c.

1540 {
1541  RpcServerProtseq *protseq;
1542  HANDLE event, wait_thread;
1543 
1544  TRACE("()\n");
1545 
1547  event = listen_done_event;
1549 
1550  if (!event)
1551  return RPC_S_NOT_LISTENING;
1552 
1553  TRACE( "waiting for server calls to finish\n" );
1555  TRACE( "done waiting\n" );
1556 
1558  /* wait for server threads to finish */
1559  while(1)
1560  {
1561  if (listen_count)
1562  break;
1563 
1564  wait_thread = NULL;
1567  {
1568  if ((wait_thread = protseq->server_thread))
1569  {
1570  protseq->server_thread = NULL;
1571  break;
1572  }
1573  }
1575  if (!wait_thread)
1576  break;
1577 
1578  TRACE("waiting for thread %u\n", GetThreadId(wait_thread));
1580  WaitForSingleObject(wait_thread, INFINITE);
1581  CloseHandle(wait_thread);
1583  }
1584  if (listen_done_event == event)
1585  {
1587  CloseHandle( event );
1588  }
1590  return RPC_S_OK;
1591 }
static struct list protseqs
Definition: rpc_server.c:68
#define CloseHandle
Definition: compat.h:406
DWORD WINAPI GetThreadId(IN HANDLE Thread)
Definition: thread.c:912
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
smooth NULL
Definition: ftsmooth.c:416
#define RPC_S_NOT_LISTENING
Definition: winerror.h:1026
#define TRACE(s)
Definition: solgame.cpp:4
HANDLE server_thread
Definition: rpc_server.h:41
static LONG listen_count
Definition: rpc_server.c:102
uint32_t entry
Definition: isohybrid.c:63
static CRITICAL_SECTION listen_cs
Definition: rpc_server.c:81
struct _cl_event * event
Definition: glext.h:7739
static HANDLE listen_done_event
Definition: rpc_server.c:104
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
#define INFINITE
Definition: serial.h:102
#define RPC_S_OK
Definition: rpcnterr.h:22

Referenced by RpcpStopRpcServer(), RpcpStopRpcServerEx(), RpcServerListen(), run_server(), server(), test_rpc_ncacn_ip_tcp(), test_server_listening(), and wait_listen_proc().

◆ RpcObjectSetType()

RPC_STATUS WINAPI RpcObjectSetType ( UUID ObjUuid,
UUID TypeUuid 
)

Definition at line 1281 of file rpc_server.c.

1282 {
1283  RpcObjTypeMap *map = RpcObjTypeMaps, *prev = NULL;
1284  RPC_STATUS dummy;
1285 
1286  TRACE("(ObjUUID == %s, TypeUuid == %s).\n", debugstr_guid(ObjUuid), debugstr_guid(TypeUuid));
1287  if ((! ObjUuid) || UuidIsNil(ObjUuid, &dummy)) {
1288  /* nil uuid cannot be remapped */
1289  return RPC_S_INVALID_OBJECT;
1290  }
1291 
1292  /* find the mapping for this object if there is one ... */
1293  while (map) {
1294  if (! UuidCompare(ObjUuid, &map->Object, &dummy)) break;
1295  prev = map;
1296  map = map->next;
1297  }
1298  if ((! TypeUuid) || UuidIsNil(TypeUuid, &dummy)) {
1299  /* ... and drop it from the list */
1300  if (map) {
1301  if (prev)
1302  prev->next = map->next;
1303  else
1304  RpcObjTypeMaps = map->next;
1305  HeapFree(GetProcessHeap(), 0, map);
1306  }
1307  } else {
1308  /* ... , fail if we found it ... */
1309  if (map)
1310  return RPC_S_ALREADY_REGISTERED;
1311  /* ... otherwise create a new one and add it in. */
1312  map = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcObjTypeMap));
1313  map->Object = *ObjUuid;
1314  map->Type = *TypeUuid;
1315  map->next = NULL;
1316  if (prev)
1317  prev->next = map; /* prev is the last map in the linklist */
1318  else
1319  RpcObjTypeMaps = map;
1320  }
1321 
1322  return RPC_S_OK;
1323 }
int WINAPI UuidCompare(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
Definition: rpcrt4_main.c:207
int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
Definition: rpcrt4_main.c:266
long RPC_STATUS
Definition: rpc.h:52
#define RPC_S_INVALID_OBJECT
Definition: winerror.h:1142
smooth NULL
Definition: ftsmooth.c:416
#define debugstr_guid
Definition: kernel32.h:35
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
Definition: _map.h:44
unsigned char dummy
Definition: maze.c:118
#define HeapFree(x, y, z)
Definition: compat.h:402
#define RPC_S_ALREADY_REGISTERED
Definition: winerror.h:1022
#define RPC_S_OK
Definition: rpcnterr.h:22
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum map
Definition: glfuncs.h:262
static RpcObjTypeMap * RpcObjTypeMaps
Definition: rpc_server.c:65

◆ RPCRT4_destroy_all_protseqs()

void RPCRT4_destroy_all_protseqs ( void  )

Definition at line 1094 of file rpc_server.c.

1095 {
1096  RpcServerProtseq *cps, *cursor2;
1097 
1098  if (listen_count != 0)
1099  std_listen = FALSE;
1100 
1103  {
1104  if (listen_count != 0)
1107  }
1111 }
static struct list protseqs
Definition: rpc_server.c:68
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
static void RPCRT4_sync_with_server_thread(RpcServerProtseq *ps)
Definition: rpc_server.c:708
static LONG listen_count
Definition: rpc_server.c:102
uint32_t entry
Definition: isohybrid.c:63
static CRITICAL_SECTION listen_cs
Definition: rpc_server.c:81
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
static BOOL std_listen
Definition: rpc_server.c:100
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static void destroy_serverprotoseq(RpcServerProtseq *ps)
Definition: rpc_server.c:975

Referenced by DllMain().

◆ RPCRT4_find_interface()

static RpcServerInterface* RPCRT4_find_interface ( UUID object,
const RPC_SYNTAX_IDENTIFIER if_id,
const RPC_SYNTAX_IDENTIFIER transfer_syntax,
BOOL  check_object 
)
static

Definition at line 130 of file rpc_server.c.

134 {
135  UUID* MgrType = NULL;
136  RpcServerInterface* cif;
138 
139  if (check_object)
140  MgrType = LookupObjType(object);
143  if (!memcmp(if_id, &cif->If->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER)) &&
144  (!transfer_syntax || !memcmp(transfer_syntax, &cif->If->TransferSyntax, sizeof(RPC_SYNTAX_IDENTIFIER))) &&
145  (check_object == FALSE || UuidEqual(MgrType, &cif->MgrTypeUuid, &status)) &&
146  std_listen) {
148  break;
149  }
150  }
152  if (&cif->entry == &server_interfaces) cif = NULL;
153  TRACE("returning %p for object %s, if_id { %d.%d %s }\n", cif,
154  debugstr_guid(object), if_id->SyntaxVersion.MajorVersion,
156  return cif;
157 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
unsigned short MajorVersion
Definition: rpcdcep.h:27
int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
Definition: rpcrt4_main.c:250
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
static UUID * LookupObjType(UUID *ObjUuid)
Definition: rpc_server.c:121
RPC_SYNTAX_IDENTIFIER InterfaceId
Definition: rpcdcep.h:104
long RPC_STATUS
Definition: rpc.h:52
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
RPC_VERSION SyntaxVersion
Definition: rpcdcep.h:33
smooth NULL
Definition: ftsmooth.c:416
#define debugstr_guid
Definition: kernel32.h:35
RPC_SYNTAX_IDENTIFIER TransferSyntax
Definition: rpcdcep.h:105
#define TRACE(s)
Definition: solgame.cpp:4
struct list entry
Definition: rpc_server.h:65
unsigned short MinorVersion
Definition: rpcdcep.h:28
uint32_t entry
Definition: isohybrid.c:63
RPC_SERVER_INTERFACE * If
Definition: rpc_server.h:66
#define InterlockedIncrement
Definition: armddk.h:53
static BOOL std_listen
Definition: rpc_server.c:100
static struct list server_interfaces
Definition: rpc_server.c:69
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by process_bind_packet_no_send(), and process_request_packet().

◆ RPCRT4_get_or_create_serverprotseq()

static RPC_STATUS RPCRT4_get_or_create_serverprotseq ( UINT  MaxCalls,
const char Protseq,
RpcServerProtseq **  ps 
)
static

Definition at line 987 of file rpc_server.c.

988 {
990  RpcServerProtseq *cps;
991 
993 
995  if (!strcmp(cps->Protseq, Protseq))
996  {
997  TRACE("found existing protseq object for %s\n", Protseq);
998  *ps = cps;
1000  return S_OK;
1001  }
1002 
1003  status = alloc_serverprotoseq(MaxCalls, Protseq, ps);
1004 
1006 
1007  return status;
1008 }
static struct list protseqs
Definition: rpc_server.c:68
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
long RPC_STATUS
Definition: rpc.h:52
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
#define TRACE(s)
Definition: solgame.cpp:4
uint32_t entry
Definition: isohybrid.c:63
#define S_OK
Definition: intsafe.h:59
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static RPC_STATUS alloc_serverprotoseq(UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
Definition: rpc_server.c:946
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by RpcServerUseProtseqA(), RpcServerUseProtseqEpExA(), RpcServerUseProtseqEpExW(), and RpcServerUseProtseqW().

◆ RPCRT4_io_thread()

static DWORD CALLBACK RPCRT4_io_thread ( LPVOID  the_arg)
static

Definition at line 543 of file rpc_server.c.

544 {
545  RpcConnection* conn = the_arg;
546  RpcPktHdr *hdr;
547  RPC_MESSAGE *msg;
549  RpcPacket *packet;
550  unsigned char *auth_data;
551  ULONG auth_length;
552 
553  TRACE("(%p)\n", conn);
554 
555  for (;;) {
557  if (!msg) break;
558 
559  status = RPCRT4_ReceiveWithAuth(conn, &hdr, msg, &auth_data, &auth_length);
560  if (status != RPC_S_OK) {
561  WARN("receive failed with error %x\n", status);
562  HeapFree(GetProcessHeap(), 0, msg);
563  break;
564  }
565 
566  switch (hdr->common.ptype) {
567  case PKT_BIND:
568  TRACE("got bind packet\n");
569 
570  status = process_bind_packet(conn, &hdr->bind, msg, auth_data,
571  auth_length);
572  break;
573 
574  case PKT_REQUEST:
575  TRACE("got request packet\n");
576 
577  packet = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcPacket));
578  if (!packet) {
579  I_RpcFree(msg->Buffer);
581  HeapFree(GetProcessHeap(), 0, msg);
582  HeapFree(GetProcessHeap(), 0, auth_data);
583  goto exit;
584  }
585  packet->conn = RPCRT4_GrabConnection( conn );
586  packet->hdr = hdr;
587  packet->msg = msg;
588  packet->auth_data = auth_data;
589  packet->auth_length = auth_length;
591  ERR("couldn't queue work item for worker thread, error was %d\n", GetLastError());
594  } else {
595  continue;
596  }
597  break;
598 
599  case PKT_AUTH3:
600  TRACE("got auth3 packet\n");
601 
602  status = process_auth3_packet(conn, &hdr->common, msg, auth_data,
603  auth_length);
604  break;
605  default:
606  FIXME("unhandled packet type %u\n", hdr->common.ptype);
607  break;
608  }
609 
610  I_RpcFree(msg->Buffer);
612  HeapFree(GetProcessHeap(), 0, msg);
613  HeapFree(GetProcessHeap(), 0, auth_data);
614 
615  if (status != RPC_S_OK) {
616  WARN("processing packet failed with error %u\n", status);
617  break;
618  }
619  }
620 exit:
622  return 0;
623 }
char hdr[14]
Definition: iptest.cpp:33
UCHAR packet[_PAGE_SIZE]
Definition: serial.c:53
void WINAPI I_RpcFree(void *Object)
Definition: rpcrt4_main.c:722
#define WARN(fmt,...)
Definition: debug.h:111
VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
Definition: rpc_message.c:403
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
static DWORD CALLBACK RPCRT4_worker_thread(LPVOID the_arg)
Definition: rpc_server.c:533
RpcConnection * RPCRT4_GrabConnection(RpcConnection *conn) DECLSPEC_HIDDEN
long RPC_STATUS
Definition: rpc.h:52
#define FIXME(fmt,...)
Definition: debug.h:110
Definition: dhcpd.h:135
void RPCRT4_ReleaseConnection(RpcConnection *Connection) DECLSPEC_HIDDEN
#define WT_EXECUTELONGFUNCTION
Definition: winnt_old.h:1076
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
RPC_STATUS RPCRT4_ReceiveWithAuth(RpcConnection *Connection, RpcPktHdr **Header, PRPC_MESSAGE pMsg, unsigned char **auth_data_out, ULONG *auth_length_out)
Definition: rpc_message.c:1376
BOOL WINAPI QueueUserWorkItem(IN LPTHREAD_START_ROUTINE Function, IN PVOID Context, IN ULONG Flags)
Definition: thread.c:1064
static RPC_STATUS process_bind_packet(RpcConnection *conn, RpcPktBindHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length)
Definition: rpc_server.c:337
static RPC_STATUS process_auth3_packet(RpcConnection *conn, RpcPktCommonHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length)
Definition: rpc_server.c:475
#define ERR(fmt,...)
Definition: debug.h:109
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
#define msg(x)
Definition: auth_time.c:54
unsigned int ULONG
Definition: retypes.h:1
void exit(int exitcode)
Definition: _exit.c:33
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:402
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RPCRT4_new_client().

◆ RPCRT4_new_client()

void RPCRT4_new_client ( RpcConnection conn)

Definition at line 625 of file rpc_server.c.

626 {
628  if (!thread) {
629  DWORD err = GetLastError();
630  ERR("failed to create thread, error=%08x\n", err);
632  }
633  /* we could set conn->thread, but then we'd have to make the io_thread wait
634  * for that, otherwise the thread might finish, destroy the connection, and
635  * free the memory we'd write to before we did, causing crashes and stuff -
636  * so let's implement that later, when we really need conn->thread */
637 
638  CloseHandle( thread );
639 }
#define CloseHandle
Definition: compat.h:406
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:136
smooth NULL
Definition: ftsmooth.c:416
void RPCRT4_ReleaseConnection(RpcConnection *Connection) DECLSPEC_HIDDEN
unsigned long DWORD
Definition: ntddk_ex.h:95
static HANDLE thread
Definition: service.c:33
#define err(...)
#define ERR(fmt,...)
Definition: debug.h:109
static DWORD CALLBACK RPCRT4_io_thread(LPVOID the_arg)
Definition: rpc_server.c:543

Referenced by rpcrt4_protseq_np_wait_for_new_connection(), and rpcrt4_protseq_sock_wait_for_new_connection().

◆ RPCRT4_process_packet()

static void RPCRT4_process_packet ( RpcConnection conn,
RpcPktHdr hdr,
RPC_MESSAGE msg,
unsigned char auth_data,
ULONG  auth_length 
)
static

Definition at line 500 of file rpc_server.c.

503 {
504  msg->Handle = (RPC_BINDING_HANDLE)conn->server_binding;
505 
506  switch (hdr->common.ptype) {
507  case PKT_BIND:
508  TRACE("got bind packet\n");
509  process_bind_packet(conn, &hdr->bind, msg, auth_data, auth_length);
510  break;
511 
512  case PKT_REQUEST:
513  TRACE("got request packet\n");
514  process_request_packet(conn, &hdr->request, msg);
515  break;
516 
517  case PKT_AUTH3:
518  TRACE("got auth3 packet\n");
519  process_auth3_packet(conn, &hdr->common, msg, auth_data, auth_length);
520  break;
521  default:
522  FIXME("unhandled packet type %u\n", hdr->common.ptype);
523  break;
524  }
525 
526  /* clean up */
527  I_RpcFree(msg->Buffer);
529  HeapFree(GetProcessHeap(), 0, msg);
530  HeapFree(GetProcessHeap(), 0, auth_data);
531 }
char hdr[14]
Definition: iptest.cpp:33
void WINAPI I_RpcFree(void *Object)
Definition: rpcrt4_main.c:722
VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
Definition: rpc_message.c:403
#define FIXME(fmt,...)
Definition: debug.h:110
switch(r->id)
Definition: btrfs.c:2904
static RPC_STATUS process_request_packet(RpcConnection *conn, RpcPktRequestHdr *hdr, RPC_MESSAGE *msg)
Definition: rpc_server.c:362
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
static RPC_STATUS process_bind_packet(RpcConnection *conn, RpcPktBindHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length)
Definition: rpc_server.c:337
struct _RpcBinding * server_binding
Definition: rpc_binding.h:96
static RPC_STATUS process_auth3_packet(RpcConnection *conn, RpcPktCommonHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length)
Definition: rpc_server.c:475
#define msg(x)
Definition: auth_time.c:54
I_RPC_HANDLE RPC_BINDING_HANDLE
Definition: rpcdce.h:50
#define HeapFree(x, y, z)
Definition: compat.h:402

Referenced by RPCRT4_worker_thread().

◆ RPCRT4_protseq_is_endpoint_registered()

static BOOL RPCRT4_protseq_is_endpoint_registered ( RpcServerProtseq protseq,
const char endpoint 
)
static

Definition at line 817 of file rpc_server.c.

818 {
819  RpcConnection *conn;
820  BOOL registered = FALSE;
821  EnterCriticalSection(&protseq->cs);
822  LIST_FOR_EACH_ENTRY(conn, &protseq->listeners, RpcConnection, protseq_entry) {
823  if (!endpoint || !strcmp(endpoint, conn->Endpoint)) {
824  registered = TRUE;
825  break;
826  }
827  }
828  LeaveCriticalSection(&protseq->cs);
829  return registered;
830 }
#define TRUE
Definition: types.h:120
struct list listeners
Definition: rpc_server.h:36
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
unsigned int BOOL
Definition: ntddk_ex.h:94
CRITICAL_SECTION cs
Definition: rpc_server.h:38
Definition: nis.h:10
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)

Referenced by RPCRT4_use_protseq().

◆ RPCRT4_release_server_interface()

static void RPCRT4_release_server_interface ( RpcServerInterface sif)
static

Definition at line 159 of file rpc_server.c.

160 {
161  if (!InterlockedDecrement(&sif->CurrentCalls) &&
162  sif->Delete) {
163  /* sif must have been removed from server_interfaces before
164  * CallsCompletedEvent is set */
165  if (sif->CallsCompletedEvent)
167  HeapFree(GetProcessHeap(), 0, sif);
168  }
169 }
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
HANDLE CallsCompletedEvent
Definition: rpc_server.h:76
#define GetProcessHeap()
Definition: compat.h:403
#define InterlockedDecrement
Definition: armddk.h:52
#define HeapFree(x, y, z)
Definition: compat.h:402

Referenced by process_bind_packet_no_send(), and process_request_packet().

◆ RPCRT4_server_thread()

static DWORD CALLBACK RPCRT4_server_thread ( LPVOID  the_arg)
static

Definition at line 641 of file rpc_server.c.

642 {
643  int res;
644  unsigned int count;
645  void *objs = NULL;
646  RpcServerProtseq* cps = the_arg;
647  RpcConnection* conn;
648  BOOL set_ready_event = FALSE;
649 
650  TRACE("(the_arg == ^%p)\n", the_arg);
651 
652  for (;;) {
653  objs = cps->ops->get_wait_array(cps, objs, &count);
654 
655  if (set_ready_event)
656  {
657  /* signal to function that changed state that we are now sync'ed */
659  set_ready_event = FALSE;
660  }
661 
662  /* start waiting */
663  res = cps->ops->wait_for_new_connection(cps, count, objs);
664 
665  if (res == -1 || (res == 0 && !std_listen))
666  {
667  /* cleanup */
668  cps->ops->free_wait_array(cps, objs);
669  break;
670  }
671  else if (res == 0)
672  set_ready_event = TRUE;
673  }
674 
675  TRACE("closing connections\n");
676 
677  EnterCriticalSection(&cps->cs);
678  LIST_FOR_EACH_ENTRY(conn, &cps->listeners, RpcConnection, protseq_entry)
680  LIST_FOR_EACH_ENTRY(conn, &cps->connections, RpcConnection, protseq_entry)
681  {
682  RPCRT4_GrabConnection(conn);
684  }
685  LeaveCriticalSection(&cps->cs);
686 
687  if (res == 0 && !std_listen)
689 
690  TRACE("waiting for active connections to close\n");
691 
692  EnterCriticalSection(&cps->cs);
693  while (!list_empty(&cps->connections))
694  {
695  conn = LIST_ENTRY(list_head(&cps->connections), RpcConnection, protseq_entry);
696  LeaveCriticalSection(&cps->cs);
698  EnterCriticalSection(&cps->cs);
699  }
700  LeaveCriticalSection(&cps->cs);
701 
702  TRACE("done\n");
703  return 0;
704 }
HANDLE server_ready_event
Definition: rpc_server.h:45
#define TRUE
Definition: types.h:120
struct list listeners
Definition: rpc_server.h:36
GLuint GLuint GLsizei count
Definition: gl.h:1545
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
__WINE_SERVER_LIST_INLINE struct list * list_head(const struct list *list)
Definition: list.h:131
RpcConnection * RPCRT4_GrabConnection(RpcConnection *conn) DECLSPEC_HIDDEN
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
unsigned int BOOL
Definition: ntddk_ex.h:94
static void rpcrt4_conn_close_read(RpcConnection *connection)
Definition: rpc_binding.h:205
const struct protseq_ops * ops
Definition: rpc_server.h:31
smooth NULL
Definition: ftsmooth.c:416
struct list connections
Definition: rpc_server.h:37
CRITICAL_SECTION cs
Definition: rpc_server.h:38
#define TRACE(s)
Definition: solgame.cpp:4
void rpcrt4_conn_release_and_wait(RpcConnection *connection) DECLSPEC_HIDDEN
__WINE_SERVER_LIST_INLINE int list_empty(const struct list *list)
Definition: list.h:143
GLuint res
Definition: glext.h:9613
static BOOL std_listen
Definition: rpc_server.c:100
RPC_STATUS RPCRT4_CloseConnection(RpcConnection *Connection) DECLSPEC_HIDDEN
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
#define LIST_ENTRY(type)
Definition: queue.h:175

Referenced by RPCRT4_start_listen_protseq().

◆ RPCRT4_ServerFreeAllRegisteredAuthInfo()

void RPCRT4_ServerFreeAllRegisteredAuthInfo ( void  )

Definition at line 1396 of file rpc_server.c.

1397 {
1398  struct rpc_server_registered_auth_info *auth_info, *cursor2;
1399 
1402  {
1403  HeapFree(GetProcessHeap(), 0, auth_info->package_name);
1404  HeapFree(GetProcessHeap(), 0, auth_info->principal);
1405  HeapFree(GetProcessHeap(), 0, auth_info);
1406  }
1409 }
static CRITICAL_SECTION server_auth_info_cs
Definition: rpc_server.c:90
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static struct list server_registered_auth_info
Definition: rpc_server.c:70
#define GetProcessHeap()
Definition: compat.h:403
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
uint32_t entry
Definition: isohybrid.c:63
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
#define HeapFree(x, y, z)
Definition: compat.h:402

Referenced by DllMain().

◆ RPCRT4_ServerGetRegisteredAuthInfo()

RPC_STATUS RPCRT4_ServerGetRegisteredAuthInfo ( USHORT  auth_type,
CredHandle cred,
TimeStamp exp,
ULONG max_token 
)

Definition at line 1365 of file rpc_server.c.

1367 {
1369  struct rpc_server_registered_auth_info *auth_info;
1370  SECURITY_STATUS sec_status;
1371 
1374  {
1375  if (auth_info->auth_type == auth_type)
1376  {
1377  sec_status = AcquireCredentialsHandleW((SEC_WCHAR *)auth_info->principal, auth_info->package_name,
1379  cred, exp);
1380  if (sec_status != SEC_E_OK)
1381  {
1383  break;
1384  }
1385 
1386  *max_token = auth_info->max_token;
1387  status = RPC_S_OK;
1388  break;
1389  }
1390  }
1392 
1393  return status;
1394 }
SECURITY_STATUS WINAPI AcquireCredentialsHandleW(SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialsUse, PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
Definition: wrapper.c:105
WCHAR SEC_WCHAR
Definition: sspi.h:29
static CRITICAL_SECTION server_auth_info_cs
Definition: rpc_server.c:90
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
long RPC_STATUS
Definition: rpc.h:52
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
#define SECPKG_CRED_INBOUND
Definition: sspi.h:277
#define RPC_S_SEC_PKG_ERROR
Definition: winerror.h:1132
smooth NULL
Definition: ftsmooth.c:416
LONG SECURITY_STATUS
Definition: sspi.h:34
static struct list server_registered_auth_info
Definition: rpc_server.c:70
#define RPC_S_UNKNOWN_AUTHN_SERVICE
Definition: winerror.h:1055
uint32_t entry
Definition: isohybrid.c:63
#define SEC_E_OK
Definition: winerror.h:2356
DWORD exp
Definition: msg.c:16038
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RPCRT4_ServerConnectionAuth().

◆ RPCRT4_start_listen()

static RPC_STATUS RPCRT4_start_listen ( BOOL  auto_listen)
static

Definition at line 741 of file rpc_server.c.

742 {
744  RpcServerProtseq *cps;
745 
746  TRACE("\n");
747 
749  if (auto_listen || !listen_done_event)
750  {
751  status = RPC_S_OK;
752  if(!auto_listen)
754  if (++listen_count == 1)
755  std_listen = TRUE;
756  }
758  if (status) return status;
759 
760  if (std_listen)
761  {
764  {
766  if (status != RPC_S_OK)
767  break;
768 
769  /* make sure server is actually listening on the interface before
770  * returning */
772  }
774  }
775 
776  return status;
777 }
static struct list protseqs
Definition: rpc_server.c:68
#define TRUE
Definition: types.h:120
static RPC_STATUS RPCRT4_start_listen_protseq(RpcServerProtseq *ps, BOOL auto_listen)
Definition: rpc_server.c:723
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
long RPC_STATUS
Definition: rpc.h:52
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
static void RPCRT4_sync_with_server_thread(RpcServerProtseq *ps)
Definition: rpc_server.c:708
static LONG listen_count
Definition: rpc_server.c:102
uint32_t entry
Definition: isohybrid.c:63
static CRITICAL_SECTION listen_cs
Definition: rpc_server.c:81
#define RPC_S_ALREADY_LISTENING
Definition: winerror.h:1024
static HANDLE listen_done_event
Definition: rpc_server.c:104
static BOOL std_listen
Definition: rpc_server.c:100
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RpcServerListen(), and RpcServerRegisterIf3().

◆ RPCRT4_start_listen_protseq()

static RPC_STATUS RPCRT4_start_listen_protseq ( RpcServerProtseq ps,
BOOL  auto_listen 
)
static

Definition at line 723 of file rpc_server.c.

724 {
726 
728  if (ps->server_thread) goto done;
729 
730  if (!ps->mgr_mutex) ps->mgr_mutex = CreateMutexW(NULL, FALSE, NULL);
733  if (!ps->server_thread)
735 
736 done:
738  return status;
739 }
HANDLE server_ready_event
Definition: rpc_server.h:45
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
long RPC_STATUS
Definition: rpc.h:52
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:136
smooth NULL
Definition: ftsmooth.c:416
static DWORD CALLBACK RPCRT4_server_thread(LPVOID the_arg)
Definition: rpc_server.c:641
HANDLE server_thread
Definition: rpc_server.h:41
static CRITICAL_SECTION listen_cs
Definition: rpc_server.c:81
HANDLE WINAPI DECLSPEC_HOTPATCH CreateMutexW(IN LPSECURITY_ATTRIBUTES lpMutexAttributes OPTIONAL, IN BOOL bInitialOwner, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:576
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RPCRT4_start_listen(), and RPCRT4_use_protseq().

◆ RPCRT4_stop_listen()

static RPC_STATUS RPCRT4_stop_listen ( BOOL  auto_listen)
static

Definition at line 779 of file rpc_server.c.

780 {
781  BOOL stop_listen = FALSE;
783 
785  if (!std_listen && (auto_listen || !listen_done_event))
786  {
788  }
789  else
790  {
791  stop_listen = listen_count != 0 && --listen_count == 0;
792  assert(listen_count >= 0);
793  if (stop_listen)
794  std_listen = FALSE;
795  }
797 
798  if (status) return status;
799 
800  if (stop_listen) {
801  RpcServerProtseq *cps;
806  }
807 
808  if (!auto_listen)
809  {
813  }
814  return RPC_S_OK;
815 }
static struct list protseqs
Definition: rpc_server.c:68
#define assert(x)
Definition: debug.h:53
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
long RPC_STATUS
Definition: rpc.h:52
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
unsigned int BOOL
Definition: ntddk_ex.h:94
#define RPC_S_NOT_LISTENING
Definition: winerror.h:1026
static void RPCRT4_sync_with_server_thread(RpcServerProtseq *ps)
Definition: rpc_server.c:708
static LONG listen_count
Definition: rpc_server.c:102
uint32_t entry
Definition: isohybrid.c:63
static CRITICAL_SECTION listen_cs
Definition: rpc_server.c:81
static HANDLE listen_done_event
Definition: rpc_server.c:104
static BOOL std_listen
Definition: rpc_server.c:100
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RpcMgmtStopServerListening().

◆ RPCRT4_sync_with_server_thread()

static void RPCRT4_sync_with_server_thread ( RpcServerProtseq ps)
static

Definition at line 708 of file rpc_server.c.

709 {
710  /* make sure we are the only thread sync'ing the server state, otherwise
711  * there is a race with the server thread setting an older state and setting
712  * the server_ready_event when the new state hasn't yet been applied */
714 
715  ps->ops->signal_state_changed(ps);
716 
717  /* wait for server thread to make the requested changes before returning */
719 
720  ReleaseMutex(ps->mgr_mutex);
721 }
HANDLE server_ready_event
Definition: rpc_server.h:45
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
const struct protseq_ops * ops
Definition: rpc_server.h:31
BOOL WINAPI DECLSPEC_HOTPATCH ReleaseMutex(IN HANDLE hMutex)
Definition: synch.c:618
#define INFINITE
Definition: serial.h:102

Referenced by RPCRT4_destroy_all_protseqs(), RPCRT4_start_listen(), RPCRT4_stop_listen(), and RPCRT4_use_protseq().

◆ RPCRT4_use_protseq()

static RPC_STATUS RPCRT4_use_protseq ( RpcServerProtseq ps,
const char endpoint 
)
static

Definition at line 832 of file rpc_server.c.

833 {
835 
836  EnterCriticalSection(&ps->cs);
837 
839  status = RPC_S_OK;
840  else
841  status = ps->ops->open_endpoint(ps, endpoint);
842 
843  LeaveCriticalSection(&ps->cs);
844 
845  if (status != RPC_S_OK)
846  return status;
847 
848  if (std_listen)
849  {
851  if (status == RPC_S_OK)
853  }
854 
855  return status;
856 }
static BOOL RPCRT4_protseq_is_endpoint_registered(RpcServerProtseq *protseq, const char *endpoint)
Definition: rpc_server.c:817
static RPC_STATUS RPCRT4_start_listen_protseq(RpcServerProtseq *ps, BOOL auto_listen)
Definition: rpc_server.c:723
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
long RPC_STATUS
Definition: rpc.h:52
const struct protseq_ops * ops
Definition: rpc_server.h:31
CRITICAL_SECTION cs
Definition: rpc_server.h:38
static void RPCRT4_sync_with_server_thread(RpcServerProtseq *ps)
Definition: rpc_server.c:708
Definition: nis.h:10
static BOOL std_listen
Definition: rpc_server.c:100
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RpcServerUseProtseqA(), RpcServerUseProtseqEpExA(), RpcServerUseProtseqEpExW(), and RpcServerUseProtseqW().

◆ RPCRT4_worker_thread()

static DWORD CALLBACK RPCRT4_worker_thread ( LPVOID  the_arg)
static

Definition at line 533 of file rpc_server.c.

534 {
535  RpcPacket *pkt = the_arg;
536  RPCRT4_process_packet(pkt->conn, pkt->hdr, pkt->msg, pkt->auth_data,
537  pkt->auth_length);
539  HeapFree(GetProcessHeap(), 0, pkt);
540  return 0;
541 }
unsigned char * auth_data
Definition: rpc_server.c:53
static void RPCRT4_process_packet(RpcConnection *conn, RpcPktHdr *hdr, RPC_MESSAGE *msg, unsigned char *auth_data, ULONG auth_length)
Definition: rpc_server.c:500
ULONG auth_length
Definition: rpc_server.c:54
RPC_MESSAGE * msg
Definition: rpc_server.c:52
struct _RpcConnection * conn
Definition: rpc_server.c:50
void RPCRT4_ReleaseConnection(RpcConnection *Connection) DECLSPEC_HIDDEN
#define GetProcessHeap()
Definition: compat.h:403
#define HeapFree(x, y, z)
Definition: compat.h:402
RpcPktHdr * hdr
Definition: rpc_server.c:51

Referenced by RPCRT4_io_thread().

◆ RpcServerInqBindings()

RPC_STATUS WINAPI RpcServerInqBindings ( RPC_BINDING_VECTOR **  BindingVector)

Definition at line 861 of file rpc_server.c.

862 {
864  DWORD count;
865  RpcServerProtseq* ps;
866  RpcConnection* conn;
867 
868  if (BindingVector)
869  TRACE("(*BindingVector == ^%p)\n", *BindingVector);
870  else
871  ERR("(BindingVector == NULL!!?)\n");
872 
874  /* count connections */
875  count = 0;
877  EnterCriticalSection(&ps->cs);
878  LIST_FOR_EACH_ENTRY(conn, &ps->listeners, RpcConnection, protseq_entry)
879  count++;
880  LeaveCriticalSection(&ps->cs);
881  }
882  if (count) {
883  /* export bindings */
884  *BindingVector = HeapAlloc(GetProcessHeap(), 0,
885  sizeof(RPC_BINDING_VECTOR) +
886  sizeof(RPC_BINDING_HANDLE)*(count-1));
887  (*BindingVector)->Count = count;
888  count = 0;
890  EnterCriticalSection(&ps->cs);
891  LIST_FOR_EACH_ENTRY(conn, &ps->listeners, RpcConnection, protseq_entry) {
892  RPCRT4_MakeBinding((RpcBinding**)&(*BindingVector)->BindingH[count],
893  conn);
894  count++;
895  }
896  LeaveCriticalSection(&ps->cs);
897  }
898  status = RPC_S_OK;
899  } else {
900  *BindingVector = NULL;
902  }
904  return status;
905 }
static struct list protseqs
Definition: rpc_server.c:68
struct list listeners
Definition: rpc_server.h:36
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define RPC_S_NO_BINDINGS
Definition: winerror.h:1029
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
long RPC_STATUS
Definition: rpc.h:52
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
smooth NULL
Definition: ftsmooth.c:416
CRITICAL_SECTION cs
Definition: rpc_server.h:38
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
uint32_t entry
Definition: isohybrid.c:63
RPC_STATUS RPCRT4_MakeBinding(RpcBinding **Binding, RpcConnection *Connection)
Definition: rpc_binding.c:232
#define ERR(fmt,...)
Definition: debug.h:109
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by test_endpoint_mapper(), and test_RpcServerUseProtseq().

◆ RpcServerInqDefaultPrincNameA()

RPC_STATUS RPC_ENTRY RpcServerInqDefaultPrincNameA ( ULONG  AuthnSvc,
RPC_CSTR PrincName 
)

Definition at line 1481 of file rpc_server.c.

1482 {
1483  RPC_STATUS ret;
1484  RPC_WSTR principalW;
1485 
1486  TRACE("%u, %p\n", AuthnSvc, PrincName);
1487 
1488  if ((ret = RpcServerInqDefaultPrincNameW( AuthnSvc, &principalW )) == RPC_S_OK)
1489  {
1490  if (!(*PrincName = (RPC_CSTR)RPCRT4_strdupWtoA( principalW ))) return RPC_S_OUT_OF_MEMORY;
1491  RpcStringFreeW( &principalW );
1492  }
1493  return ret;
1494 }
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:174
unsigned short * RPC_WSTR
Definition: rpcdce.h:46
LPSTR RPCRT4_strdupWtoA(LPCWSTR src)
Definition: rpc_binding.c:58
long RPC_STATUS
Definition: rpc.h:52
#define RPC_S_OUT_OF_MEMORY
Definition: rpcnterr.h:24
unsigned char * RPC_CSTR
Definition: rpcdce.h:45
#define TRACE(s)
Definition: solgame.cpp:4
int ret
RPC_STATUS RPC_ENTRY RpcServerInqDefaultPrincNameW(ULONG AuthnSvc, RPC_WSTR *PrincName)
Definition: rpc_server.c:1499
#define RPC_S_OK
Definition: rpcnterr.h:22

Referenced by test_RpcServerInqDefaultPrincName().

◆ RpcServerInqDefaultPrincNameW()

RPC_STATUS RPC_ENTRY RpcServerInqDefaultPrincNameW ( ULONG  AuthnSvc,
RPC_WSTR PrincName 
)

Definition at line 1499 of file rpc_server.c.

1500 {
1501  ULONG len = 0;
1502 
1503  FIXME("%u, %p\n", AuthnSvc, PrincName);
1504 
1505  if (AuthnSvc != RPC_C_AUTHN_WINNT) return RPC_S_UNKNOWN_AUTHN_SERVICE;
1506 
1507  GetUserNameExW( NameSamCompatible, NULL, &len );
1509 
1510  if (!(*PrincName = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1511  return RPC_S_OUT_OF_MEMORY;
1512 
1513  GetUserNameExW( NameSamCompatible, *PrincName, &len );
1514  return RPC_S_OK;
1515 }
#define RPC_C_AUTHN_WINNT
Definition: rpcdce.h:158
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define RPC_S_OUT_OF_MEMORY
Definition: rpcnterr.h:24
#define FIXME(fmt,...)
Definition: debug.h:110
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define RPC_S_UNKNOWN_AUTHN_SERVICE
Definition: winerror.h:1055
GLenum GLsizei len
Definition: glext.h:6722
#define RPC_S_INTERNAL_ERROR
Definition: winerror.h:1074
#define ERROR_MORE_DATA
Definition: dderror.h:13
BOOLEAN WINAPI GetUserNameExW(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize)
Definition: sspi.c:1079
unsigned int ULONG
Definition: retypes.h:1
#define RPC_S_OK
Definition: rpcnterr.h:22

Referenced by RpcServerInqDefaultPrincNameA().

◆ RpcServerListen()

RPC_STATUS WINAPI RpcServerListen ( UINT  MinimumCallThreads,
UINT  MaxCalls,
UINT  DontWait 
)

Definition at line 1520 of file rpc_server.c.

1521 {
1523 
1524  TRACE("(%u,%u,%u)\n", MinimumCallThreads, MaxCalls, DontWait);
1525 
1526  if (list_empty(&protseqs))
1528 
1530 
1531  if (DontWait || (status != RPC_S_OK)) return status;
1532 
1533  return RpcMgmtWaitServerListen();
1534 }
static struct list protseqs
Definition: rpc_server.c:68
#define RPC_S_NO_PROTSEQS_REGISTERED
Definition: winerror.h:1025
long RPC_STATUS
Definition: rpc.h:52
#define TRACE(s)
Definition: solgame.cpp:4
__WINE_SERVER_LIST_INLINE int list_empty(const struct list *list)
Definition: list.h:143
RPC_STATUS WINAPI RpcMgmtWaitServerListen(void)
Definition: rpc_server.c:1539
static RPC_STATUS RPCRT4_start_listen(BOOL auto_listen)
Definition: rpc_server.c:741
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by LrpcThreadProc(), LsarStartRpcServer(), main(), RpcpStartRpcServer(), RpcServerThread(), RPCSS_Initialize(), RpcThreadRoutine(), run_server(), SampStartRpcServer(), ScmStartRpcServer(), server(), StartRpcServer(), test_ndr_buffer(), test_rpc_ncacn_ip_tcp(), test_server_listening(), and test_stop_wait_for_call().

◆ RpcServerRegisterAuthInfoA()

RPC_STATUS WINAPI RpcServerRegisterAuthInfoA ( RPC_CSTR  ServerPrincName,
ULONG  AuthnSvc,
RPC_AUTH_KEY_RETRIEVAL_FN  GetKeyFn,
LPVOID  Arg 
)

Definition at line 1414 of file rpc_server.c.

1416 {
1417  WCHAR *principal_name = NULL;
1419 
1420  TRACE("(%s,%u,%p,%p)\n", ServerPrincName, AuthnSvc, GetKeyFn, Arg);
1421 
1422  if(ServerPrincName && !(principal_name = RPCRT4_strdupAtoW((const char*)ServerPrincName)))
1423  return RPC_S_OUT_OF_RESOURCES;
1424 
1425  status = RpcServerRegisterAuthInfoW(principal_name, AuthnSvc, GetKeyFn, Arg);
1426 
1427  HeapFree(GetProcessHeap(), 0, principal_name);
1428  return status;
1429 }
RPC_STATUS WINAPI RpcServerRegisterAuthInfoW(RPC_WSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, LPVOID Arg)
Definition: rpc_server.c:1434
long RPC_STATUS
Definition: rpc.h:52
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPWSTR RPCRT4_strdupAtoW(LPCSTR src)
Definition: rpc_binding.c:69
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:402
Definition: ps.c:97

Referenced by test_RpcServerInqDefaultPrincName().

◆ RpcServerRegisterAuthInfoW()

RPC_STATUS WINAPI RpcServerRegisterAuthInfoW ( RPC_WSTR  ServerPrincName,
ULONG  AuthnSvc,
RPC_AUTH_KEY_RETRIEVAL_FN  GetKeyFn,
LPVOID  Arg 
)

Definition at line 1434 of file rpc_server.c.

1436 {
1437  struct rpc_server_registered_auth_info *auth_info;
1438  SecPkgInfoW *packages, *package;
1440  ULONG max_token;
1442 
1443  TRACE("(%s,%u,%p,%p)\n", debugstr_w(ServerPrincName), AuthnSvc, GetKeyFn, Arg);
1444 
1445  status = find_security_package(AuthnSvc, &packages, &package);
1446  if (status != RPC_S_OK)
1447  return status;
1448 
1449  package_name = RPCRT4_strdupW(package->Name);
1450  max_token = package->cbMaxToken;
1451  FreeContextBuffer(packages);
1452  if (!package_name)
1453  return RPC_S_OUT_OF_RESOURCES;
1454 
1455  auth_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*auth_info));
1456  if (!auth_info) {
1458  return RPC_S_OUT_OF_RESOURCES;
1459  }
1460 
1461  if (ServerPrincName && !(auth_info->principal = RPCRT4_strdupW(ServerPrincName))) {
1463  HeapFree(GetProcessHeap(), 0, auth_info);
1464  return RPC_S_OUT_OF_RESOURCES;
1465  }
1466 
1467  auth_info->auth_type = AuthnSvc;
1468  auth_info->package_name = package_name;
1469  auth_info->max_token = max_token;
1470 
1474 
1475  return RPC_S_OK;
1476 }
SECURITY_STATUS WINAPI FreeContextBuffer(PVOID pv)
Definition: sspi.c:699
static CRITICAL_SECTION server_auth_info_cs
Definition: rpc_server.c:90
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
long RPC_STATUS
Definition: rpc.h:52
ULONG cbMaxToken
Definition: sspi.h:104
#define debugstr_w
Definition: kernel32.h:32
SEC_WCHAR * Name
Definition: sspi.h:105
static struct list server_registered_auth_info
Definition: rpc_server.c:70
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
unsigned int ULONG
Definition: retypes.h:1
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
#define RPCRT4_strdupW(x)
Definition: rpc_binding.h:152
static SERVICE_STATUS status
Definition: service.c:31
static RPC_STATUS find_security_package(ULONG auth_type, SecPkgInfoW **packages_buf, SecPkgInfoW **ret)
Definition: rpc_server.c:1334
#define HeapFree(x, y, z)
Definition: compat.h:402
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RpcServerRegisterAuthInfoA(), and test_RpcServerRegisterAuthInfo().

◆ RpcServerRegisterIf()

RPC_STATUS WINAPI RpcServerRegisterIf ( RPC_IF_HANDLE  IfSpec,
UUID MgrTypeUuid,
RPC_MGR_EPV MgrEpv 
)

Definition at line 1116 of file rpc_server.c.

1117 {
1118  TRACE("(%p,%s,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv);
1119  return RpcServerRegisterIf3( IfSpec, MgrTypeUuid, MgrEpv, 0, RPC_C_LISTEN_MAX_CALLS_DEFAULT, (UINT)-1, NULL, NULL );
1120 }
#define RPC_C_LISTEN_MAX_CALLS_DEFAULT
Definition: rpcdce.h:122
smooth NULL
Definition: ftsmooth.c:416
#define debugstr_guid
Definition: kernel32.h:35
#define TRACE(s)
Definition: solgame.cpp:4
unsigned int UINT
Definition: ndis.h:50
RPC_STATUS WINAPI RpcServerRegisterIf3(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv, UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN *IfCallbackFn, void *SecurityDescriptor)
Definition: rpc_server.c:1144

Referenced by DsSetupInit(), LrpcThreadProc(), LsarStartRpcServer(), main(), RpcpAddInterface(), RpcServerThread(), RPCSS_Initialize(), RpcThreadRoutine(), run_server(), SampStartRpcServer(), ScmStartRpcServer(), server(), StartRpcServer(), test_endpoint_mapper(), test_ndr_buffer(), test_rpc_ncacn_ip_tcp(), and test_server_listening().

◆ RpcServerRegisterIf2()

RPC_STATUS WINAPI RpcServerRegisterIf2 ( RPC_IF_HANDLE  IfSpec,
UUID MgrTypeUuid,
RPC_MGR_EPV MgrEpv,
UINT  Flags,
UINT  MaxCalls,
UINT  MaxRpcSize,
RPC_IF_CALLBACK_FN IfCallbackFn 
)

Definition at line 1135 of file rpc_server.c.

1137 {
1138  return RpcServerRegisterIf3( IfSpec, MgrTypeUuid, MgrEpv, Flags, MaxCalls, MaxRpcSize, IfCallbackFn, NULL );
1139 }
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
smooth NULL
Definition: ftsmooth.c:416
RPC_STATUS WINAPI RpcServerRegisterIf3(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv, UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN *IfCallbackFn, void *SecurityDescriptor)
Definition: rpc_server.c:1144

◆ RpcServerRegisterIf3()

RPC_STATUS WINAPI RpcServerRegisterIf3 ( RPC_IF_HANDLE  IfSpec,
UUID MgrTypeUuid,
RPC_MGR_EPV MgrEpv,
UINT  Flags,
UINT  MaxCalls,
UINT  MaxRpcSize,
RPC_IF_CALLBACK_FN IfCallbackFn,
void SecurityDescriptor 
)

Definition at line 1144 of file rpc_server.c.

1146 {
1147  PRPC_SERVER_INTERFACE If = IfSpec;
1148  RpcServerInterface* sif;
1149  unsigned int i;
1150 
1151  TRACE("(%p,%s,%p,%u,%u,%u,%p,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv, Flags, MaxCalls,
1152  MaxRpcSize, IfCallbackFn, SecurityDescriptor);
1153 
1154  if (SecurityDescriptor)
1155  FIXME("Unsupported SecurityDescriptor argument.\n");
1156 
1157  TRACE(" interface id: %s %d.%d\n", debugstr_guid(&If->InterfaceId.SyntaxGUID),
1160  TRACE(" transfer syntax: %s %d.%d\n", debugstr_guid(&If->TransferSyntax.SyntaxGUID),
1163  TRACE(" dispatch table: %p\n", If->DispatchTable);
1164  if (If->DispatchTable) {
1165  TRACE(" dispatch table count: %d\n", If->DispatchTable->DispatchTableCount);
1166  for (i=0; i<If->DispatchTable->DispatchTableCount; i++) {
1167  TRACE(" entry %d: %p\n", i, If->DispatchTable->DispatchTable[i]);
1168  }
1169  TRACE(" reserved: %ld\n", If->DispatchTable->Reserved);
1170  }
1171  TRACE(" protseq endpoint count: %d\n", If->RpcProtseqEndpointCount);
1172  TRACE(" default manager epv: %p\n", If->DefaultManagerEpv);
1173  TRACE(" interpreter info: %p\n", If->InterpreterInfo);
1174 
1176  sif->If = If;
1177  if (MgrTypeUuid) {
1178  sif->MgrTypeUuid = *MgrTypeUuid;
1179  sif->MgrEpv = MgrEpv;
1180  } else {
1181  memset(&sif->MgrTypeUuid, 0, sizeof(UUID));
1182  sif->MgrEpv = If->DefaultManagerEpv;
1183  }
1184  sif->Flags = Flags;
1185  sif->MaxCalls = MaxCalls;
1186  sif->MaxRpcSize = MaxRpcSize;
1187  sif->IfCallbackFn = IfCallbackFn;
1188 
1192 
1193  if (sif->Flags & RPC_IF_AUTOLISTEN)
1195 
1196  return RPC_S_OK;
1197 }
void const * InterpreterInfo
Definition: rpcdcep.h:110
#define TRUE
Definition: types.h:120
PRPC_DISPATCH_TABLE DispatchTable
Definition: rpcdcep.h:106
unsigned short MajorVersion
Definition: rpcdcep.h:27
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
Definition: list.h:96
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define RPC_IF_AUTOLISTEN
Definition: rpcdce.h:313
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
RPC_DISPATCH_FUNCTION * DispatchTable
Definition: rpcdcep.h:88
RPC_SYNTAX_IDENTIFIER InterfaceId
Definition: rpcdcep.h:104
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FIXME(fmt,...)
Definition: debug.h:110
RPC_MGR_EPV * DefaultManagerEpv
Definition: rpcdcep.h:109
RPC_IF_CALLBACK_FN * IfCallbackFn
Definition: rpc_server.h:72
unsigned int DispatchTableCount
Definition: rpcdcep.h:87
RPC_VERSION SyntaxVersion
Definition: rpcdcep.h:33
#define debugstr_guid
Definition: kernel32.h:35
RPC_SYNTAX_IDENTIFIER TransferSyntax
Definition: rpcdcep.h:105
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
RPC_MGR_EPV * MgrEpv
Definition: rpc_server.h:68
struct list entry
Definition: rpc_server.h:65
LONG_PTR Reserved
Definition: rpcdcep.h:89
unsigned short MinorVersion
Definition: rpcdcep.h:28
RPC_SERVER_INTERFACE * If
Definition: rpc_server.h:66
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
static struct list server_interfaces
Definition: rpc_server.c:69
static RPC_STATUS RPCRT4_start_listen(BOOL auto_listen)
Definition: rpc_server.c:741
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
#define memset(x, y, z)
Definition: compat.h:39
#define RPC_S_OK
Definition: rpcnterr.h:22
unsigned int RpcProtseqEndpointCount
Definition: rpcdcep.h:107

Referenced by RpcServerRegisterIf(), RpcServerRegisterIf2(), and RpcServerRegisterIfEx().

◆ RpcServerRegisterIfEx()

RPC_STATUS WINAPI RpcServerRegisterIfEx ( RPC_IF_HANDLE  IfSpec,
UUID MgrTypeUuid,
RPC_MGR_EPV MgrEpv,
UINT  Flags,
UINT  MaxCalls,
RPC_IF_CALLBACK_FN IfCallbackFn 
)

Definition at line 1125 of file rpc_server.c.

1127 {
1128  TRACE("(%p,%s,%p,%u,%u,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv, Flags, MaxCalls, IfCallbackFn);
1129  return RpcServerRegisterIf3( IfSpec, MgrTypeUuid, MgrEpv, Flags, MaxCalls, (UINT)-1, IfCallbackFn, NULL );
1130 }
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
smooth NULL
Definition: ftsmooth.c:416
#define debugstr_guid
Definition: kernel32.h:35
#define TRACE(s)
Definition: solgame.cpp:4
unsigned int UINT
Definition: ndis.h:50
RPC_STATUS WINAPI RpcServerRegisterIf3(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv, UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN *IfCallbackFn, void *SecurityDescriptor)
Definition: rpc_server.c:1144

Referenced by RPC_RegisterInterface().

◆ RpcServerUnregisterIf()

RPC_STATUS WINAPI RpcServerUnregisterIf ( RPC_IF_HANDLE  IfSpec,
UUID MgrTypeUuid,
UINT  WaitForCallsToComplete 
)

Definition at line 1202 of file rpc_server.c.

1203 {
1204  PRPC_SERVER_INTERFACE If = IfSpec;
1205  HANDLE event = NULL;
1206  BOOL found = FALSE;
1207  BOOL completed = TRUE;
1208  RpcServerInterface *cif;
1210 
1211  TRACE("(IfSpec == (RPC_IF_HANDLE)^%p (%s), MgrTypeUuid == %s, WaitForCallsToComplete == %u)\n",
1212  IfSpec, debugstr_guid(&If->InterfaceId.SyntaxGUID), debugstr_guid(MgrTypeUuid), WaitForCallsToComplete);
1213 
1216  if (((!IfSpec && !(cif->Flags & RPC_IF_AUTOLISTEN)) ||
1217  (IfSpec && !memcmp(&If->InterfaceId, &cif->If->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER)))) &&
1218  UuidEqual(MgrTypeUuid, &cif->MgrTypeUuid, &status)) {
1219  list_remove(&cif->entry);
1220  TRACE("unregistering cif %p\n", cif);
1221  if (cif->CurrentCalls) {
1222  completed = FALSE;
1223  cif->Delete = TRUE;
1224  if (WaitForCallsToComplete)
1225  cif->CallsCompletedEvent = event = CreateEventW(NULL, FALSE, FALSE, NULL);
1226  }
1227  found = TRUE;
1228  break;
1229  }
1230  }
1232 
1233  if (!found) {
1234  ERR("not found for object %s\n", debugstr_guid(MgrTypeUuid));
1235  return RPC_S_UNKNOWN_IF;
1236  }
1237 
1238  if (completed)
1239  HeapFree(GetProcessHeap(), 0, cif);
1240  else if (event) {
1241  /* sif will be freed when the last call is completed, so be careful not to
1242  * touch that memory here as that could happen before we get here */
1244  CloseHandle(event);
1245  }
1246 
1247  return RPC_S_OK;
1248 }
#define RPC_S_UNKNOWN_IF
Definition: winerror.h:1028
#define TRUE
Definition: types.h:120
#define CloseHandle
Definition: compat.h:406
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
Definition: rpcrt4_main.c:250
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define RPC_IF_AUTOLISTEN
Definition: rpcdce.h:313
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
RPC_SYNTAX_IDENTIFIER InterfaceId
Definition: rpcdcep.h:104
long RPC_STATUS
Definition: rpc.h:52
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
HANDLE CallsCompletedEvent
Definition: rpc_server.h:76
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
#define debugstr_guid
Definition: kernel32.h:35
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:403
struct list entry
Definition: rpc_server.h:65
uint32_t entry
Definition: isohybrid.c:63
struct _cl_event * event
Definition: glext.h:7739
RPC_SERVER_INTERFACE * If
Definition: rpc_server.h:66
#define ERR(fmt,...)
Definition: debug.h:109
static struct list server_interfaces
Definition: rpc_server.c:69
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
#define INFINITE
Definition: serial.h:102
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:402
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RPC_UnregisterInterface(), RpcpStopRpcServer(), RPCSS_Initialize(), s_stop(), s_stop_autolisten(), server(), service_handler(), test_endpoint_mapper(), test_ndr_buffer(), and test_rpc_ncacn_ip_tcp().

◆ RpcServerUnregisterIfEx()

RPC_STATUS WINAPI RpcServerUnregisterIfEx ( RPC_IF_HANDLE  IfSpec,
UUID MgrTypeUuid,
int  RundownContextHandles 
)

Definition at line 1253 of file rpc_server.c.

1254 {
1255  FIXME("(IfSpec == (RPC_IF_HANDLE)^%p, MgrTypeUuid == %s, RundownContextHandles == %d): stub\n",
1256  IfSpec, debugstr_guid(MgrTypeUuid), RundownContextHandles);
1257 
1258  return RPC_S_OK;
1259 }
#define FIXME(fmt,...)
Definition: debug.h:110
#define debugstr_guid
Definition: kernel32.h:35
#define RPC_S_OK
Definition: rpcnterr.h:22

Referenced by RpcpStopRpcServerEx().

◆ RpcServerUseProtseqA()

RPC_STATUS WINAPI RpcServerUseProtseqA ( RPC_CSTR  Protseq,
unsigned int  MaxCalls,
void SecurityDescriptor 
)

Definition at line 1060 of file rpc_server.c.

1061 {
1063  RpcServerProtseq* ps;
1064 
1065  TRACE("(Protseq == %s, MaxCalls == %d, SecurityDescriptor == ^%p)\n", debugstr_a((char*)Protseq), MaxCalls, SecurityDescriptor);
1066 
1067  status = RPCRT4_get_or_create_serverprotseq(MaxCalls, (const char *)Protseq, &ps);
1068  if (status != RPC_S_OK)
1069  return status;
1070 
1071  return RPCRT4_use_protseq(ps, NULL);
1072 }
static RPC_STATUS RPCRT4_get_or_create_serverprotseq(UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
Definition: rpc_server.c:987
static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq *ps, const char *endpoint)
Definition: rpc_server.c:832
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
long RPC_STATUS
Definition: rpc.h:52
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by test_RpcServerUseProtseq().

◆ RpcServerUseProtseqEpA()

RPC_STATUS WINAPI RpcServerUseProtseqEpA ( RPC_CSTR  Protseq,
UINT  MaxCalls,
RPC_CSTR  Endpoint,
LPVOID  SecurityDescriptor 
)

Definition at line 910 of file rpc_server.c.

911 {
912  RPC_POLICY policy;
913 
914  TRACE( "(%s,%u,%s,%p)\n", Protseq, MaxCalls, Endpoint, SecurityDescriptor );
915 
916  /* This should provide the default behaviour */
917  policy.Length = sizeof( policy );
918  policy.EndpointFlags = 0;
919  policy.NICFlags = 0;
920 
921  return RpcServerUseProtseqEpExA( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
922 }
RPC_STATUS WINAPI RpcServerUseProtseqEpExA(RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor, PRPC_POLICY lpPolicy)
Definition: rpc_server.c:1013
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
ULONG NICFlags
Definition: rpcdce.h:218
unsigned int Length
Definition: rpcdce.h:216
#define TRACE(s)
Definition: solgame.cpp:4
ULONG EndpointFlags
Definition: rpcdce.h:217

Referenced by run_server(), server(), test_ndr_buffer(), test_rpc_ncacn_ip_tcp(), test_RpcServerUseProtseq(), and test_server_listening().

◆ RpcServerUseProtseqEpExA()

RPC_STATUS WINAPI RpcServerUseProtseqEpExA ( RPC_CSTR  Protseq,
UINT  MaxCalls,
RPC_CSTR  Endpoint,
LPVOID  SecurityDescriptor,
PRPC_POLICY  lpPolicy 
)

Definition at line 1013 of file rpc_server.c.

1015 {
1016  RpcServerProtseq* ps;
1018 
1019  TRACE("(%s,%u,%s,%p,{%u,%u,%u})\n", debugstr_a((const char *)Protseq),
1020  MaxCalls, debugstr_a((const char *)Endpoint), SecurityDescriptor,
1021  lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
1022 
1023  status = RPCRT4_get_or_create_serverprotseq(MaxCalls, (const char *)Protseq, &ps);
1024  if (status != RPC_S_OK)
1025  return status;
1026 
1027  return RPCRT4_use_protseq(ps, (const char *)Endpoint);
1028 }
static RPC_STATUS RPCRT4_get_or_create_serverprotseq(UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
Definition: rpc_server.c:987
static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq *ps, const char *endpoint)
Definition: rpc_server.c:832
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
ULONG NICFlags
Definition: rpcdce.h:218
unsigned int Length
Definition: rpcdce.h:216
long RPC_STATUS
Definition: rpc.h:52
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
ULONG EndpointFlags
Definition: rpcdce.h:217
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RpcServerUseProtseqEpA().

◆ RpcServerUseProtseqEpExW()

RPC_STATUS WINAPI RpcServerUseProtseqEpExW ( RPC_WSTR  Protseq,
UINT  MaxCalls,
RPC_WSTR  Endpoint,
LPVOID  SecurityDescriptor,
PRPC_POLICY  lpPolicy 
)

Definition at line 1033 of file rpc_server.c.

1035 {
1036  RpcServerProtseq* ps;
1038  LPSTR ProtseqA;
1039  LPSTR EndpointA;
1040 
1041  TRACE("(%s,%u,%s,%p,{%u,%u,%u})\n", debugstr_w( Protseq ), MaxCalls,
1042  debugstr_w( Endpoint ), SecurityDescriptor,
1043  lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
1044 
1045  ProtseqA = RPCRT4_strdupWtoA(Protseq);
1046  status = RPCRT4_get_or_create_serverprotseq(MaxCalls, ProtseqA, &ps);
1047  RPCRT4_strfree(ProtseqA);
1048  if (status != RPC_S_OK)
1049  return status;
1050 
1051  EndpointA = RPCRT4_strdupWtoA(Endpoint);
1052  status = RPCRT4_use_protseq(ps, EndpointA);
1053  RPCRT4_strfree(EndpointA);
1054  return status;
1055 }
static RPC_STATUS RPCRT4_get_or_create_serverprotseq(UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
Definition: rpc_server.c:987
static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq *ps, const char *endpoint)
Definition: rpc_server.c:832
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
ULONG NICFlags
Definition: rpcdce.h:218
char * LPSTR
Definition: xmlstorage.h:182
unsigned int Length
Definition: rpcdce.h:216
LPSTR RPCRT4_strdupWtoA(LPCWSTR src)
Definition: rpc_binding.c:58
long RPC_STATUS
Definition: rpc.h:52
void RPCRT4_strfree(LPSTR src)
Definition: rpc_binding.c:104
#define debugstr_w
Definition: kernel32.h:32
#define TRACE(s)
Definition: solgame.cpp:4
ULONG EndpointFlags
Definition: rpcdce.h:217
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by RpcServerUseProtseqEpW().

◆ RpcServerUseProtseqEpW()

RPC_STATUS WINAPI RpcServerUseProtseqEpW ( RPC_WSTR  Protseq,
UINT  MaxCalls,
RPC_WSTR  Endpoint,
LPVOID  SecurityDescriptor 
)

Definition at line 927 of file rpc_server.c.

928 {
929  RPC_POLICY policy;
930 
931  TRACE( "(%s,%u,%s,%p)\n", debugstr_w( Protseq ), MaxCalls, debugstr_w( Endpoint ), SecurityDescriptor );
932 
933  /* This should provide the default behaviour */
934  policy.Length = sizeof( policy );
935  policy.EndpointFlags = 0;
936  policy.NICFlags = 0;
937 
938  return RpcServerUseProtseqEpExW( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
939 }
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
ULONG NICFlags
Definition: rpcdce.h:218
unsigned int Length
Definition: rpcdce.h:216
RPC_STATUS WINAPI RpcServerUseProtseqEpExW(RPC_WSTR Protseq, UINT MaxCalls, RPC_WSTR Endpoint, LPVOID SecurityDescriptor, PRPC_POLICY lpPolicy)
Definition: rpc_server.c:1033
#define debugstr_w
Definition: kernel32.h:32
#define TRACE(s)
Definition: solgame.cpp:4
ULONG EndpointFlags
Definition: rpcdce.h:217

Referenced by LrpcThreadProc(), LsarStartRpcServer(), RPC_StartRemoting(), RpcpAddInterface(), RpcServerThread(), RPCSS_Initialize(), RpcThreadRoutine(), SampStartRpcServer(), ScmStartRpcServer(), and StartRpcServer().

◆ RpcServerUseProtseqW()

RPC_STATUS WINAPI RpcServerUseProtseqW ( RPC_WSTR  Protseq,
unsigned int  MaxCalls,
void SecurityDescriptor 
)

Definition at line 1077 of file rpc_server.c.

1078 {
1080  RpcServerProtseq* ps;
1081  LPSTR ProtseqA;
1082 
1083  TRACE("Protseq == %s, MaxCalls == %d, SecurityDescriptor == ^%p)\n", debugstr_w(Protseq), MaxCalls, SecurityDescriptor);
1084 
1085  ProtseqA = RPCRT4_strdupWtoA(Protseq);
1086  status = RPCRT4_get_or_create_serverprotseq(MaxCalls, ProtseqA, &ps);
1087  RPCRT4_strfree(ProtseqA);
1088  if (status != RPC_S_OK)
1089  return status;
1090 
1091  return RPCRT4_use_protseq(ps, NULL);
1092 }
static RPC_STATUS RPCRT4_get_or_create_serverprotseq(UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
Definition: rpc_server.c:987
static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq *ps, const char *endpoint)
Definition: rpc_server.c:832
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
char * LPSTR
Definition: xmlstorage.h:182
LPSTR RPCRT4_strdupWtoA(LPCWSTR src)
Definition: rpc_binding.c:58
long RPC_STATUS
Definition: rpc.h:52
void RPCRT4_strfree(LPSTR src)
Definition: rpc_binding.c:104
#define debugstr_w
Definition: kernel32.h:32
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( rpc  )

Variable Documentation

◆ listen_count

LONG listen_count
static

◆ listen_cs

◆ listen_cs_debug

CRITICAL_SECTION_DEBUG listen_cs_debug
static
Initial value:
=
{
0, 0, &listen_cs,
0, 0, { (DWORD_PTR)(__FILE__ ": listen_cs") }
}
#define DWORD_PTR
Definition: treelist.c:76
static CRITICAL_SECTION_DEBUG listen_cs_debug
Definition: rpc_server.c:82
static CRITICAL_SECTION listen_cs
Definition: rpc_server.c:81
LIST_ENTRY ProcessLocksList
Definition: winbase.h:855

Definition at line 82 of file rpc_server.c.

◆ listen_done_event

HANDLE listen_done_event
static

◆ protseqs

◆ RpcObjTypeMaps

RpcObjTypeMap* RpcObjTypeMaps
static

Definition at line 65 of file rpc_server.c.

Referenced by LookupObjTypeMap(), and RpcObjectSetType().

◆ server_auth_info_cs

static CRITICAL_SECTION server_auth_info_cs = { &server_auth_info_cs_debug, -1, 0, 0, 0, 0 }
static

◆ server_auth_info_cs_debug

CRITICAL_SECTION_DEBUG server_auth_info_cs_debug
static
Initial value:
=
{
0, 0, { (DWORD_PTR)(__FILE__ ": server_auth_info_cs") }
}
#define DWORD_PTR
Definition: treelist.c:76
static CRITICAL_SECTION server_auth_info_cs
Definition: rpc_server.c:90
static CRITICAL_SECTION_DEBUG server_auth_info_cs_debug
Definition: rpc_server.c:91
LIST_ENTRY ProcessLocksList
Definition: winbase.h:855

Definition at line 91 of file rpc_server.c.

◆ server_cs

◆ server_cs_debug

CRITICAL_SECTION_DEBUG server_cs_debug
static
Initial value:
=
{
0, 0, &server_cs,
0, 0, { (DWORD_PTR)(__FILE__ ": server_cs") }
}
#define DWORD_PTR
Definition: treelist.c:76
static CRITICAL_SECTION server_cs
Definition: rpc_server.c:72
static CRITICAL_SECTION_DEBUG server_cs_debug
Definition: rpc_server.c:73
LIST_ENTRY ProcessLocksList
Definition: winbase.h:855

Definition at line 73 of file rpc_server.c.

◆ server_interfaces

struct list server_interfaces = LIST_INIT(server_interfaces)
static

Definition at line 69 of file rpc_server.c.

Referenced by RPCRT4_find_interface(), RpcServerRegisterIf3(), and RpcServerUnregisterIf().

◆ server_registered_auth_info

struct list server_registered_auth_info = LIST_INIT(server_registered_auth_info)
static

◆ std_listen

◆ uuid_nil

UUID uuid_nil
static

Definition at line 106 of file rpc_server.c.

Referenced by LookupObjType().