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