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); }