MI_Result EnableShutdownPrivilege(
_In_ HANDLE hToken,
_Outptr_result_maybenull_ MI_Instance **cimErrorDetails)
{
MI_Uint32 dwLen = 0;
BOOL res = TRUE;
BYTE *pBuffer;
TOKEN_USER tu;
TOKEN_PRIVILEGES * pPrivs = NULL;
MI_Uint32 xCount = 0;
if (cimErrorDetails == NULL)
{
return MI_RESULT_INVALID_PARAMETER;
}
*cimErrorDetails = NULL; // Explicitly set *cimErrorDetails to NULL as _Outptr_ requires setting this at least once.
memset(&tu, 0, sizeof(TOKEN_USER));
res = GetTokenInformation(hToken, TokenPrivileges, &tu, sizeof(TOKEN_USER), (PDWORD)&dwLen);
if (!res && ERROR_INSUFFICIENT_BUFFER != GetLastError())
{
return GetCimWin32Error(GetLastError(), cimErrorDetails, ID_LCMHELPER_COMPUTERNAMECONTEXT_ERROR);
}
pBuffer = (BYTE*)DSC_malloc(dwLen, NitsHere());
if (pBuffer == NULL)
{
return GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, cimErrorDetails, ID_LCMHELPER_MEMORY_ERROR);
}
res = GetTokenInformation(hToken, TokenPrivileges, pBuffer, dwLen, (PDWORD)&dwLen);
if (!res && ERROR_INSUFFICIENT_BUFFER != GetLastError())
{
DSC_free(pBuffer);
return GetCimWin32Error(GetLastError(), cimErrorDetails, ID_LCMHELPER_COMPUTERNAMECONTEXT_ERROR);
}
pPrivs = (TOKEN_PRIVILEGES*)(BYTE*)pBuffer;
for (xCount = 0; xCount < pPrivs->PrivilegeCount; xCount++)
{
pPrivs->Privileges[xCount].Attributes |= SE_PRIVILEGE_ENABLED;
}
if (!AdjustTokenPrivileges(hToken, FALSE, pPrivs, 0, NULL, NULL))
{
DSC_free(pBuffer);
return GetCimMIError(MI_RESULT_FAILED, cimErrorDetails, ID_LCMHELPER_COMPUTERNAMECONTEXT_ERROR);
}
DSC_free(pBuffer);
return MI_RESULT_OK;
}
MI_Result ScheduleRestart(
_Outptr_result_maybenull_ MI_Instance **cimErrorDetails)
{
MI_Uint32 dwError = ERROR_SUCCESS;
HANDLE hToken;
MI_Boolean bRevertToSelf = MI_FALSE;
Intlstr intlstr = Intlstr_Null;
MI_Result result = MI_RESULT_OK;
if (cimErrorDetails == NULL)
{
return MI_RESULT_INVALID_PARAMETER;
}
*cimErrorDetails = NULL; // Explicitly set *cimErrorDetails to NULL as _Outptr_ requires setting this at least once.
DSC_EventWriteMessageScheduleReboot();
GetResourceString(ID_LCMHELPER_SHUTDOWN_MESSAGE, &intlstr);
if (!OpenThreadToken(GetCurrentThread(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY | TOKEN_DUPLICATE, TRUE, &hToken))
{
if (GetLastError() == ERROR_NO_TOKEN)
{
SetLastError(ERROR_SUCCESS);
if (!ImpersonateSelf(SecurityImpersonation))
{
return GetCimWin32Error(GetLastError(), cimErrorDetails, ID_LCMHELPER_THREADIMPERSONATION_FAILED);
}
if (!OpenThreadToken(GetCurrentThread(), TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY | TOKEN_DUPLICATE, TRUE, &hToken))
{
RevertToSelf();
return GetCimWin32Error(GetLastError(), cimErrorDetails, ID_LCMHELPER_THREADIMPERSONATION_FAILED);
}
bRevertToSelf = MI_TRUE;
}
else
{
return GetCimWin32Error(GetLastError(), cimErrorDetails, ID_LCMHELPER_THREADIMPERSONATION_FAILED);
}
}
result = EnableShutdownPrivilege(hToken, cimErrorDetails);
if (result != MI_RESULT_OK)
{
if (bRevertToSelf)
{
RevertToSelf();
}
return result;
}
#ifdef _PREFAST_
#pragma prefast (push)
#pragma prefast (disable: 28159) //This is needed to reconfigure windows server to finish configuring the system by DSC.
#endif /* _PREFAST_ */
dwError = InitiateSystemShutdownEx(NULL,
(MI_Char*)intlstr.str,
DSC_REBOOT_GRACEPERIOD,
TRUE,
TRUE,
SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_MINOR_MAINTENANCE | SHTDN_REASON_FLAG_PLANNED);
#ifdef _PREFAST_
#pragma prefast (pop)
#endif /* _PREFAST_ */
if (bRevertToSelf)
{
RevertToSelf();
}
if (intlstr.str )
{
Intlstr_Free(intlstr);
}
if (!dwError)
{
return GetCimWin32Error(GetLastError(), cimErrorDetails, ID_LCMHELPER_SHUTDOWN_FAILED);
}
return MI_RESULT_OK;
}
MI_Result RegisterStartAtBootTask(
_In_ MI_Boolean bregisterTask,
_Outptr_result_maybenull_ MI_Instance **extendedError)
{
MI_Result r = MI_RESULT_OK;
PROCESS_INFORMATION ProcInfo;
STARTUPINFO si;
HRESULT hr = S_OK;
MI_Uint32 dwExitCode = 0;
BOOL bRes = MI_TRUE;
wchar_t param[LCM_MAX_PATH] ;
wchar_t wExe[LCM_MAX_PATH];
DSC_EventWriteMessageScheduleTaskAfterReboot();
if (extendedError == NULL)
{
return MI_RESULT_INVALID_PARAMETER;
}
*extendedError = NULL; // Explicitly set *extendedError to NULL as _Outptr_ requires setting this at least once.
wExe[0] = L'\0';
param[0] = L'\0';
memset(&si,0,sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_FORCEOFFFEEDBACK;
if (bregisterTask)
{
hr = StringCchPrintf(param, LCM_MAX_PATH, L" /Create /SC ONSTART /TN \"%s\" /RU System /F /TR \"PowerShell.exe -NonInt -Window Hidden -Command \'Invoke-CimMethod -Namespace root/Microsoft/Windows/DesiredStateConfiguration -ClassName MSFT_DSCLocalConfigurationManager -MethodName PerformRequiredConfigurationChecks -Arg @{Flags = [System.UInt32]2 }\'\"",
DSC_RESTART_BOOTUP_TASK);
}
else
{
hr = StringCchPrintf(param, LCM_MAX_PATH, L" /Delete /F /TN \"%s\" ", DSC_RESTART_BOOTUP_TASK);
}
if (FAILED(hr) || NitsShouldFault(NitsHere(), NitsAutomatic))
{
if (SUCCEEDED(hr)) hr = E_FAIL;
return GetCimError(hr, extendedError, ID_LCMHELPER_PRINTF_ERROR);
}
if(GetEnvironmentVariable(L"windir", wExe, LCM_MAX_PATH) ==0 )
{
return GetCimWin32Error(GetLastError(), extendedError, ID_MODMAN_WINDIRENV_FAILED);
}
hr = StringCchCatW(wExe, LCM_MAX_PATH, L"\\system32\\schtasks.exe");
if( FAILED(hr))
{
return GetCimError(hr, extendedError, ID_ENGINEHELPER_CAT_ERROR);
}
bRes = CreateProcess(wExe, param,
NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &ProcInfo);
if (!bRes)
{
return GetCimWin32Error(GetLastError(), extendedError, ID_ENGINEHELPER_CREATEPROCESS_ERROR);
}
WaitForSingleObject( ProcInfo.hProcess, INFINITE);
if (GetExitCodeProcess(ProcInfo.hProcess,(LPDWORD)&dwExitCode) && dwExitCode != 0)
{
r = GetCimMIError(MI_RESULT_FAILED, extendedError, ID_ENGINEHELPER_CREATEPROCESS_ERROR);
}
CloseHandle(ProcInfo.hThread);
CloseHandle(ProcInfo.hProcess);
return r;
}
MI_Result UpdateTask(
_In_z_ MI_Char* taskName,
_In_z_ MI_Char* taskTime,
_In_ MI_Uint32 refreshFrequencyInSeconds,
_Outptr_result_maybenull_ MI_Instance **extendedError)
{
MI_Result r = MI_RESULT_OK;
PROCESS_INFORMATION ProcInfo;
STARTUPINFO si;
HRESULT hr = S_OK;
MI_Uint32 dwExitCode = 0;
BOOL bRes = MI_TRUE;
UINT retVal = 0;
HANDLE hXmlFileHandle = NULL;
BOOL bHandleUsageSuccess = FALSE;
const char BOM [] = {0xFF, 0xFE};
MI_Uint32 dwWmiMethodArg = 0;
size_t sFormattedXMLFileLength = 0;
// The task scheduler filename
// This will double as the buffer for GetTempPath and for the command
wchar_t wSchedTaskPath[MAX_PATH];
wchar_t wTmpFilePath[MAX_PATH];
wchar_t wSchedTaskFile[(sizeof(LocalConfigManagerTaskXMLFormatString)+sizeof(L"2013-04-11T18:10:48")+sizeof("2678400"))/sizeof(wchar_t)];
wchar_t wSchedTaskParam[LCM_MAX_PATH];
MI_Uint32 len = 0;
LPWSTR wCommandFormat = NULL;
if (extendedError == NULL)
{
return MI_RESULT_INVALID_PARAMETER;
}
*extendedError = NULL; // Explicitly set *extendedError to NULL as _Outptr_ requires setting this at least once.
wSchedTaskPath[0] = L'\0';
wTmpFilePath[0] = L'\0';
wSchedTaskFile[0] = L'\0';
wSchedTaskParam[0] = L'\0';
memset(&si,0,sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_FORCEOFFFEEDBACK;
if (refreshFrequencyInSeconds > THIRTY_ONE_DAYS_IN_SECONDS)
{
refreshFrequencyInSeconds = THIRTY_ONE_DAYS_IN_SECONDS;
}
if (refreshFrequencyInSeconds < FIFTEEN_MINUTES_IN_SECONDS)
{
refreshFrequencyInSeconds = THIRTY_ONE_DAYS_IN_SECONDS;
}
wCommandFormat = LocalConfigManagerTaskConsistencyCommand;
dwWmiMethodArg = 1;
retVal = GetTempPath(MAX_PATH, wSchedTaskPath);
if (!retVal)
{
hr = E_FAIL;
return GetCimError(hr, extendedError, ID_LCMHELPER_GETTEMPPATH_ERROR);
}
// 0 here signifies our willingness to let the system create and close the file for us
// This means we cannot specify FILE_ATTRIBUTE_TEMPORARY to CreateFile
// but in return we can be sure that nobody will take our filename in the microsecond before we use it
retVal = GetTempFileName(wSchedTaskPath, L"LCM", 0u, wTmpFilePath);
if (!retVal)
{
hr = E_FAIL;
return GetCimError(hr, extendedError, ID_LCMHELPER_GETTEMPFILENAME_ERROR);
}
hr = StringCchPrintf(wSchedTaskParam, sizeof(wSchedTaskParam)/sizeof(wchar_t), wCommandFormat, wTmpFilePath);
if (FAILED(hr) || NitsShouldFault(NitsHere(), NitsAutomatic))
{
if (SUCCEEDED(hr)) hr = E_FAIL;
return GetCimError(hr, extendedError, ID_LCMHELPER_PRINTF_ERROR);
}
if (GetEnvironmentVariable(L"windir", wSchedTaskPath, MAX_PATH) ==0 )
{
return GetCimWin32Error(GetLastError(), extendedError, ID_MODMAN_WINDIRENV_FAILED);
}
hr = StringCchCatW(wSchedTaskPath, MAX_PATH, L"\\system32\\schtasks.exe");
if (FAILED(hr))
{
return GetCimError(hr, extendedError, ID_ENGINEHELPER_CAT_ERROR);
}
hr = StringCchPrintf(wSchedTaskFile, sizeof(wSchedTaskFile)/sizeof(wchar_t), LocalConfigManagerTaskXMLFormatString, refreshFrequencyInSeconds, taskTime, dwWmiMethodArg);
if (FAILED(hr) || NitsShouldFault(NitsHere(), NitsAutomatic))
{
if( SUCCEEDED(hr)) hr = E_FAIL;
return GetCimError(hr, extendedError, ID_LCMHELPER_PRINTF_ERROR);
}
hr = StringCchLength(wSchedTaskFile, STRSAFE_MAX_CCH, &sFormattedXMLFileLength);
if (FAILED(hr) || NitsShouldFault(NitsHere(), NitsAutomatic))
{
if( SUCCEEDED(hr)) hr = E_FAIL;
return GetCimError(hr, extendedError, ID_LCMHELPER_STRLEN_ERROR);
}
// We've done everything we can do ahead of time. Now we actually start changing the system
hXmlFileHandle = CreateFile(wTmpFilePath, GENERIC_WRITE, 0 /* Prevent sharing */, NULL /* Children don't inherit */, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL /* No template */);
if (hXmlFileHandle == INVALID_HANDLE_VALUE)
{
return GetCimWin32Error(GetLastError(), extendedError, ID_ENGINEHELPER_OPENFILE_ERROR);
}
bHandleUsageSuccess = WriteFile(hXmlFileHandle, BOM, sizeof(BOM), (LPDWORD)&len, NULL);
if (!bHandleUsageSuccess)
{
hr = HRESULT_FROM_WIN32(GetLastError());
CloseHandle(hXmlFileHandle);
DeleteFile(wTmpFilePath);
return GetCimError(hr, extendedError, ID_LCMHELPER_WRITEFILE_ERROR);
}
bHandleUsageSuccess = WriteFile(hXmlFileHandle, wSchedTaskFile, (DWORD)(sFormattedXMLFileLength*sizeof(wchar_t)), (LPDWORD)&len, NULL);
if (!bHandleUsageSuccess)
{
hr = HRESULT_FROM_WIN32(GetLastError());
CloseHandle(hXmlFileHandle);
DeleteFile(wTmpFilePath);
return GetCimError(hr, extendedError, ID_LCMHELPER_WRITEFILE_ERROR);
}
bHandleUsageSuccess = CloseHandle(hXmlFileHandle);
if (!bHandleUsageSuccess)
{
hr = HRESULT_FROM_WIN32(GetLastError());
DeleteFile(wTmpFilePath);
return GetCimError(hr, extendedError, ID_LCMHELPER_CLOSEHANDLE_ERROR);
}
bRes = CreateProcess(wSchedTaskPath, wSchedTaskParam, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &ProcInfo);
if (!bRes)
{
CloseHandle(hXmlFileHandle);
DeleteFile(wTmpFilePath);
return GetCimWin32Error(GetLastError(), extendedError, ID_ENGINEHELPER_CREATEPROCESS_ERROR);
}
WaitForSingleObject(ProcInfo.hProcess, INFINITE);
if (GetExitCodeProcess(ProcInfo.hProcess,(LPDWORD)&dwExitCode) && dwExitCode != 0)
{
r = GetCimMIError(MI_RESULT_FAILED, extendedError, ID_ENGINEHELPER_CREATEPROCESS_ERROR);
}
bHandleUsageSuccess = DeleteFile(wTmpFilePath);
if (!bHandleUsageSuccess && r == MI_RESULT_OK)
{
hr = HRESULT_FROM_WIN32(GetLastError());
return GetCimError(hr, extendedError, ID_LCMHELPER_DELETEFILE_ERROR);
}
CloseHandle(ProcInfo.hThread);
CloseHandle(ProcInfo.hProcess);
return r;
}
MI_Result RepudicationHelper(
_In_opt_ MI_Context* context,
_In_ HANDLE token,
_In_z_ const MI_Char* methodName,
_Outptr_result_maybenull_ MI_Instance **cimErrorDetails)
{
MI_Type type;
MI_Value value;
MI_Result result;
size_t computerLength;
DWORD sidLength;
MI_Char* pComputerName=NULL;
BOOL success = FALSE;
PWSTR pstrUserSid = NULL;
PTOKEN_USER userInformation = NULL;
LCMProviderContext lcmContext = {0};
if (context)
{
result = MI_Context_GetCustomOption(context,DSCCOMPUTERNAME, &type, &value);
if (result == MI_RESULT_OK && type == MI_STRING)
{
computerLength = Tcslen(value.string)+1;
pComputerName = (MI_Char*)DSC_malloc(computerLength* sizeof(wchar_t), NitsHere());
if (pComputerName == NULL)
{
return GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, cimErrorDetails, ID_LCMHELPER_MEMORY_ERROR);
}
memcpy(pComputerName, value.string, computerLength * sizeof(wchar_t));
}
}
GetTokenInformation(token, TokenUser, userInformation, 0, &sidLength);
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER || NitsShouldFault(NitsHere(), NitsAutomatic))
{
if (pComputerName != NULL)
{
DSC_free(pComputerName);
}
return GetCimMIError(MI_RESULT_FAILED, cimErrorDetails, ID_LCMHELPER_COMPUTERNAMECONTEXT_ERROR);
}
userInformation = (PTOKEN_USER)DSC_malloc(sidLength, NitsHere());
if (userInformation == NULL)
{
if (pComputerName != NULL)
{
DSC_free(pComputerName);
}
return GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, cimErrorDetails, ID_LCMHELPER_MEMORY_ERROR);
}
success = GetTokenInformation(token, TokenUser, userInformation, sidLength, &sidLength);
if (!success || NitsShouldFault(NitsHere(), NitsAutomatic))
{
if (pComputerName != NULL)
{
DSC_free(pComputerName);
}
DSC_free(userInformation);
if (success)
{
// Pass through a bogus error if we've faulted in an error otherwise success will be returned.
SetLastError(ERROR_ACCESS_DENIED);
}
return GetCimWin32Error(MI_RESULT_FAILED, cimErrorDetails, GetLastError());
}
success = ConvertSidToStringSidW(userInformation->User.Sid, &pstrUserSid);
DSC_free(userInformation);
if (!success || NitsShouldFault(NitsHere(), NitsAutomatic))
{
if (pComputerName != NULL)
{
DSC_free(pComputerName);
}
if (pstrUserSid != NULL)
{
LocalFree(pstrUserSid);
}
if (success)
{
// Pass through a bogus error if we've faulted in an error otherwise success will be returned.
SetLastError(ERROR_ACCESS_DENIED);
}
return GetCimWin32Error(MI_RESULT_FAILED, cimErrorDetails, GetLastError());
}
lcmContext.executionMode = (LCM_EXECUTIONMODE_OFFLINE | LCM_EXECUTIONMODE_ONLINE);
lcmContext.context = (void*)context;
LCM_WriteMessageInfo(&lcmContext, pComputerName, MI_WRITEMESSAGE_CHANNEL_VERBOSE, pstrUserSid);
LocalFree(pstrUserSid);
if (pComputerName != NULL)
{
DSC_free(pComputerName);
}
return MI_RESULT_OK;
}
void MI_CALL MSFT_DSCLocalConfigManager_Invoke_SendMetaConfiguration(
_In_opt_ MSFT_DSCLocalConfigManager_Self* self,
_In_ MI_Context* context,
_In_opt_z_ const MI_Char* nameSpace,
_In_opt_z_ const MI_Char* className,
_In_opt_z_ const MI_Char* methodName,
_In_ const MSFT_DSCLocalConfigManager* instanceName,
_In_opt_ const MSFT_DSCLocalConfigManager_SendMetaConfiguration* in)
{
MI_Result miResult;
MI_Instance *cimErrorDetails = NULL;
HANDLE m_clientThreadToken;
MI_UNREFERENCED_PARAMETER(self);
MI_UNREFERENCED_PARAMETER(nameSpace);
MI_UNREFERENCED_PARAMETER(className);
MI_UNREFERENCED_PARAMETER(methodName);
MI_UNREFERENCED_PARAMETER(instanceName);
MI_UNREFERENCED_PARAMETER(in);
if(!in->MetaConfiguration.exists)
{
MI_Context_PostResult(context, MI_RESULT_INVALID_PARAMETER);
return;
}
if(!OpenThreadToken(GetCurrentThread(), TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_DUPLICATE, TRUE, &m_clientThreadToken))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_THREADIMPERSONATION_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
if (!SetThreadToken(NULL, NULL))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_REVERTSELF_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
CloseHandle(m_clientThreadToken);
return;
}
miResult = SetMetaConfig(in->MetaConfiguration.value, &cimErrorDetails);
if (!SetThreadToken(NULL, m_clientThreadToken))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_RESUMEIMPERSONATION_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
CloseHandle(m_clientThreadToken);
return;
}
CloseHandle(m_clientThreadToken);
if(miResult != MI_RESULT_OK)
{
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
MI_Context_PostResult(context, MI_RESULT_OK);
}
void MI_CALL MSFT_DSCLocalConfigManager_Invoke_ApplyConfiguration(
_In_opt_ MSFT_DSCLocalConfigManager_Self* self,
_In_ MI_Context* context,
_In_opt_z_ const MI_Char* nameSpace,
_In_opt_z_ const MI_Char* className,
_In_opt_z_ const MI_Char* methodName,
_In_ const MSFT_DSCLocalConfigManager* instanceName,
_In_opt_ const MSFT_DSCLocalConfigManager_ApplyConfiguration* in)
{
MI_Result miResult;
MI_Instance *cimErrorDetails = NULL;
MSFT_DSCLocalConfigManager_ApplyConfiguration outputObject;
HANDLE m_clientThreadToken;
MI_UNREFERENCED_PARAMETER(self);
MI_UNREFERENCED_PARAMETER(nameSpace);
MI_UNREFERENCED_PARAMETER(className);
MI_UNREFERENCED_PARAMETER(methodName);
MI_UNREFERENCED_PARAMETER(instanceName);
MI_UNREFERENCED_PARAMETER(in);
if(!OpenThreadToken(GetCurrentThread(), TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_DUPLICATE, TRUE, &m_clientThreadToken))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_THREADIMPERSONATION_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
if (!SetThreadToken(NULL, NULL))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_REVERTSELF_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
CloseHandle(m_clientThreadToken);
return;
}
miResult = MSFT_DSCLocalConfigManager_ApplyConfiguration_Construct(&outputObject, context);
if(miResult != MI_RESULT_OK)
{
GetCimMIError(miResult, &cimErrorDetails, ID_LCMHELPER_CONSTRUCTAPPLY_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
SetThreadToken(NULL, m_clientThreadToken);
CloseHandle(m_clientThreadToken);
return;
}
miResult = CallConsistencyEngine(context, &cimErrorDetails);
if(miResult != MI_RESULT_OK)
{
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
SetThreadToken(NULL, m_clientThreadToken);
CloseHandle(m_clientThreadToken);
return;
}
miResult = MSFT_DSCLocalConfigManager_ApplyConfiguration_Set_MIReturn(&outputObject, 0);
if(miResult != MI_RESULT_OK)
{
GetCimMIError(miResult, &cimErrorDetails, ID_LCMHELPER_SETAPPLY_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
SetThreadToken(NULL, m_clientThreadToken);
CloseHandle(m_clientThreadToken);
return;
}
miResult = MSFT_DSCLocalConfigManager_ApplyConfiguration_Post(&outputObject, context);
MSFT_DSCLocalConfigManager_ApplyConfiguration_Destruct(&outputObject);
if (!SetThreadToken(NULL, m_clientThreadToken))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_RESUMEIMPERSONATION_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
CloseHandle(m_clientThreadToken);
return;
}
CloseHandle(m_clientThreadToken);
if(miResult != MI_RESULT_OK)
{
GetCimMIError(miResult, &cimErrorDetails, ID_LCMHELPER_POSTAPPLY_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
MI_Context_PostResult(context, MI_RESULT_OK);
}
void MI_CALL MSFT_DSCLocalConfigManager_Invoke_GetConfiguration(
_In_opt_ MSFT_DSCLocalConfigManager_Self* self,
_In_ MI_Context* context,
_In_opt_z_ const MI_Char* nameSpace,
_In_opt_z_ const MI_Char* className,
_In_opt_z_ const MI_Char* methodName,
_In_ const MSFT_DSCLocalConfigManager* instanceName,
_In_opt_ const MSFT_DSCLocalConfigManager_GetConfiguration* in)
{
MI_Result miResult;
MI_Instance *cimErrorDetails = NULL;
MI_InstanceA outInstances = {0};
MI_Value val;
MI_Uint32 bufferIndex = 0;
MSFT_DSCLocalConfigManager_GetConfiguration outputObject;
HANDLE m_clientThreadToken;
MI_UNREFERENCED_PARAMETER(self);
MI_UNREFERENCED_PARAMETER(nameSpace);
MI_UNREFERENCED_PARAMETER(className);
MI_UNREFERENCED_PARAMETER(methodName);
MI_UNREFERENCED_PARAMETER(instanceName);
MI_UNREFERENCED_PARAMETER(in);
if(!in->configurationData.exists)
{
MI_Context_PostResult(context, MI_RESULT_INVALID_PARAMETER);
return;
}
if(!OpenThreadToken(GetCurrentThread(), TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_DUPLICATE, TRUE, &m_clientThreadToken))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_THREADIMPERSONATION_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
if (!SetThreadToken(NULL, NULL))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_REVERTSELF_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
CloseHandle(m_clientThreadToken);
return;
}
miResult = MSFT_DSCLocalConfigManager_GetConfiguration_Construct(&outputObject, context);
if(miResult != MI_RESULT_OK)
{
GetCimMIError(miResult, &cimErrorDetails, ID_LCMHELPER_CONSTRUCTGET_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
GetRealBufferIndex( &(in->configurationData.value), &bufferIndex);
miResult = CallGetConfiguration(in->configurationData.value.data + bufferIndex,
in->configurationData.value.size - bufferIndex, &outInstances,
context, &cimErrorDetails);
if(miResult != MI_RESULT_OK)
{
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
MSFT_DSCLocalConfigManager_GetConfiguration_Destruct(&outputObject);
SetThreadToken(NULL, m_clientThreadToken);
CloseHandle(m_clientThreadToken);
return;
}
val.instancea.data = outInstances.data;
val.instancea.size = outInstances.size;
miResult = MI_Context_WriteStreamParameter(context, L"configurations", &val, MI_INSTANCEA, 0);
CleanUpInstanceCache(&outInstances);
if(miResult != MI_RESULT_OK)
{
GetCimMIError(miResult, &cimErrorDetails, ID_LCMHELPER_WRITEGET_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
MSFT_DSCLocalConfigManager_GetConfiguration_Destruct(&outputObject);
SetThreadToken(NULL, m_clientThreadToken);
CloseHandle(m_clientThreadToken);
return;
}
miResult = MSFT_DSCLocalConfigManager_GetConfiguration_Set_MIReturn(&outputObject, 0);
if(miResult != MI_RESULT_OK)
{
GetCimMIError(miResult, &cimErrorDetails, ID_LCMHELPER_SETGET_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
MSFT_DSCLocalConfigManager_GetConfiguration_Destruct(&outputObject);
SetThreadToken(NULL, m_clientThreadToken);
CloseHandle(m_clientThreadToken);
return;
}
miResult = MSFT_DSCLocalConfigManager_GetConfiguration_Post(&outputObject, context);
MSFT_DSCLocalConfigManager_GetConfiguration_Destruct(&outputObject);
if (!SetThreadToken(NULL, m_clientThreadToken))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_RESUMEIMPERSONATION_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
CloseHandle(m_clientThreadToken);
return;
}
CloseHandle(m_clientThreadToken);
if(miResult != MI_RESULT_OK)
{
GetCimMIError(miResult, &cimErrorDetails, ID_LCMHELPER_POSTGET_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
MI_Context_PostResult(context, MI_RESULT_OK);
}
void MI_CALL MSFT_DSCLocalConfigManager_Invoke_SendConfigurationApply(
_In_opt_ MSFT_DSCLocalConfigManager_Self* self,
_In_ MI_Context* context,
_In_opt_z_ const MI_Char* nameSpace,
_In_opt_z_ const MI_Char* className,
_In_opt_z_ const MI_Char* methodName,
_In_ const MSFT_DSCLocalConfigManager* instanceName,
_In_opt_ const MSFT_DSCLocalConfigManager_SendConfigurationApply* in)
{
MI_Result miResult;
MI_Instance *cimErrorDetails = NULL;
MI_Uint32 bufferIndex = 0;
HANDLE m_clientThreadToken;
MI_UNREFERENCED_PARAMETER(self);
MI_UNREFERENCED_PARAMETER(nameSpace);
MI_UNREFERENCED_PARAMETER(className);
MI_UNREFERENCED_PARAMETER(methodName);
MI_UNREFERENCED_PARAMETER(instanceName);
MI_UNREFERENCED_PARAMETER(in);
if(!in->ConfigurationData.exists)
{
MI_Context_PostResult(context, MI_RESULT_INVALID_PARAMETER);
return;
}
if(!OpenThreadToken(GetCurrentThread(), TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_DUPLICATE, TRUE, &m_clientThreadToken))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_THREADIMPERSONATION_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
if (!SetThreadToken(NULL, NULL))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_REVERTSELF_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
CloseHandle(m_clientThreadToken);
return;
}
GetRealBufferIndex( &(in->ConfigurationData.value), &bufferIndex);
miResult = CallSetConfiguration(in->ConfigurationData.value.data + bufferIndex,
in->ConfigurationData.value.size - bufferIndex, LCM_SETFLAGS_DEFAULT, context, &cimErrorDetails);
if (!SetThreadToken(NULL, m_clientThreadToken))
{
GetCimWin32Error(GetLastError(), &cimErrorDetails, ID_LCMHELPER_RESUMEIMPERSONATION_FAILED);
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
CloseHandle(m_clientThreadToken);
return;
}
CloseHandle(m_clientThreadToken);
if(miResult != MI_RESULT_OK)
{
MI_PostCimError(context, cimErrorDetails);
MI_Instance_Delete(cimErrorDetails);
return;
}
MI_Context_PostResult(context, MI_RESULT_OK);
}
