void
s_stop(void)
{
ok(RPC_S_OK == RpcMgmtStopServerListening(NULL), "RpcMgmtStopServerListening\n");
ok(RPC_S_OK == RpcServerUnregisterIf(NULL, NULL, FALSE), "RpcServerUnregisterIf\n");
ok(SetEvent(stop_event), "SetEvent\n");
}
RPC_STATUS
SpoolerStopRpcServer(
VOID
)
/*++
Routine Description:
Deletes the interface.
Arguments:
Return Value:
NERR_Success, or any RPC error codes that can be returned from
RpcServerUnregisterIf.
--*/
{
RPC_STATUS RpcStatus;
RpcStatus = RpcServerUnregisterIf(winspool_ServerIfHandle, 0, 0);
RpcMgmtStopServerListening(0);
RpcMgmtWaitServerListen();
return (RpcStatus);
}
__declspec(dllexport) long UnregisterRpc(
LPWSTR errorMessageBuffer
, int errorMessageBufferLength
)
{
RPC_STATUS lStatus = -1;
// The RpcMgmtStopServerListening function tells a server to stop listening for remote procedure calls.
//
lStatus = RpcMgmtStopServerListening( NULL );
if (0 != lStatus )
{
return lStatus;
}
// The RpcServerUnregisterIf function removes an interface from the RPC run-time library registry.
//
lStatus = RpcServerUnregisterIf( NULL, NULL, TRUE );
if (0 != lStatus )
{
return lStatus;
}
return 0;
}
HRESULT StopServer()
{
RpcServerUnregisterIf( MagoRemoteEvent_v1_0_s_ifspec, NULL, FALSE );
RpcMgmtStopServerListening( NULL );
RpcMgmtWaitServerListen();
return S_OK;
}
//------------------------------------------------------------------
bool AVEngine::CloseRPC()
{
RPC_STATUS status ;
DWORD dwWaitStatus ;
// Wait until thread have terminated.
status = RpcMgmtStopServerListening(NULL);
if (status != RPC_S_OK)
{
return false ;
}
status = RpcServerUnregisterIf(AVEngine_AsyncRPC_v1_0_s_ifspec, NULL, FALSE);
if (status != RPC_S_OK)
{
return false ;
}
dwWaitStatus = WaitForSingleObject(hThread,2000);
if ( dwWaitStatus == WAIT_FAILED || dwWaitStatus == WAIT_TIMEOUT )
{
TerminateThread (hThread ,1);
}
// Close all thread handles and free memory allocation.
CloseHandle(hThread);
return true;
}
DWORD WINAPI AfsAdmSvr_AutoShutdownThread (LPVOID lp)
{
for (;;)
{
AfsAdmSvr_Enter();
BOOL fShutdown = l.fAutoShutdown;
// If there are any clients connected, forcably disconnect any
// that haven't pinged us for too long
//
for (size_t iClient = 0; iClient < l.cClientsAllocated; ++iClient)
{
if (!l.aClients[ iClient ])
continue;
if (l.aClients[ iClient ]->timeLastPing + cminREQ_CLIENT_PING <= AfsAdmSvr_GetCurrentTime())
{
Print (dlCONNECTION, "Client 0x%08lX idle for too long; detaching", l.aClients[ iClient ]);
AfsAdmSvr_DetachClient ((UINT_PTR)l.aClients[ iClient ]);
}
}
// If any operations are in progress, we can't shutdown.
//
if (l.cOperations)
fShutdown = FALSE;
// If any clients are still connected, we can't shutdown.
//
if (l.cClients)
fShutdown = FALSE;
// If we haven't been idle long enough, we can't shutdown
//
if (!l.timeLastIdleStart)
fShutdown = FALSE;
else if (l.timeLastIdleStart + cminAUTO_SHUTDOWN > AfsAdmSvr_GetCurrentTime())
fShutdown = FALSE;
// That's it; can we stop now?
//
if (fShutdown)
{
Print ("Idle for too long; shutting down.");
RpcMgmtStopServerListening (NULL);
AfsAdmSvr_StopCallbackManagers();
}
AfsAdmSvr_Leave();
if (fShutdown)
break;
Sleep (cminAUTO_SHUTDOWN_SLEEP * 60L * 1000L);
}
return 0;
}
void RpcShutdown(void)
{
RpcMgmtStopServerListening(NULL);
if (rpc_ShutdownEvent != NULL) {
thrd_WaitForSingleObject_Event(rpc_ShutdownEvent, INFINITE);
CloseHandle(rpc_ShutdownEvent);
}
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void ShutDown(IN RPC_BINDING_HANDLE hBinding)
{
RPC_STATUS nStatus;
// Tell the server to stop listening for remote procedure calls
_tprintf_s(TEXT("Shutting down the server\n"));
nStatus = RpcMgmtStopServerListening(NULL);
EXIT_IF_FAIL(nStatus, "RpcMgmtStopServerListening");
}
void _BochsRpcServer::Stop()
{
if (!server_shutdown.exchange(true))
{
RpcMgmtStopServerListening(NULL);
RpcServerUnregisterIf(NULL, NULL, FALSE);
SetEvent(WorkingItemReadyEvent.get());
//break the request processing wait
}
}
/* returns false if we discover at the last moment that we
aren't ready to terminate */
BOOL RPCSS_Shutdown(void)
{
RpcMgmtStopServerListening(NULL);
RpcServerUnregisterIf(epm_v3_0_s_ifspec, NULL, TRUE);
RpcServerUnregisterIf(Irot_v0_2_s_ifspec, NULL, TRUE);
CloseHandle(exit_event);
return TRUE;
}
//
// MidiRPC_StopServer
//
// Stops the RPC server so the program can shutdown.
//
void MidiRPC_StopServer()
{
// Local shutdown tasks
ShutdownSDL();
delete song;
song = NULL;
// Stop RPC server
RpcMgmtStopServerListening(NULL);
}
static DWORD WINAPI
ServiceControlHandler(DWORD dwControl,
DWORD dwEventType,
LPVOID lpEventData,
LPVOID lpContext)
{
DPRINT("ServiceControlHandler() called\n");
switch (dwControl)
{
case SERVICE_CONTROL_STOP:
DPRINT(" SERVICE_CONTROL_STOP received\n");
LogfReportEvent(EVENTLOG_INFORMATION_TYPE,
0,
EVENT_EventlogStopped, 0, NULL, 0, NULL);
/* Stop listening to incoming RPC messages */
RpcMgmtStopServerListening(NULL);
UpdateServiceStatus(SERVICE_STOPPED);
return ERROR_SUCCESS;
case SERVICE_CONTROL_PAUSE:
DPRINT(" SERVICE_CONTROL_PAUSE received\n");
UpdateServiceStatus(SERVICE_PAUSED);
return ERROR_SUCCESS;
case SERVICE_CONTROL_CONTINUE:
DPRINT(" SERVICE_CONTROL_CONTINUE received\n");
UpdateServiceStatus(SERVICE_RUNNING);
return ERROR_SUCCESS;
case SERVICE_CONTROL_INTERROGATE:
DPRINT(" SERVICE_CONTROL_INTERROGATE received\n");
SetServiceStatus(ServiceStatusHandle,
&ServiceStatus);
return ERROR_SUCCESS;
case SERVICE_CONTROL_SHUTDOWN:
DPRINT(" SERVICE_CONTROL_SHUTDOWN received\n");
LogfReportEvent(EVENTLOG_INFORMATION_TYPE,
0,
EVENT_EventlogStopped, 0, NULL, 0, NULL);
UpdateServiceStatus(SERVICE_STOPPED);
return ERROR_SUCCESS;
default:
DPRINT1(" Control %lu received\n", dwControl);
return ERROR_CALL_NOT_IMPLEMENTED;
}
}
HRESULT
ShutdownCommon()
{
HRESULT status = RpcMgmtStopServerListening(NULL);
if (status != RPC_S_OK)
{
return status;
}
status = RpcServerUnregisterIf(ServerIChakraJIT_v0_0_s_ifspec, NULL, FALSE);
return status;
}
/* add this function to hellop.c */
void HavokShutdown(void)
{
RPC_STATUS status;
status = RpcMgmtStopServerListening(NULL);
if (status)
return;
status = RpcServerUnregisterIf(NULL, NULL, FALSE);
if (status)
return;
return;
} //end Shutdown
void Shutdown(IN RPC_BINDING_HANDLE hBinding)
{
RPC_STATUS status;
printf_s("Calling RpcMgmtStopServerListening\n");
status = RpcMgmtStopServerListening(NULL);
printf_s("RpcMgmtStopServerListening returned: 0x%x\n", status);
if (status)
exit(status);
printf_s("Calling RpcServerUnregisterIf\n");
status = RpcServerUnregisterIf(NULL, NULL, FALSE);
printf_s("RpcServerUnregisterIf returned 0x%x\n", status);
if (status)
exit(status);
}
bool stop_gdipp_rpc_server()
{
//bool b_ret;
RPC_STATUS rpc_status;
rpc_status = RpcMgmtStopServerListening(NULL);
if (rpc_status != RPC_S_OK)
return false;
//b_ret = rpc_index_shutdown();
//assert(b_ret);
destroy_freetype();
return true;
}
void Shutdown()
{
RPC_STATUS status;
status = RpcMgmtStopServerListening(NULL);
if (status)
{
exit(status);
}
status = RpcServerUnregisterIf(NULL, NULL, FALSE);
if (status)
{
exit(status);
}
}
void Shutdown(DATA_HANDLE_TYPE dh)
{
RPC_STATUS status;
printf_s("Calling RpcMgmtStopServerListening\n");
status = RpcMgmtStopServerListening(NULL);
printf_s("RpcMgmtStopServerListening returned: 0x%x\n", status);
if (status) {
exit(status);
}
printf_s("Calling RpcServerUnregisterIf\n");
status = RpcServerUnregisterIf(NULL, NULL, FALSE);
printf_s("RpcServerUnregisterIf returned 0x%x\n", status);
if (status) {
exit(status);
}
}
static DWORD WINAPI
_ServiceControlHandlerEx(DWORD dwControl, DWORD dwEventType, LPVOID lpEventData, LPVOID lpContext)
{
switch (dwControl)
{
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
_UpdateServiceStatus(SERVICE_STOP_PENDING, 1);
RpcMgmtStopServerListening(NULL);
_UpdateServiceStatus(SERVICE_STOPPED, 0);
return NO_ERROR;
case SERVICE_CONTROL_INTERROGATE:
return NO_ERROR;
default:
return ERROR_CALL_NOT_IMPLEMENTED;
}
}
ULONG
VmDirRpcServerStopListen(
VOID
)
{
ULONG dwError = 0;
/*
MSDN: If the server is not listening, the function fails.
*/
dwError = RpcMgmtStopServerListening(NULL);
if(dwError == NO_ERROR)
{
// if we successfully called RpcMgmtStopServerListening
// wait for rpc calls to complete....
dwError = RpcMgmtWaitServerListen();
}
return dwError;
}
/* called with no locks with translated messages */
LONG APIENTRY MainWndProc(
HWND hWnd,
unsigned int message,
unsigned int wParam,
long lParam)
{
HDC hDC; /* display-context variable */
PAINTSTRUCT ps; /* paint structure */
main_wnd = hWnd;
switch (message) {
case WM_QUERYOPEN:
/* block attempts to open the window */
return 0;
case WM_COMMAND:
/* LOWORD(wParam) is command */
return (DefWindowProc(hWnd, message, wParam, lParam));
case WM_CREATE:
break;
case WM_PAINT:
hDC = BeginPaint (hWnd, &ps);
/* nothing to print, but this clears invalidated rectangle flag */
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
RpcMgmtStopServerListening(NULL);
PostQuitMessage(0);
break;
default:
return (DefWindowProc(hWnd, message, wParam, lParam));
}
return (0);
}
NTSTATUS
NTAPI
RpcpStopRpcServerEx (
_In_ RPC_IF_HANDLE IfSpec
)
{
RPC_STATUS rpcStatus;
/* Unregister the interface */
rpcStatus = RpcServerUnregisterIfEx(IfSpec, NULL, TRUE);
/* Acquire the lock while we dereference the RPC services */
EnterCriticalSection(&RpcpCriticalSection);
if (--RpcpNumInstances == 0)
{
/* All RPC services stopped, rundown the server */
RpcMgmtStopServerListening(NULL);
RpcMgmtWaitServerListen();
}
/* Release the lock and return the unregister result */
LeaveCriticalSection(&RpcpCriticalSection);
return I_RpcMapWin32Status(rpcStatus);
}
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);
}
