static
DWORD
LwSmQueryServiceDependencyClosureHelper(
LW_SERVICE_HANDLE hHandle,
PWSTR** pppwszServiceList
)
{
DWORD dwError = 0;
PLW_SERVICE_INFO pInfo = NULL;
LW_SERVICE_HANDLE hDepHandle = NULL;
PWSTR pwszDepName = NULL;
size_t i = 0;
dwError = LwSmQueryServiceInfo(hHandle, &pInfo);
BAIL_ON_ERROR(dwError);
for (i = 0; pInfo->ppwszDependencies[i]; i++)
{
dwError = LwSmAcquireServiceHandle(pInfo->ppwszDependencies[i], &hDepHandle);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceDependencyClosureHelper(hDepHandle, pppwszServiceList);
BAIL_ON_ERROR(dwError);
if (!LwSmStringListContains(*pppwszServiceList, pInfo->ppwszDependencies[i]))
{
dwError = LwAllocateWc16String(&pwszDepName, pInfo->ppwszDependencies[i]);
BAIL_ON_ERROR(dwError);
dwError = LwSmStringListAppend(pppwszServiceList, pwszDepName);
BAIL_ON_ERROR(dwError);
pwszDepName = NULL;
}
LwSmReleaseServiceHandle(hDepHandle);
hDepHandle = NULL;
}
cleanup:
LW_SAFE_FREE_MEMORY(pwszDepName);
if (pInfo)
{
LwSmCommonFreeServiceInfo(pInfo);
}
if (hDepHandle)
{
LwSmReleaseServiceHandle(hDepHandle);
}
return dwError;
error:
goto cleanup;
}
static
DWORD
LwSmInfo(
int argc,
char** pArgv
)
{
DWORD dwError = 0;
PWSTR pwszServiceName = NULL;
LW_SERVICE_HANDLE hHandle = NULL;
PLW_SERVICE_INFO pInfo = NULL;
PSTR pszTemp = NULL;
size_t i = 0;
dwError = LwMbsToWc16s(pArgv[1], &pwszServiceName);
BAIL_ON_ERROR(dwError);
dwError = LwSmAcquireServiceHandle(pwszServiceName, &hHandle);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceInfo(hHandle, &pInfo);
BAIL_ON_ERROR(dwError);
printf("Service: %s\n", pArgv[1]);
dwError = LwWc16sToMbs(pInfo->pwszDescription, &pszTemp);
BAIL_ON_ERROR(dwError);
printf("Description: %s\n", pszTemp);
LW_SAFE_FREE_MEMORY(pszTemp);
printf("Type: %s\n", LwSmTypeToString(pInfo->type));
printf("Autostart: %s\n", pInfo->bAutostart ? "yes" : "no");
dwError = LwWc16sToMbs(pInfo->pwszPath, &pszTemp);
BAIL_ON_ERROR(dwError);
printf("Path: %s\n", pszTemp);
LW_SAFE_FREE_MEMORY(pszTemp);
printf("Arguments:");
for (i = 0; pInfo->ppwszArgs[i]; i++)
{
dwError = LwWc16sToMbs(pInfo->ppwszArgs[i], &pszTemp);
BAIL_ON_ERROR(dwError);
printf(" '%s'", pszTemp);
LW_SAFE_FREE_MEMORY(pszTemp);
}
printf("\n");
printf("Environment:");
for (i = 0; pInfo->ppwszEnv[i]; i++)
{
dwError = LwWc16sToMbs(pInfo->ppwszEnv[i], &pszTemp);
BAIL_ON_ERROR(dwError);
printf(" '%s'", pszTemp);
LW_SAFE_FREE_MEMORY(pszTemp);
}
printf("\n");
printf("Dependencies:");
for (i = 0; pInfo->ppwszDependencies[i]; i++)
{
dwError = LwWc16sToMbs(pInfo->ppwszDependencies[i], &pszTemp);
BAIL_ON_ERROR(dwError);
printf(" %s", pszTemp);
LW_SAFE_FREE_MEMORY(pszTemp);
}
printf("\n");
dwError = LwWc16sToMbs(pInfo->pwszGroup, &pszTemp);
BAIL_ON_ERROR(dwError);
printf("Service Group: %s\n", pszTemp);
LW_SAFE_FREE_MEMORY(pszTemp);
if (pInfo->dwFdLimit)
{
printf("File descriptor limit: %lu\n", (unsigned long) pInfo->dwFdLimit);
}
else
{
printf("File descriptor limit: inherit\n");
}
if (pInfo->dwCoreSize)
{
printf("Core dump size limit: %lu\n", (unsigned long) pInfo->dwCoreSize);
}
else
{
printf("Core dump size limit: inherit\n");
}
cleanup:
LW_SAFE_FREE_MEMORY(pwszServiceName);
LW_SAFE_FREE_MEMORY(pszTemp);
if (hHandle)
{
LwSmReleaseServiceHandle(hHandle);
}
return dwError;
error:
goto cleanup;
}
static
DWORD
LwSmFindServiceWithPid(
pid_t pid,
PLW_SERVICE_HANDLE phHandle
)
{
DWORD dwError = 0;
PWSTR* ppwszServiceNames = NULL;
DWORD i = 0;
PLW_SERVICE_INFO pInfo = NULL;
LW_SERVICE_HANDLE hHandle = NULL;
LW_SERVICE_STATUS status = {0};
dwError = LwSmEnumerateServices(&ppwszServiceNames);
BAIL_ON_ERROR(dwError);
for (i = 0; ppwszServiceNames[i]; i++)
{
dwError = LwSmAcquireServiceHandle(ppwszServiceNames[i], &hHandle);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceStatus(hHandle, &status);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceInfo(hHandle, &pInfo);
BAIL_ON_ERROR(dwError);
if (status.pid == pid && pInfo->type != LW_SERVICE_TYPE_DRIVER)
{
*phHandle = hHandle;
hHandle = NULL;
goto cleanup;
}
LwSmReleaseServiceHandle(hHandle);
hHandle = NULL;
LwSmFreeServiceInfo(pInfo);
pInfo = NULL;
}
dwError = LW_ERROR_INVALID_PARAMETER;
BAIL_ON_ERROR(dwError);
cleanup:
if (hHandle)
{
LwSmReleaseServiceHandle(hHandle);
}
if (ppwszServiceNames)
{
LwSmFreeServiceNameList(ppwszServiceNames);
}
if (pInfo)
{
LwSmFreeServiceInfo(pInfo);
}
return dwError;
error:
goto cleanup;
}
static
DWORD
LwSmGdb(
int argc,
char** pArgv
)
{
DWORD dwError = 0;
PWSTR pwszServiceName = NULL;
LW_SERVICE_HANDLE hHandle = NULL;
LW_SERVICE_STATUS status = {0};
PLW_SERVICE_INFO pInfo = NULL;
PSTR pszExecutablePath = NULL;
PSTR pszPid = NULL;
dwError = LwMbsToWc16s(pArgv[1], &pwszServiceName);
BAIL_ON_ERROR(dwError);
dwError = LwSmAcquireServiceHandle(pwszServiceName, &hHandle);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceStatus(hHandle, &status);
BAIL_ON_ERROR(dwError);
if (status.state != LW_SERVICE_STATE_RUNNING)
{
dwError = LwSmStart(argc, pArgv);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceStatus(hHandle, &status);
BAIL_ON_ERROR(dwError);
}
dwError = LwSmQueryServiceInfo(hHandle, &pInfo);
BAIL_ON_ERROR(dwError);
if (pInfo->type == LW_SERVICE_TYPE_DRIVER)
{
/* Find non-driver service so we can figure out what to attach to */
LwSmReleaseServiceHandle(hHandle);
hHandle = NULL;
LwSmFreeServiceInfo(pInfo);
pInfo = NULL;
dwError = LwSmFindServiceWithPid(status.pid, &hHandle);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceInfo(hHandle, &pInfo);
if (dwError == LW_ERROR_INVALID_PARAMETER)
{
printf("Service type is not supported\n");
}
BAIL_ON_ERROR(dwError);
}
switch (pInfo->type)
{
case LW_SERVICE_TYPE_EXECUTABLE:
case LW_SERVICE_TYPE_LEGACY_EXECUTABLE:
dwError = LwWc16sToMbs(pInfo->pwszPath, &pszExecutablePath);
BAIL_ON_ERROR(dwError);
break;
case LW_SERVICE_TYPE_MODULE:
dwError = LwAllocateString(SBINDIR "/lwsmd", &pszExecutablePath);
BAIL_ON_ERROR(dwError);
break;
default:
printf("Service type is not supported\n");
break;
}
dwError = LwAllocateStringPrintf(&pszPid, "%lu", (unsigned long) status.pid);
BAIL_ON_ERROR(dwError);
if (execlp("gdb", "gdb", pszExecutablePath, pszPid, NULL) < 0)
{
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_ERROR(dwError);
}
error:
LW_SAFE_FREE_MEMORY(pszPid);
LW_SAFE_FREE_MEMORY(pszExecutablePath);
if (pInfo)
{
LwSmFreeServiceInfo(pInfo);
}
if (hHandle)
{
LwSmReleaseServiceHandle(hHandle);
}
return dwError;
}
static
DWORD
LwSmAutostart(
int argc,
char** pArgv
)
{
DWORD dwError = 0;
PWSTR *ppwszAllServices = NULL;
LW_SERVICE_HANDLE hHandle = NULL;
PLW_SERVICE_INFO pInfo = NULL;
size_t i = 0;
PWSTR *ppwszDependencies = NULL;
LW_SERVICE_HANDLE hDepHandle = NULL;
LW_SERVICE_STATUS status = {0};
PSTR pszTemp = NULL;
size_t j = 0;
dwError = LwSmEnumerateServices(&ppwszAllServices);
BAIL_ON_ERROR(dwError);
for (i = 0; ppwszAllServices[i]; i++)
{
dwError = LwSmAcquireServiceHandle(ppwszAllServices[i], &hHandle);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceInfo(hHandle, &pInfo);
BAIL_ON_ERROR(dwError);
if (pInfo->bAutostart)
{
dwError = LwSmQueryServiceDependencyClosure(
hHandle,
&ppwszDependencies);
BAIL_ON_ERROR(dwError);
for (j = 0; ppwszDependencies[j]; j++)
{
dwError = LwSmAcquireServiceHandle(
ppwszDependencies[j],
&hDepHandle);
BAIL_ON_ERROR(dwError);
dwError = LwSmQueryServiceStatus(hDepHandle, &status);
BAIL_ON_ERROR(dwError);
if (status.state != LW_SERVICE_STATE_RUNNING)
{
if (!gState.bQuiet)
{
dwError = LwWc16sToMbs(ppwszDependencies[j], &pszTemp);
BAIL_ON_ERROR(dwError);
printf("Starting service dependency: %s\n", pszTemp);
LW_SAFE_FREE_MEMORY(pszTemp);
}
dwError = LwSmStartService(hDepHandle);
BAIL_ON_ERROR(dwError);
}
dwError = LwSmReleaseServiceHandle(hDepHandle);
hDepHandle = NULL;
BAIL_ON_ERROR(dwError);
}
if (ppwszDependencies)
{
LwSmFreeServiceNameList(ppwszDependencies);
ppwszDependencies = NULL;
}
if (!gState.bQuiet)
{
dwError = LwWc16sToMbs(ppwszAllServices[i], &pszTemp);
BAIL_ON_ERROR(dwError);
printf("Starting service: %s\n", pszTemp);
LW_SAFE_FREE_MEMORY(pszTemp);
}
dwError = LwSmStartService(hHandle);
BAIL_ON_ERROR(dwError);
}
dwError = LwSmReleaseServiceHandle(hHandle);
hHandle = NULL;
BAIL_ON_ERROR(dwError);
}
cleanup:
if (hHandle)
{
LwSmReleaseServiceHandle(hHandle);
hHandle = NULL;
}
if (ppwszAllServices)
{
LwSmFreeStringList(ppwszAllServices);
ppwszAllServices = NULL;
}
if (ppwszDependencies)
{
LwSmFreeServiceNameList(ppwszDependencies);
ppwszDependencies = NULL;
}
if (hDepHandle)
{
LwSmReleaseServiceHandle(hDepHandle);
hDepHandle = NULL;
}
LW_SAFE_FREE_MEMORY(pszTemp);
return dwError;
error:
goto cleanup;
}
