BOOL RPCSS_Initialize(void)
{
static unsigned short irot_protseq[] = IROT_PROTSEQ;
static unsigned short irot_endpoint[] = IROT_ENDPOINT;
static unsigned short epm_protseq[] = {'n','c','a','c','n','_','n','p',0};
static unsigned short epm_endpoint[] = {'\\','p','i','p','e','\\','e','p','m','a','p','p','e','r',0};
static unsigned short epm_protseq_lrpc[] = {'n','c','a','l','r','p','c',0};
static unsigned short epm_endpoint_lrpc[] = {'e','p','m','a','p','p','e','r',0};
RPC_STATUS status;
WINE_TRACE("\n");
status = RpcServerRegisterIf(epm_v3_0_s_ifspec, NULL, NULL);
if (status != RPC_S_OK)
return status;
status = RpcServerRegisterIf(Irot_v0_2_s_ifspec, NULL, NULL);
if (status != RPC_S_OK)
{
RpcServerUnregisterIf(epm_v3_0_s_ifspec, NULL, FALSE);
return FALSE;
}
status = RpcServerUseProtseqEpW(epm_protseq, RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
epm_endpoint, NULL);
if (status != RPC_S_OK)
goto fail;
status = RpcServerUseProtseqEpW(epm_protseq_lrpc, RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
epm_endpoint_lrpc, NULL);
if (status != RPC_S_OK)
goto fail;
status = RpcServerUseProtseqEpW(irot_protseq, RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
irot_endpoint, NULL);
if (status != RPC_S_OK)
goto fail;
status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE);
if (status != RPC_S_OK)
goto fail;
#ifndef __REACTOS__
exit_event = __wine_make_process_system();
#else
exit_event = CreateEventW(NULL, FALSE, FALSE, NULL); // never fires
#endif
return TRUE;
fail:
RpcServerUnregisterIf(epm_v3_0_s_ifspec, NULL, FALSE);
RpcServerUnregisterIf(Irot_v0_2_s_ifspec, NULL, FALSE);
return FALSE;
}
/* FUNCTIONS *****************************************************************/
static DWORD WINAPI RpcThreadRoutine(LPVOID lpParameter)
{
RPC_STATUS Status;
Status = RpcServerUseProtseqEpW(L"ncalrpc", 20, L"wlansvc", NULL);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
return 0;
}
Status = RpcServerRegisterIf(wlansvc_interface_v1_0_s_ifspec, NULL, NULL);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerRegisterIf() failed (Status %lx)\n", Status);
return 0;
}
Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, 0);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerListen() failed (Status %lx)\n", Status);
}
DPRINT("RpcServerListen finished\n");
return 0;
}
void main()
{
RPC_STATUS status;
/*
unsigned char * pszProtocolSequence = "ncalrpc";
unsigned char * pszEndpoint = "hello";//"\\pipe\\hello";
*/
unsigned int cMinCalls = 1;
unsigned int fDontWait = FALSE;
status = RpcServerUseProtseqEp((_TCHAR*)L"ncalrpc",
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
(_TCHAR*)L"hello",
NULL);
if (status) exit(status);
status = RpcServerRegisterIf(hello_v1_0_s_ifspec,
NULL,
NULL);
if (status) exit(status);
status = RpcServerListen(cMinCalls,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
fDontWait);
if (status) exit(status);
}
DWORD WINAPI start_gdipp_rpc_server(LPVOID lpParameter)
{
if (process_heap == NULL)
return 1;
//bool b_ret;
RPC_STATUS rpc_status;
scoped_rw_lock::initialize();
server_cache_size = min(config_instance.get_number(L"/gdipp/server/cache_size/text()", server_config::CACHE_SIZE), 24);
glyph_cache_instance.initialize();
initialize_freetype();
//b_ret = rpc_index_initialize();
//if (!b_ret)
// return 1;
rpc_status = RpcServerUseProtseqEpW(reinterpret_cast<RPC_WSTR>(L"ncalrpc"), RPC_C_PROTSEQ_MAX_REQS_DEFAULT, reinterpret_cast<RPC_WSTR>(L"gdipp"), NULL);
if (rpc_status != RPC_S_OK)
return 1;
rpc_status = RpcServerRegisterIf(gdipp_rpc_v1_0_s_ifspec, NULL, NULL);
if (rpc_status != RPC_S_OK)
return 1;
rpc_status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE);
if (rpc_status != RPC_S_OK)
return 1;
rpc_status = RpcMgmtWaitServerListen();
if (rpc_status != RPC_S_OK)
return 1;
return 0;
}
DWORD WINAPI RpcThreadRoutine(LPVOID lpParameter)
{
RPC_STATUS Status;
InitializeListHead(&LogHandleListHead);
Status = RpcServerUseProtseqEpW(L"ncacn_np", 20, L"\\pipe\\EventLog", NULL);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
return 0;
}
Status = RpcServerRegisterIf(eventlog_v0_0_s_ifspec, NULL, NULL);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerRegisterIf() failed (Status %lx)\n", Status);
return 0;
}
Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, FALSE);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerListen() failed (Status %lx)\n", Status);
}
return 0;
}
DWORD WINAPI
LrpcThreadProc(LPVOID lpParameter)
{
RPC_STATUS Status;
Status = RpcServerUseProtseqEpW(L"ncalrpc", 20, L"spoolss", NULL);
if (Status != RPC_S_OK)
{
ERR("RpcServerUseProtseqEpW failed with status %ld!\n", Status);
return 0;
}
Status = RpcServerRegisterIf(winspool_v1_0_s_ifspec, NULL, NULL);
if (Status != RPC_S_OK)
{
ERR("RpcServerRegisterIf failed with status %ld!\n", Status);
return 0;
}
Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, 0);
if (Status != RPC_S_OK)
{
ERR("RpcServerListen() failed with status %ld!\n", Status);
}
return 0;
}
DWORD
WINAPI
RpcThreadRoutine(
LPVOID lpParameter)
{
RPC_STATUS Status;
Status = RpcServerUseProtseqEpW(L"ncacn_np", 20, L"\\pipe\\srvsvc", NULL);
if (Status != RPC_S_OK)
{
ERR("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
return 0;
}
Status = RpcServerRegisterIf(srvsvc_v3_0_s_ifspec, NULL, NULL);
if (Status != RPC_S_OK)
{
ERR("RpcServerRegisterIf() failed (Status %lx)\n", Status);
return 0;
}
Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, FALSE);
if (Status != RPC_S_OK)
{
ERR("RpcServerListen() failed (Status %lx)\n", Status);
}
return 0;
}
//
// RPC Server Init
//
static bool MidiRPC_InitServer()
{
RPC_STATUS status;
// Initialize RPC protocol
status =
RpcServerUseProtseqEp
(
(RPC_CSTR)("ncalrpc"),
RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
(RPC_CSTR)("2d4dc2f9-ce90-4080-8a00-1cb819086970"),
NULL
);
if(status)
return false;
// Register server
status = RpcServerRegisterIf(MidiRPC_v1_0_s_ifspec, NULL, NULL);
if(status)
return false;
// Start listening
status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, FALSE);
return !status;
}
static void
server(void)
{
static unsigned char iptcp[] = "ncacn_ip_tcp";
static unsigned char port[] = PORT;
static unsigned char np[] = "ncacn_np";
static unsigned char pipe[] = PIPE;
RPC_STATUS status, iptcp_status, np_status;
DWORD ret;
iptcp_status = RpcServerUseProtseqEp(iptcp, 20, port, NULL);
ok(iptcp_status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_ip_tcp) failed with status %d\n", iptcp_status);
np_status = RpcServerUseProtseqEp(np, 0, pipe, NULL);
if (np_status == RPC_S_PROTSEQ_NOT_SUPPORTED)
skip("Protocol sequence ncacn_np is not supported\n");
else
ok(np_status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_np) failed with status %d\n", np_status);
if (pRpcServerRegisterIfEx)
{
trace("Using RpcServerRegisterIfEx\n");
status = pRpcServerRegisterIfEx(s_IServer_v0_0_s_ifspec, NULL, NULL,
RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH,
RPC_C_LISTEN_MAX_CALLS_DEFAULT, NULL);
}
else
status = RpcServerRegisterIf(s_IServer_v0_0_s_ifspec, NULL, NULL);
ok(status == RPC_S_OK, "RpcServerRegisterIf failed with status %d\n", status);
status = RpcServerListen(1, 20, TRUE);
ok(status == RPC_S_OK, "RpcServerListen failed with status %d\n", status);
stop_event = CreateEvent(NULL, FALSE, FALSE, NULL);
ok(stop_event != NULL, "CreateEvent failed with error %d\n", GetLastError());
if (iptcp_status == RPC_S_OK)
run_client("tcp_basic");
else
skip("tcp_basic tests skipped due to earlier failure\n");
if (np_status == RPC_S_OK)
run_client("np_basic");
else
{
skip("np_basic tests skipped due to earlier failure\n");
/* np client is what signals stop_event, so bail out if we didn't run do it */
return;
}
ret = WaitForSingleObject(stop_event, 1000);
ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
/* if the stop event didn't fire then RpcMgmtWaitServerListen will wait
* forever, so don't bother calling it in this case */
if (ret == WAIT_OBJECT_0)
{
status = RpcMgmtWaitServerListen();
todo_wine {
ok(status == RPC_S_OK, "RpcMgmtWaitServerListening failed with status %d\n", status);
}
}
void RPCExecutor::Execute()
{
// tempting to throw an exception here
if (!m_callObserver)
{
setExecutionStatus(waInitialiseFailed);
return;
}
if (!m_winamp)
{
m_callObserver->notifyException("winamp implementation is not set");
setExecutionStatus(waInitialiseFailed);
return;
}
std::string str;
RPC_STATUS status;
// "ncacn_np" for named pip
// "ncacn_ip_tcp" for tcpip
m_callObserver->notifyStatus("initialising...");
m_callObserver->notifyMessage(m_winamp->WinampVersion().c_str());
setExecutionStatus(waServerStarting);
status = RpcServerUseProtseqEp((unsigned char *) m_protocolSequence.c_str(),
20,
(unsigned char *) m_endPoint.c_str(),
NULL);
if (status == RPC_S_OK){
status = RpcServerRegisterIf(winamp_v1_0_s_ifspec, NULL, NULL);
if (status == RPC_S_OK){
m_callObserver->notifyMessage("listening...");
setExecutionStatus(waListening);
status = RpcServerListen(1, 20, FALSE);
if (status != RPC_S_OK){
setExecutionStatus(waInitialiseFailed);
m_callObserver->notifyException("error in listening");
m_callObserver->notifyException(RPCError(status));
}
}
else{
setExecutionStatus(waInitialiseFailed);
m_callObserver->notifyException("failed to register interface");
m_callObserver->notifyException(RPCError(status));
m_callObserver->notifyException("initialise failed");
}
}
else{
setExecutionStatus(waInitialiseFailed);
m_callObserver->notifyException("failed to create protocol sequence");
m_callObserver->notifyException(RPCError(status));
m_callObserver->notifyException("initialise failed");
}
setExecutionStatus(waServerStopped);
}
static void test_endpoint_mapper(RPC_CSTR protseq, RPC_CSTR address)
{
static unsigned char annotation[] = "Test annotation string.";
RPC_STATUS status;
RPC_BINDING_VECTOR *binding_vector;
handle_t handle;
unsigned char *binding;
status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
ok(status == RPC_S_OK, "%s: RpcServerRegisterIf failed (%u)\n", protseq, status);
status = RpcServerInqBindings(&binding_vector);
ok(status == RPC_S_OK, "%s: RpcServerInqBindings failed with error %u\n", protseq, status);
/* register endpoints created in test_RpcServerUseProtseq */
status = RpcEpRegisterA(IFoo_v0_0_s_ifspec, binding_vector, NULL, annotation);
ok(status == RPC_S_OK, "%s: RpcEpRegisterA failed with error %u\n", protseq, status);
/* reregister the same endpoint with no annotation */
status = RpcEpRegisterA(IFoo_v0_0_s_ifspec, binding_vector, NULL, NULL);
ok(status == RPC_S_OK, "%s: RpcEpRegisterA failed with error %u\n", protseq, status);
status = RpcStringBindingComposeA(NULL, protseq, address,
NULL, NULL, &binding);
ok(status == RPC_S_OK, "%s: RpcStringBindingCompose failed (%u)\n", protseq, status);
status = RpcBindingFromStringBindingA(binding, &handle);
ok(status == RPC_S_OK, "%s: RpcBindingFromStringBinding failed (%u)\n", protseq, status);
RpcStringFreeA(&binding);
status = RpcBindingReset(handle);
ok(status == RPC_S_OK, "%s: RpcBindingReset failed with error %u\n", protseq, status);
status = RpcEpResolveBinding(handle, IFoo_v0_0_s_ifspec);
ok(status == RPC_S_OK || broken(status == RPC_S_SERVER_UNAVAILABLE), /* win9x */
"%s: RpcEpResolveBinding failed with error %u\n", protseq, status);
status = RpcBindingReset(handle);
ok(status == RPC_S_OK, "%s: RpcBindingReset failed with error %u\n", protseq, status);
status = RpcBindingFree(&handle);
ok(status == RPC_S_OK, "%s: RpcBindingFree failed with error %u\n", protseq, status);
status = RpcServerUnregisterIf(NULL, NULL, FALSE);
ok(status == RPC_S_OK, "%s: RpcServerUnregisterIf failed (%u)\n", protseq, status);
status = RpcEpUnregister(IFoo_v0_0_s_ifspec, binding_vector, NULL);
ok(status == RPC_S_OK, "%s: RpcEpUnregisterA failed with error %u\n", protseq, status);
status = RpcBindingVectorFree(&binding_vector);
ok(status == RPC_S_OK, "%s: RpcBindingVectorFree failed with error %u\n", protseq, status);
}
unsigned int __stdcall CUDA_WRAPPER::WinThreadListener(void * wrapper)
{
CUDA_WRAPPER * cu = (CUDA_WRAPPER *) wrapper;
for (;;)
{
RPC_STATUS status;
// Uses the protocol combined with the endpoint for receiving
// remote procedure calls.
status = RpcServerUseProtseqEp(
(RPC_WSTR)_T("ncacn_ip_tcp"),// Use TCP/IP protocol
RPC_C_PROTSEQ_MAX_REQS_DEFAULT, // Backlog q length for TCP/IP.
(RPC_WSTR)_T("9191"), // TCP/IP port to use.
NULL); // No security.
if(status)
{
_endthreadex(status);
return status;
}
// Registers the DoRPC interface.
status = RpcServerRegisterIf(
DoRPC_v1_0_s_ifspec, // Interface to register.
NULL, // Use the MIDL generated entry-point vector.
NULL); // Use the MIDL generated entry-point vector.
if(status)
{
_endthreadex(status);
return status;
}
// Start to listen for remote procedure calls for all registered interfaces.
// This call will not return until RpcMgmtStopServerListening is called.
status = RpcServerListen(
1, // Recommended minimum number of threads.
RPC_C_LISTEN_MAX_CALLS_DEFAULT, // Recommended maximum number of threads.
FALSE); // Start listening now.
if(status)
{
_endthreadex(status);
return status;
}
}
return 0;
}
NTSTATUS
NTAPI
RpcpAddInterface (
_In_ LPCWSTR IfName,
_In_ RPC_IF_HANDLE IfSpec
)
{
PWCHAR endpointName;
NTSTATUS ntStatus;
RPC_STATUS rpcStatus;
/* Allocate space for the interface name and the \\PIPE\\ prefix */
endpointName = LocalAlloc(0, sizeof(WCHAR) * wcslen(IfName) + 16);
if (endpointName)
{
/* Copy the prefix, and then the interface name */
wcscpy(endpointName, L"\\PIPE\\");
wcscat(endpointName, IfName);
/* Create a named pipe endpoint with this name */
rpcStatus = RpcServerUseProtseqEpW(L"ncacn_np", 10, endpointName, NULL);
if ((rpcStatus != RPC_S_OK) && (rpcStatus != RPC_S_DUPLICATE_ENDPOINT))
{
/* We couldn't create it, or it already existed... */
DbgPrint("RpcServerUseProtseqW failed! rpcstatus = %u\n", rpcStatus);
}
else
{
/* It worked, register an interface on this endpoint now*/
rpcStatus = RpcServerRegisterIf(IfSpec, 0, 0);
}
/* In both success and failure, free the name, and convert the status */
LocalFree(endpointName);
ntStatus = I_RpcMapWin32Status(rpcStatus);
}
else
{
/* No memory, bail out */
ntStatus = STATUS_NO_MEMORY;
}
/* Return back to the caller */
return ntStatus;
}
DWORD WINAPI RpcThreadRoutine(LPVOID lpParameter)
{
RPC_STATUS Status;
InitializeCriticalSection(&LogHandleListCs);
InitializeListHead(&LogHandleListHead);
Status = RpcServerUseProtseqEpW(L"ncacn_np", 20, L"\\pipe\\EventLog", NULL);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
goto Quit;
}
Status = RpcServerRegisterIf(eventlog_v0_0_s_ifspec, NULL, NULL);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerRegisterIf() failed (Status %lx)\n", Status);
goto Quit;
}
Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, FALSE);
if (Status != RPC_S_OK)
{
DPRINT("RpcServerListen() failed (Status %lx)\n", Status);
}
EnterCriticalSection(&LogHandleListCs);
while (!IsListEmpty(&LogHandleListHead))
{
IELF_HANDLE LogHandle = (IELF_HANDLE)CONTAINING_RECORD(LogHandleListHead.Flink, LOGHANDLE, LogHandleListEntry);
ElfDeleteEventLogHandle(&LogHandle);
}
LeaveCriticalSection(&LogHandleListCs);
Quit:
DeleteCriticalSection(&LogHandleListCs);
return 0;
}
bool HavokServer()
{
RPC_STATUS status;
unsigned int cMinCalls = 1;
unsigned int fDontWait = FALSE;
/* 16MB stack per call
status = RpcMgmtSetServerStackSize(16 * 1024 * 1024);
if (status)
return false; */
status = RpcServerUseProtseqEp(pszProtocolSequence,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
pszEndpoint,
pszSecurity);
if (status)
return false;
status = RpcServerRegisterIf(havok_v1_0_s_ifspec,
NULL,
NULL);
if (status)
return false;
status = RpcServerListen(cMinCalls,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
fDontWait);
if (status)
return false;
return true;
}
void RpcListen()
{
RPC_STATUS status;
char *task;
RPC_BINDING_VECTOR *ptrBindingVector = NULL;
BOOLEAN ifaceRegistered = FALSE;
BOOLEAN epRegistered = FALSE;
#ifdef NOOSIDEBUGSERVER /* Use All Protseqs already done in OSI */
status = RpcServerUseAllProtseqs(1, NULL);
if (status != RPC_S_OK) {
task = "Use All Protocol Sequences";
goto cleanup;
}
#endif /* NOOSIDEBUGSERVER */
status = RpcServerRegisterIf(afsrpc_v1_0_s_ifspec, NULL, NULL);
if (status != RPC_S_OK) {
task = "Register Interface";
goto cleanup;
}
ifaceRegistered = TRUE;
status = RpcServerInqBindings(&ptrBindingVector);
if (status != RPC_S_OK) {
task = "Inquire Bindings";
goto cleanup;
}
status = RpcServerRegisterAuthInfo(NULL, RPC_C_AUTHN_WINNT, NULL, NULL);
if (status != RPC_S_OK) {
task = "Register Authentication Info";
goto cleanup;
}
status = RpcEpRegister(afsrpc_v1_0_s_ifspec, ptrBindingVector,
NULL, "AFS session key interface");
if (status != RPC_S_OK) {
task = "Register Endpoints";
goto cleanup;
}
epRegistered = TRUE;
afsi_log("RPC server listening");
status = RpcServerListen(OSI_MAXRPCCALLS, OSI_MAXRPCCALLS, 0);
if (status != RPC_S_OK) {
task = "Server Listen";
}
cleanup:
if (epRegistered)
(void) RpcEpUnregister(afsrpc_v1_0_s_ifspec, ptrBindingVector,
NULL);
if (ptrBindingVector)
(void) RpcBindingVectorFree(&ptrBindingVector);
if (ifaceRegistered)
(void) RpcServerUnregisterIf(afsrpc_v1_0_s_ifspec, NULL, FALSE);
if (status != RPC_S_OK)
afsi_log("RPC problem, code %d for %s", status, task);
else
afsi_log("RPC shutdown");
if (rpc_ShutdownEvent != NULL)
thrd_SetEvent(rpc_ShutdownEvent);
return;
}
RPC_STATUS
SpoolerStartRpcServer(
VOID)
/*++
Routine Description:
Arguments:
Return Value:
NERR_Success, or any RPC error codes that can be returned from
RpcServerUnregisterIf.
--*/
{
unsigned char * InterfaceAddress;
RPC_STATUS status;
PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
BOOL Bool;
HKEY hKey;
DWORD cbData;
DWORD dwSerializeRpc = 0;
DWORD dwType;
InterfaceAddress = "\\pipe\\spoolss";
// Croft up a security descriptor that will grant everyone
// all access to the object (basically, no security)
//
// We do this by putting in a NULL Dacl.
//
// BUGBUG: rpc should copy the security descriptor,
// Since it currently doesn't, simply allocate it for now and
// leave it around forever.
//
SecurityDescriptor = LocalAlloc( LMEM_FIXED, sizeof( SECURITY_DESCRIPTOR ));
if (SecurityDescriptor == 0) {
DBGMSG(DBG_ERROR, ("Spoolss: out of memory\n"));
return FALSE;
}
InitializeSecurityDescriptor( SecurityDescriptor, SECURITY_DESCRIPTOR_REVISION );
Bool = SetSecurityDescriptorDacl (
SecurityDescriptor,
TRUE, // Dacl present
NULL, // NULL Dacl
FALSE // Not defaulted
);
//
// There's no way the above call can fail. But check anyway.
//
if (!Bool) {
DBGMSG(DBG_ERROR, ("Spoolss: SetSecurityDescriptorDacl failed\n"));
return FALSE;
}
//
// For now, ignore the second argument.
//
status = RpcServerUseProtseqEpA("ncacn_np", 10, InterfaceAddress, SecurityDescriptor);
if (status) {
DBGMSG(DBG_ERROR, ("RpcServerUseProtseqEpA = %u\n",status));
return FALSE;
}
//
// For now, ignore the second argument.
//
status = RpcServerUseProtseqEpA("ncalrpc", 10, "spoolss", SecurityDescriptor);
if (status) {
DBGMSG(DBG_ERROR, ("RpcServerUseProtseqEpA = %u\n",status));
return FALSE;
}
//
// Now we need to add the interface. We can just use the winspool_ServerIfHandle
// specified by the MIDL compiler in the stubs (winspl_s.c).
//
status = RpcServerRegisterIf(winspool_ServerIfHandle, 0, 0);
if (status) {
DBGMSG(DBG_ERROR, ("RpcServerRegisterIf = %u\n",status));
return FALSE;
}
if (!RegOpenKeyEx(HKEY_LOCAL_MACHINE,
szPrintKey,
0,
KEY_READ,
&hKey)) {
cbData = sizeof(dwSerializeRpc);
//
// Ignore failure case since we can use the default
//
RegQueryValueEx(hKey,
szSerializeRpc,
NULL,
&dwType,
(LPBYTE)&dwSerializeRpc,
&cbData);
cbData = sizeof(dwCallExitProcessOnShutdown);
//
// This value can be used to control if spooler controls ExitProcess
// on shutdown
//
RegQueryValueEx(hKey,
szCallExitProcessOnShutdown,
NULL,
&dwType,
(LPBYTE)&dwCallExitProcessOnShutdown,
&cbData);
RegCloseKey(hKey);
}
if (dwSerializeRpc) {
// By default, rpc will serialize access to context handles. Since
// the spooler needs to be able to have two threads access a context
// handle at once, and it knows what it is doing, we will tell rpc
// not to serialize access to context handles.
I_RpcSsDontSerializeContext();
}
status = RpcMgmtSetServerStackSize(16384);
if (status != RPC_S_OK) {
DBGMSG(DBG_ERROR, ("Spoolss : RpcMgmtSetServerStackSize = %d\n", status));
}
// The first argument specifies the minimum number of threads to
// create to handle calls; the second argument specifies the maximum
// concurrent calls to handle. The third argument indicates that
// the routine should not wait.
status = RpcServerListen(1,12345,1); // DaveSn was 0
if ( status != RPC_S_OK ) {
DBGMSG(DBG_ERROR, ("Spoolss : RpcServerListen = %d\n", status));
}
return (status);
}
//
// FUNCTION: ServiceStart
//
// PURPOSE: Actual code of the service
// that does the work.
//
// PARAMETERS:
// dwArgc - number of command line arguments
// lpszArgv - array of command line arguments
//
// RETURN VALUE:
// none
//
// COMMENTS:
// Starts the service listening for RPC requests.
//
VOID ServiceStart (HWND NotifyWindow)
{
UINT i;
RPC_BINDING_VECTOR *pbindingVector = 0;
RPC_STATUS status;
BOOL fListening = FALSE;
///////////////////////////////////////////////////
//
// Service initialization
//
//
// Use protocol sequences (protseqs) specified in ProtocolArray.
//
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_STARTING,0,0);
for(i = 0; i < sizeof(ProtocolArray)/sizeof(TCHAR *); i++)
{
status = RpcServerUseProtseq(ProtocolArray[i],
ProtocolBuffer,
0);
if (status == RPC_S_OK)
{
if(NotifyWindow) PostMessage(NotifyWindow,MPM_SERVER_PENDING,0,0);
fListening = TRUE;
}
}
if (!fListening)
{
// Unable to listen to any protocol!
//
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_STOPPED,0,status);
dwErr = status;
return;
}
//
// Register the services interface(s).
//
status = RpcServerRegisterIf(R_MPE_v1_0_s_ifspec,0,0);
if (status != RPC_S_OK) {
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_STOPPED,0,status);
dwErr = status;
hMainThread = 0;
return;
}
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_PENDING,0,0);
// Register interface(s) and binding(s) (endpoints) with
// the endpoint mapper.
//
status = RpcServerInqBindings(&pbindingVector);
if (status != RPC_S_OK) {
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_STOPPED,0,status);
dwErr = status;
hMainThread = 0;
return;
}
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_PENDING,0,0);
status = RpcEpRegister(R_MPE_v1_0_s_ifspec,pbindingVector,0,0);
if (status != RPC_S_OK) {
dwErr = status;
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_STOPPED,0,status);
hMainThread = 0;
return;
}
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_PENDING,0,0);
// Enable NT LM Security Support Provider (NtLmSsp service)
//
status = RpcServerRegisterAuthInfo(0,
RPC_C_AUTHN_WINNT,
0,
0
);
if (status != RPC_S_OK){
dwErr = status;
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_STOPPED,0,status);
hMainThread = 0;
return;
}
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_PENDING,0,0);
// Start accepting client calls.
//
status = RpcServerListen(MinimumThreads,
RPC_C_LISTEN_MAX_CALLS_DEFAULT, // rpcdce.h
TRUE); // don't block.
if (status != RPC_S_OK) {
dwErr = status;
PostMessage(NotifyWindow,MPM_SERVER_STOPPED,0,status);
hMainThread = 0;
return;
}
//
// End of initialization
//
////////////////////////////////////////////////////////////
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_STARTED,0,status);
else
SetEvent(StartEvent);
////////////////////////////////////////////////////////////
//
// Cleanup
//
// RpcMgmtWaitServerListen() will block until the server has
// stopped listening. If this service had something better to
// do with this thread, it would delay this call until
// ServiceStop() had been called. (Set an event in ServiceStop()).
//
status = RpcMgmtWaitServerListen();
if (status != RPC_S_OK) {
dwErr = status;
PostMessage(NotifyWindow,MPM_SERVER_STOPPED,0,status);
hMainThread = 0;
return;
}
NotifyWindow = g_hNotifyWindow;
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_PENDING,0,0);
// ASSERT(status == RPC_S_OK)
status = RpcServerUnregisterIf(R_MPE_v1_0_s_ifspec,0,TRUE);
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_PENDING,0,0);
// Remove entries from the endpoint mapper database.
//
RpcEpUnregister(R_MPE_v1_0_s_ifspec, // from rpcsvc.h
pbindingVector,
0);
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_PENDING,0,0);
// Delete the binding vector
//
status = RpcBindingVectorFree(&pbindingVector);
if(NotifyWindow)
PostMessage(NotifyWindow,MPM_SERVER_STOPPED,0,status);
//
////////////////////////////////////////////////////////////
return;
}
static void test_rpc_ncacn_ip_tcp(void)
{
RPC_STATUS status;
unsigned char *binding, *principal;
handle_t IFoo_IfHandle;
ULONG level, authnsvc, authzsvc;
RPC_AUTH_IDENTITY_HANDLE identity;
static unsigned char foo[] = "foo";
static unsigned char ncacn_ip_tcp[] = "ncacn_ip_tcp";
static unsigned char address[] = "127.0.0.1";
static unsigned char endpoint[] = "4114";
static unsigned char spn[] = "principal";
status = RpcNetworkIsProtseqValidA(foo);
ok(status == RPC_S_INVALID_RPC_PROTSEQ, "return wrong\n");
status = RpcNetworkIsProtseqValidA(ncacn_ip_tcp);
ok(status == RPC_S_OK, "return wrong\n");
status = RpcMgmtStopServerListening(NULL);
todo_wine {
ok(status == RPC_S_NOT_LISTENING,
"wrong RpcMgmtStopServerListening error (%u)\n", status);
}
status = RpcMgmtWaitServerListen();
ok(status == RPC_S_NOT_LISTENING,
"wrong RpcMgmtWaitServerListen error status (%u)\n", status);
status = RpcServerListen(1, 20, FALSE);
ok(status == RPC_S_NO_PROTSEQS_REGISTERED,
"wrong RpcServerListen error (%u)\n", status);
status = RpcServerUseProtseqEpA(ncacn_ip_tcp, 20, endpoint, NULL);
ok(status == RPC_S_OK, "RpcServerUseProtseqEp failed (%u)\n", status);
status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
ok(status == RPC_S_OK, "RpcServerRegisterIf failed (%u)\n", status);
status = RpcServerListen(1, 20, TRUE);
todo_wine {
ok(status == RPC_S_OK, "RpcServerListen failed (%u)\n", status);
}
status = RpcServerListen(1, 20, TRUE);
todo_wine {
ok(status == RPC_S_ALREADY_LISTENING,
"wrong RpcServerListen error (%u)\n", status);
}
status = RpcStringBindingComposeA(NULL, ncacn_ip_tcp, address,
endpoint, NULL, &binding);
ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
status = RpcBindingFromStringBindingA(binding, &IFoo_IfHandle);
ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n",
status);
status = RpcBindingSetAuthInfoA(IFoo_IfHandle, NULL, RPC_C_AUTHN_LEVEL_NONE,
RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NAME);
ok(status == RPC_S_OK, "RpcBindingSetAuthInfo failed (%u)\n", status);
status = RpcBindingInqAuthInfoA(IFoo_IfHandle, NULL, NULL, NULL, NULL, NULL);
ok(status == RPC_S_BINDING_HAS_NO_AUTH, "RpcBindingInqAuthInfo failed (%u)\n",
status);
status = RpcBindingSetAuthInfoA(IFoo_IfHandle, spn, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NAME);
ok(status == RPC_S_OK, "RpcBindingSetAuthInfo failed (%u)\n", status);
level = authnsvc = authzsvc = 0;
principal = (unsigned char *)0xdeadbeef;
identity = (RPC_AUTH_IDENTITY_HANDLE *)0xdeadbeef;
status = RpcBindingInqAuthInfoA(IFoo_IfHandle, &principal, &level, &authnsvc,
&identity, &authzsvc);
ok(status == RPC_S_OK, "RpcBindingInqAuthInfo failed (%u)\n", status);
ok(identity == NULL, "expected NULL identity, got %p\n", identity);
ok(principal != (unsigned char *)0xdeadbeef, "expected valid principal, got %p\n", principal);
ok(level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY, "expected RPC_C_AUTHN_LEVEL_PKT_PRIVACY, got %d\n", level);
ok(authnsvc == RPC_C_AUTHN_WINNT, "expected RPC_C_AUTHN_WINNT, got %d\n", authnsvc);
todo_wine ok(authzsvc == RPC_C_AUTHZ_NAME, "expected RPC_C_AUTHZ_NAME, got %d\n", authzsvc);
if (status == RPC_S_OK) RpcStringFreeA(&principal);
status = RpcMgmtStopServerListening(NULL);
ok(status == RPC_S_OK, "RpcMgmtStopServerListening failed (%u)\n",
status);
status = RpcMgmtStopServerListening(NULL);
ok(status == RPC_S_OK, "RpcMgmtStopServerListening failed (%u)\n",
status);
status = RpcServerUnregisterIf(NULL, NULL, FALSE);
ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%u)\n", status);
status = RpcMgmtWaitServerListen();
todo_wine {
ok(status == RPC_S_OK, "RpcMgmtWaitServerListen failed (%u)\n", status);
}
status = RpcStringFreeA(&binding);
ok(status == RPC_S_OK, "RpcStringFree failed (%u)\n", status);
status = RpcBindingFree(&IFoo_IfHandle);
ok(status == RPC_S_OK, "RpcBindingFree failed (%u)\n", status);
}
