static
DWORD
bind_server(
rpc_binding_vector_p_t * server_binding,
rpc_if_handle_t interface_spec,
PENDPOINT pEndPoints
)
{
DWORD dwError = 0;
DWORD dwRpcStatus = 0;
DWORD i;
/*
* Prepare the server binding handle
* use all avail protocols (UDP and TCP). This basically allocates
* new sockets for us and associates the interface UUID and
* object UUID of with those communications endpoints.
*/
for (i = 0; pEndPoints[i].protocol != NULL; i++)
{
if (!pEndPoints[i].endpoint)
{
rpc_server_use_protseq((unsigned char*) pEndPoints[i].protocol,
rpc_c_protseq_max_calls_default,
(unsigned32*)&dwRpcStatus);
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
}
else
{
if (!strcmp(pEndPoints[i].protocol, "ncalrpc") &&
pEndPoints[i].endpoint[0] == '/')
{
dwError = prepare_domain_socket(pEndPoints[i].endpoint);
BAIL_ON_SRVSVC_ERROR(dwError);
}
rpc_server_use_protseq_ep((unsigned char*) pEndPoints[i].protocol,
rpc_c_protseq_max_calls_default,
(unsigned char*) pEndPoints[i].endpoint,
(unsigned32*)&dwRpcStatus);
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
}
}
rpc_server_inq_bindings(server_binding, (unsigned32*)&dwRpcStatus);
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
error:
return dwError;
}
DWORD
LWICheckSecurity(
handle_t hBindingHandle,
ACCESS_MASK dwAccessMask
)
{
DWORD dwError = ERROR_SUCCESS;
volatile unsigned32 rpcError;
PACCESS_TOKEN pUserToken = NULL;
TRY
{
rpc_binding_inq_access_token_caller(
hBindingHandle,
&pUserToken,
(unsigned32*)&rpcError);
}
CATCH_ALL
ENDTRY;
BAIL_ON_DCE_ERROR(dwError, rpcError);
dwError = EVTCheckAllowed(
pUserToken,
dwAccessMask);
BAIL_ON_EVT_ERROR(dwError);
error:
if (pUserToken)
{
RtlReleaseAccessToken(&pUserToken);
}
return dwError;
}
DWORD
WinRegUnregisterForRPC(
rpc_binding_vector_p_t pServerBinding
)
{
volatile DWORD dwError = 0;
volatile DWORD dwRpcStatus = 0;
DCETHREAD_TRY
{
SRVSVC_LOG_INFO("Unregistering server from the endpoint mapper...");
rpc_ep_unregister(winreg_v1_0_s_ifspec,
pServerBinding,
NULL,
(unsigned32*)&dwRpcStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if (dwRpcStatus == RPC_S_OK)
{
dwError = dcethread_exc_getstatus(THIS_CATCH);
if (!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_UNREGISTER;
}
}
}
DCETHREAD_ENDTRY
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
BAIL_ON_SRVSVC_ERROR(dwError);
DCETHREAD_TRY
{
rpc_binding_vector_free(&pServerBinding, (unsigned32*)&dwRpcStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if (dwRpcStatus == RPC_S_OK)
{
dwError = dcethread_exc_getstatus(THIS_CATCH);
if (!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_UNREGISTER;
}
}
}
DCETHREAD_ENDTRY
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
BAIL_ON_SRVSVC_ERROR(dwError);
DCETHREAD_TRY
{
SRVSVC_LOG_INFO("Cleaning up the communications endpoints...");
rpc_server_unregister_if(winreg_v1_0_s_ifspec,
NULL,
(unsigned32*)&dwRpcStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if (dwRpcStatus == RPC_S_OK)
{
dwError = dcethread_exc_getstatus(THIS_CATCH);
if (!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_UNREGISTER;
}
}
}
DCETHREAD_ENDTRY
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
BAIL_ON_SRVSVC_ERROR(dwError);
cleanup:
return dwError;
error:
SRVSVC_LOG_ERROR("Failed to unregister RPC endpoint. Error code [%d]\n", dwError);
goto cleanup;
}
DWORD
WinRegRegisterForRPC(
PSTR pszServiceName,
rpc_binding_vector_p_t* ppServerBinding
)
{
volatile DWORD dwError = 0;
volatile DWORD dwRpcStatus = 0;
rpc_binding_vector_p_t pServerBinding = NULL;
BOOLEAN bRegistered = FALSE;
BOOLEAN bBound = FALSE;
BOOLEAN bEPRegistered = FALSE;
static ENDPOINT endpoints[] =
{
{"ncacn_ip_tcp", NULL},
{"ncacn_np" , "\\\\pipe\\\\winreg"},
{NULL , NULL}
};
DCETHREAD_TRY
{
rpc_server_register_if(winreg_v1_0_s_ifspec,
NULL,
NULL,
(unsigned32*)&dwRpcStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if (dwRpcStatus == RPC_S_OK)
{
dwError = dcethread_exc_getstatus(THIS_CATCH);
if (!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_REGISTER;
}
}
}
DCETHREAD_ENDTRY;
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
BAIL_ON_SRVSVC_ERROR(dwError);
bRegistered = TRUE;
SRVSVC_LOG_INFO("RPC Service registered successfully.");
DCETHREAD_TRY
{
dwError = bind_server(&pServerBinding,
winreg_v1_0_s_ifspec,
endpoints);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if (!dwError)
{
dwError = dcethread_exc_getstatus(THIS_CATCH);
}
if (!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_REGISTER;
}
}
DCETHREAD_ENDTRY;
BAIL_ON_SRVSVC_ERROR(dwError);
bBound = TRUE;
DCETHREAD_TRY
{
rpc_ep_register(winreg_v1_0_s_ifspec,
pServerBinding,
NULL,
(idl_char*)pszServiceName,
(unsigned32*)&dwRpcStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if (dwRpcStatus == RPC_S_OK)
{
dwError = dcethread_exc_getstatus(THIS_CATCH);
if (!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_REGISTER;
}
}
}
DCETHREAD_ENDTRY;
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
BAIL_ON_SRVSVC_ERROR(dwError);
bEPRegistered = TRUE;
SRVSVC_LOG_INFO("RPC Endpoint registered successfully.");
*ppServerBinding = pServerBinding;
cleanup:
return dwError;
error:
SRVSVC_LOG_ERROR("Failed to register RPC endpoint. Error Code: [%u]\n", dwError);
if (bEPRegistered)
{
DCETHREAD_TRY
{
DWORD tmpStatus = 0;
rpc_ep_unregister(winreg_v1_0_s_ifspec,
pServerBinding,
NULL,
(unsigned32*)&tmpStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
DCETHREAD_ENDTRY;
}
if (bBound)
{
DCETHREAD_TRY
{
DWORD tmpStatus = 0;
rpc_binding_vector_free(&pServerBinding,
(unsigned32*)&tmpStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
DCETHREAD_ENDTRY;
}
if (bRegistered)
{
DCETHREAD_TRY
{
DWORD tmpStatus = 0;
rpc_server_unregister_if(winreg_v1_0_s_ifspec,
NULL,
(unsigned32*)&tmpStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
DCETHREAD_ENDTRY;
}
*ppServerBinding = NULL;
goto cleanup;
}
DWORD
LwEvtCreateEventlogRpcBinding(
const char * hostname,
handle_t * event_binding
)
{
DWORD winerror = 0;
DWORD dwError = 0;
const char * protocol;
const char * endpoint;
char * pszBindingString = NULL;
char *hostPrincipal = NULL;
size_t hostPrincipalSize = 0;
int ret = 0;
handle_t eventBinding_local = 0;
BOOLEAN bLocalHost = FALSE;
/* Connect using tcp */
protocol = "ncacn_ip_tcp";
endpoint = NULL;
EVT_LOG_VERBOSE("client::eventlogbinding.c: CreateEventlogRpcBinding() hostname=%s, *event_binding=%.16X\n",
hostname, *event_binding);
RPC_STRING_BINDING_COMPOSE((char*) protocol, (char*) hostname, (char*) endpoint, &pszBindingString, &winerror);
BAIL_ON_DCE_ERROR(dwError, winerror);
if (pszBindingString == NULL || *pszBindingString == '\0') {
BAIL_ON_DCE_ERROR(dwError, RPC_S_INVALID_STRING_BINDING);
}
EVT_LOG_VERBOSE("client::eventlogbinding.c: CreateEventlogRpcBinding() pszBindingString=%s, running rbfsb\n",
pszBindingString);
RPC_BINDING_FROM_STRING_BINDING(pszBindingString, &eventBinding_local, &winerror);
BAIL_ON_DCE_ERROR(dwError, winerror);
EVT_LOG_VERBOSE("client::eventlogbinding.c: CreateEventlogRpcBinding() eventBinding_local=%.16X, finished rbfsb\n",
eventBinding_local);
if (hostname != NULL && !bLocalHost)
{
/* Set up authentication if we are connecting to a remote host */
hostPrincipalSize = strlen(hostname) + 6;
dwError = LwAllocateMemory(hostPrincipalSize, (PVOID*)&hostPrincipal);
BAIL_ON_EVT_ERROR(dwError);
ret = snprintf(hostPrincipal, hostPrincipalSize, "host/%s", hostname);
if (ret < 0 || ret >= hostPrincipalSize) {
BAIL_ON_EVT_ERROR(ERROR_INSUFFICIENT_BUFFER);
}
EVT_LOG_VERBOSE("client::eventlogbinding.c: CreateEventlogRpcBinding() using host principal [%s]\n",
hostPrincipal);
winerror = RpcBindingSetAuthInfo(eventBinding_local,
(unsigned char*)hostPrincipal,
rpc_c_protect_level_pkt_privacy,
rpc_c_authn_gss_negotiate,
NULL,
rpc_c_authz_name);
BAIL_ON_DCE_ERROR(dwError, winerror);
EVT_LOG_VERBOSE("client::eventlogbinding.c: CreateEventlogRpcBinding() eventBinding_local=%.16X, auth info set"
"winerror=0x%08x\n", eventBinding_local, winerror);
}
*event_binding = eventBinding_local;
EVT_LOG_VERBOSE("client::eventlogbinding.c: CreateEventlogRpcBinding() finished successfully\n");
cleanup:
if (hostPrincipal)
{
LwFreeMemory(hostPrincipal);
}
if (pszBindingString)
{
DWORD tempstatus = 0;
RPC_STRING_FREE(&pszBindingString, &tempstatus);
}
return dwError;
error:
EVT_LOG_VERBOSE("client::eventlogbinding.c: CreateEventlogRpcBinding() label error: winerror=%d\n",
winerror);
goto cleanup;
}
DWORD
SrvSvcRegisterForRPC(
PSTR pszServiceName,
rpc_binding_vector_p_t* ppServerBinding
)
{
volatile DWORD dwError = 0;
volatile DWORD dwRpcStatus = 0;
rpc_binding_vector_p_t pServerBinding = NULL;
BOOLEAN bRegistered = FALSE;
BOOLEAN bBound = FALSE;
BOOLEAN bEPRegistered = FALSE;
static ENDPOINT endpoints[] =
{
{"ncacn_np", "\\\\pipe\\\\srvsvc"},
{"ncalrpc", NULL}, // endpoint is fetched from config parameter
{NULL, NULL}, // placeholder for ncacn_ip_tcp (if enabled)
{NULL, NULL}
};
DWORD i = 0;
PSTR lpcSocketPath = NULL;
BOOLEAN registerTcpIp = FALSE;
dwError = SrvSvcConfigGetLpcSocketPath(&lpcSocketPath);
BAIL_ON_SRVSVC_ERROR(dwError);
// Fill in the socket path for local procedure calls (ncalrpc)
while (endpoints[i].protocol) {
if (lpcSocketPath &&
LwRtlCStringIsEqual(endpoints[i].protocol,
"ncalrpc",
TRUE))
{
endpoints[i].endpoint = lpcSocketPath;
}
i++;
}
dwError = SrvSvcConfigGetRegisterTcpIp(®isterTcpIp);
BAIL_ON_SRVSVC_ERROR(dwError);
// Append ncacn_ip_tcp endpoint if it's enabled in the configuration
if (registerTcpIp)
{
endpoints[i++].protocol = "ncacn_ip_tcp";
}
DCETHREAD_TRY
{
rpc_server_register_if (srvsvc_v3_0_s_ifspec,
NULL,
NULL,
(unsigned32*)&dwRpcStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if ( dwRpcStatus == RPC_S_OK )
{
dwError = dcethread_exc_getstatus (THIS_CATCH);
if(!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_REGISTER;
}
}
}
DCETHREAD_ENDTRY;
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
BAIL_ON_SRVSVC_ERROR(dwError);
bRegistered = TRUE;
SRVSVC_LOG_INFO("RPC Service registered successfully.");
DCETHREAD_TRY
{
dwError = bind_server(&pServerBinding,
srvsvc_v3_0_s_ifspec,
endpoints);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if(!dwError)
{
dwError = dcethread_exc_getstatus (THIS_CATCH);
}
if(!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_REGISTER;
}
}
DCETHREAD_ENDTRY;
BAIL_ON_SRVSVC_ERROR(dwError);
bBound = TRUE;
DCETHREAD_TRY
{
rpc_ep_register(srvsvc_v3_0_s_ifspec,
pServerBinding,
NULL,
(idl_char*)pszServiceName,
(unsigned32*)&dwRpcStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if ( dwRpcStatus == RPC_S_OK )
{
dwError = dcethread_exc_getstatus (THIS_CATCH);
if(!dwError)
{
dwError = SRVSVC_ERROR_RPC_EXCEPTION_UPON_REGISTER;
}
}
}
DCETHREAD_ENDTRY;
BAIL_ON_DCE_ERROR(dwError, dwRpcStatus);
BAIL_ON_SRVSVC_ERROR(dwError);
bEPRegistered = TRUE;
SRVSVC_LOG_INFO("RPC Endpoint registered successfully.");
*ppServerBinding = pServerBinding;
cleanup:
// DCE/RPC runtime makes a copy of ncalrpc socket path internally
// so it is safe to free it here
LW_SAFE_FREE_MEMORY(lpcSocketPath);
return dwError;
error:
SRVSVC_LOG_ERROR("Failed to register RPC endpoint. Error Code: [%u]\n", dwError);
if (bEPRegistered)
{
DCETHREAD_TRY
{
DWORD tmpStatus = 0;
rpc_ep_unregister(srvsvc_v3_0_s_ifspec,
pServerBinding,
NULL,
(unsigned32*)&tmpStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
DCETHREAD_ENDTRY;
}
if (bBound) {
DCETHREAD_TRY
{
DWORD tmpStatus = 0;
rpc_binding_vector_free(&pServerBinding,
(unsigned32*)&tmpStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
DCETHREAD_ENDTRY;
}
if (bRegistered)
{
DCETHREAD_TRY
{
DWORD tmpStatus = 0;
rpc_server_unregister_if (srvsvc_v3_0_s_ifspec,
NULL,
(unsigned32*)&tmpStatus);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
DCETHREAD_ENDTRY;
}
*ppServerBinding = NULL;
goto cleanup;
}
