void Module::ResumeServices() { if (_SCManager) { for (size_t i = 0; i != ProximityServicesCount; ++i) { ServiceState& serviceState = _ServiceStateCache[i]; PCWSTR serviceName = ProximityServicesNames[i]; if (!serviceState.ServiceHandle) { // Nothing to do. continue; } // Restore service start type. LOG_COMMENT(L"Restore '%s' service start type.", serviceName); if (!ChangeServiceStartType(serviceState.ServiceHandle, serviceState.StartType)) { LOG_COMMENT(L"Failed to re-enable."); } // Cleanup. CloseServiceHandle(serviceState.ServiceHandle); serviceState.ServiceHandle = nullptr; } // Cleanup. CloseServiceHandle(_SCManager); _SCManager = nullptr; } }
bool Module::StopAndDisableServices() { _SCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (!_SCManager) { return false; } for (size_t i = 0; i != ProximityServicesCount; ++i) { PCWSTR serviceName = ProximityServicesNames[i]; LOG_COMMENT(L"Stopping and disabling service '%s'.", serviceName); SC_HANDLE serviceHandle = OpenService(_SCManager, serviceName, SC_MANAGER_ALL_ACCESS); if (!serviceHandle) { if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) { // Service doesn't exist on this platform. // Just skip it. LOG_COMMENT(L"Service doesn't exist. Skipping."); continue; } return false; } std::unique_ptr<QUERY_SERVICE_CONFIG> serviceConfig; if (!GetServiceConfig(serviceHandle, &serviceConfig)) { CloseServiceHandle(serviceHandle); return false; } if (!ChangeServiceStartType(serviceHandle, SERVICE_DISABLED)) { LOG_COMMENT(L"Failed to disable service."); CloseServiceHandle(serviceHandle); return false; } LOG_COMMENT(L"Disabled service."); if (!StopService(serviceHandle)) { CloseServiceHandle(serviceHandle); return false; } _ServiceStateCache[i].ServiceHandle = serviceHandle; _ServiceStateCache[i].StartType = serviceConfig->dwStartType; } return true; }
bool Module::StopService(_In_ SC_HANDLE serviceHandle) { // Signal service to stop. SERVICE_STATUS serviceStatus; BOOL controlServiceResult = ControlService(serviceHandle, SERVICE_CONTROL_STOP, &serviceStatus); if (!controlServiceResult) { DWORD lastError = GetLastError(); if (lastError != ERROR_SERVICE_NOT_ACTIVE && lastError != ERROR_SERVICE_CANNOT_ACCEPT_CTRL && serviceStatus.dwCurrentState != SERVICE_START_PENDING) { LOG_COMMENT(L"Failed to send service stop command."); return false; } } auto serviceStoppedCallback = [] (void* /*context*/) { }; // Register for service stopped event. SERVICE_NOTIFY serviceNotifyData = {}; serviceNotifyData.dwVersion = SERVICE_NOTIFY_STATUS_CHANGE; serviceNotifyData.pfnNotifyCallback = serviceStoppedCallback; DWORD registerServiceEventResult = NotifyServiceStatusChange(serviceHandle, SERVICE_NOTIFY_STOPPED, &serviceNotifyData); if (registerServiceEventResult != ERROR_SUCCESS) { LOG_COMMENT(L"Failed to subscribe to service stopped event."); return false; } // Wait for event. DWORD sleepResult = SleepEx(/*time(ms)*/ 30000, /*APC*/ TRUE); if (sleepResult == 0) { LOG_COMMENT(L"Service took too long to stop."); return false; } // Cleanup. LOG_COMMENT(L"Service stopped."); return true; }
bool Module::GetServiceConfig( _In_ SC_HANDLE serviceHandle, _Inout_ std::unique_ptr<QUERY_SERVICE_CONFIG>* config) { // Grab the size of the config data. BOOL queryResult; DWORD serviceConfigSize; queryResult = QueryServiceConfig(serviceHandle, NULL, 0, &serviceConfigSize); if (queryResult || GetLastError() != ERROR_INSUFFICIENT_BUFFER || serviceConfigSize < sizeof(QUERY_SERVICE_CONFIG)) { LOG_COMMENT(L"Failed to get service config size."); return false; } // Allocate space for the config data. auto serviceConfigBuffer = reinterpret_cast<QUERY_SERVICE_CONFIG*>(operator new (serviceConfigSize)); auto serviceConfig = std::unique_ptr<QUERY_SERVICE_CONFIG>(serviceConfigBuffer); if (!serviceConfig) { LOG_COMMENT(L"Failed to allocate space for service config."); return false; } // Grab config data. queryResult = QueryServiceConfig(serviceHandle, serviceConfig.get(), serviceConfigSize, &serviceConfigSize); if (!queryResult) { LOG_COMMENT(L"Failed to get service config."); return false; } // Return result. *config = std::move(serviceConfig); LOG_COMMENT(L"Got service config."); return true; }
void max_jit_openni_XMLConfig_read(t_max_jit_openni *x, t_symbol *s, short argc, t_atom *argv) { long i; t_atom OutAtoms[2]; short filePathID; long fileType = 'TEXT', outType; char filename[MAX_FILENAME_CHARS]; char fullyQualifiedPathname[MAX_PATH_CHARS]; XnStatus nRetVal = XN_STATUS_OK; #ifdef _DEBUG t_object *mypatcher; t_symbol *mypatcherpath; if (object_obex_lookup(x, gensym("#P"), &mypatcher) != MAX_ERR_NONE) LOG_ERROR("error getting patcher for jit.openni"); mypatcherpath = object_attr_getsym(mypatcher, gensym("filepath")); if ((mypatcherpath) && (mypatcherpath != gensym(""))) // if I use _sym_nothing rather than gensym("") then I get linker error LNK2001: unresolved external symbol __common_symbols { LOG_COMMENT2("The patcher path is %s", mypatcherpath->s_name); } else { LOG_COMMENT("error getting filepath symbol for max.jit.openni"); return; } #endif if (argc == 0) // if no argument supplied, ask for file { if (open_dialog(filename, &filePathID, &outType, &fileType, 1)) { // non-zero: user cancelled or error LOG_DEBUG("error getting XML config file from dialog box for max.jit.openni"); atom_setsym(OutAtoms, gensym("<none>")); atom_setlong(OutAtoms + 1, 0); max_jit_obex_dumpout(x, gensym("read"), 2, OutAtoms); return; } } else if ((argc != 1) || (atom_gettype(argv) != A_SYM)) { LOG_DEBUG("read must have only one symbol argument"); atom_setsym(OutAtoms, gensym("<none>")); atom_setlong(OutAtoms + 1, 0); max_jit_obex_dumpout(x, gensym("read"), 2, OutAtoms); return; } else // we have exactly one symbol argument { strncpy_zero(filename, atom_getsym(argv)->s_name, MAX_FILENAME_CHARS); if (locatefile_extended(filename, &filePathID, &outType, &fileType, 1)) { LOG_DEBUG2("Could not find file", atom_getsym(argv)->s_name); atom_setsym(OutAtoms, atom_getsym(argv)); atom_setlong(OutAtoms + 1, 0); max_jit_obex_dumpout(x, gensym("read"), 2, OutAtoms); return; } } //Load file atom_setsym(OutAtoms, gensym(filename)); if (path_topathname(filePathID, filename, fullyQualifiedPathname) == 0) { LOG_DEBUG2("asking Jitter object to load file %s", fullyQualifiedPathname); jit_object_method(max_jit_obex_jitob_get(x), gensym("init_from_xml"), gensym(fullyQualifiedPathname), &nRetVal); if (nRetVal) { atom_setlong(OutAtoms + 1, 0); } else { atom_setlong(OutAtoms + 1, 1); } max_jit_obex_dumpout(x, gensym("read"), 2, OutAtoms); } else { atom_setlong(OutAtoms + 1, 0); max_jit_obex_dumpout(x, gensym("read"), 2, OutAtoms); } }