/*Function to return agentId value from registry
If registration has never been attempted on this machine, then this function returns an empty string and returns TRUE for shouldGenerateAgentId*/
MI_Result GetAgentIdFromRegistry(
_Outptr_result_maybenull_z_ MI_Char** agentId,
_Inout_ MI_Boolean *shouldGenerateAgentId)
{
if (File_ExistT(AGENTID_FILE_PATH) != 0)
{
// We are not able to get the agent Id.
// We should generate a new agentId.
*shouldGenerateAgentId = MI_TRUE ;
return MI_RESULT_OK;
}
/* inhale contents fails into agentId */
*agentId = InhaleTextFile(AGENTID_FILE_PATH);
if (Tcscasecmp(MI_T(" "), *agentId) == 0 || Tcscasecmp(MI_T(""), *agentId) == 0)
{
// We are not able to get the agent Id.
// We should generate a new agentId.
*shouldGenerateAgentId = MI_TRUE;
return MI_RESULT_OK;
}
*shouldGenerateAgentId = MI_FALSE;
(*agentId)[36] = '\0';
return MI_RESULT_OK;
}
void MI_CALL VicePresident_EnumerateInstances(
VicePresident_Self* self,
MI_Context* context,
const MI_Char* nameSpace,
const MI_Char* className,
const MI_PropertySet* propertySet,
MI_Boolean keysOnly,
const MI_Filter* filter)
{
/* Adams */
{
VicePresident inst;
VicePresident_Construct(&inst, context);
VicePresident_Set_Key(&inst, 1);
VicePresident_Set_First(&inst, MI_T("John"));
VicePresident_Set_Last(&inst, MI_T("Adams"));
VicePresident_Post(&inst, context);
VicePresident_Destruct(&inst);
}
/* Jefferson */
{
VicePresident inst;
VicePresident_Construct(&inst, context);
VicePresident_Set_Key(&inst, 2);
VicePresident_Set_First(&inst, MI_T("Thomas"));
VicePresident_Set_Last(&inst, MI_T("Jefferson"));
VicePresident_Post(&inst, context);
VicePresident_Destruct(&inst);
}
MI_PostResult(context, MI_RESULT_OK);
}
void MI_CALL TEST_Stop_Invoke_SetTargetResource(
_In_opt_ TEST_Stop_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 TEST_Stop* instanceName,
_In_opt_ const TEST_Stop_SetTargetResource* in)
{
TEST_Stop_SetTargetResource out;
MI_UNREFERENCED_PARAMETER(self);
MI_UNREFERENCED_PARAMETER(nameSpace);
MI_UNREFERENCED_PARAMETER(className);
MI_UNREFERENCED_PARAMETER(methodName);
MI_UNREFERENCED_PARAMETER(instanceName);
MI_UNREFERENCED_PARAMETER(in);
TEST_Stop_SetTargetResource_Construct(&out, context);
MI_Context_WriteMessage(context, MI_WRITEMESSAGE_CHANNEL_VERBOSE, MI_T("Executing Set for Class TEST_Stop"));
TEST_Stop_SetTargetResource_Set_MIReturn(&out, 0 );
MI_Context_PostInstance(context, &(out.__instance));
TEST_Stop_SetTargetResource_Destruct(&out);
MI_Context_PostResult(context, MI_RESULT_OK);
}
void MI_CALL L_LifecycleC1_Load(
L_LifecycleC1_Self** self,
MI_Module_Self* selfModule,
MI_Context* context)
{
MI_Result r;
*self = NULL;
{
// Save lifecycle instance to config
L_LifecycleC1 lifecycle;
cfgL_LifecycleC1.lifecycleInstance = NULL;
r = L_LifecycleC1_Construct(&lifecycle, context);
CHKMIRESULTPOST(r,"L_LifecycleC1_Construct");
CHKMIRESULTPOST(L_LifecycleC1_Set_key(&lifecycle, MI_T("L_LifecycleC1")), "L_LifecycleC1_Set_key");
CHKMIRESULTPOST(L_LifecycleC1_Set_value(&lifecycle, 0), "L_LifecycleC1_Set_value");
cfgL_LifecycleC1.supportedSubscriptionTypes = (MI_LIFECYCLE_INDICATION_CREATE | MI_LIFECYCLE_INDICATION_MODIFY | MI_LIFECYCLE_INDICATION_DELETE);
// Lifecycle indication load
r = lifecycle_Load(&cfgL_LifecycleC1, (MI_Instance*)&lifecycle, _L_LifecycleC1_Callback, context);
CHKMIRESULTPOST(r, "lifecycle_Load");
// Regular class load
r = class_Load((void**)self, &cfgL_LifecycleC1, NULL);
CHKMIRESULTPOST(r, "class_Load");
r = L_LifecycleC1_Destruct(&lifecycle);
CHKMIRESULTPOST(r, "L_LifecycleC1_Destruct");
}
MI_PostResult(context, MI_RESULT_OK);
}
static MI_Result WriteError(_In_ MI_Context* context, MI_Uint32 resultCode, _In_z_ const MI_Char* resultType, _In_z_ const MI_Char* errorMessage, _Out_ MI_Boolean *flag)
{
MI_Result returnValue = MI_RESULT_OK;
MI_Instance* extendedError = NULL;
NativeResourceProvider* nativeResourceProvider = (NativeResourceProvider*)context;
if (!nativeResourceProvider->_private.resourceProviderClassLoaded) {
DSC_EventUnSupportedHostMethodCalled(MI_T("PostIndication"));
return MI_RESULT_NOT_SUPPORTED;
}
*flag = MI_TRUE; // TRUE indicates the provider can continue (this is a non-terminating error)
returnValue = MI_Utilities_CimErrorFromErrorCode(resultCode, resultType, errorMessage, &extendedError);
EH_CheckResult(returnValue);
DoWriteError(NULL, nativeResourceProvider->_private.callbackContext, extendedError, NULL);
EH_UNWIND;
if (extendedError != NULL)
MI_Instance_Delete(extendedError);
return returnValue;
}
const MI_Char* SubscribeStatusName(SubscribeStatus status)
{
if ((MI_Uint32)status <= (MI_Uint32) SUBSCRIBE_SUB_CANCELLED)
{
return _SubscribeStatusNames[(MI_Uint32)status];
}
return MI_T("UNKNOWN Status");
}
MI_Result GetThumbprintForRegisteredServerURL(
_In_ RegistrationManager* self,
_In_ MI_Instance* registrationData,
_Outptr_result_maybenull_z_ MI_Char** thumbprint,
_Outptr_result_maybenull_ MI_Instance **cimErrorDetails)
{
size_t dwSize;
MI_Value value;
int retValue;
MI_Uint32 i = 0;
MI_Result result = MI_RESULT_OK;
if (cimErrorDetails)
{
*cimErrorDetails = NULL;
}
*thumbprint = 0;
if (self->serverURLs == NULL)
{
InitializeServerURLs(self, cimErrorDetails);
}
if (self->serverURLs != NULL)
{
result = MI_Instance_GetElement(registrationData, MSFT_ServerURL_Name, &value, NULL, NULL, NULL);
EH_CheckResult(result);
for (i = 0; i < self->numberOfServerURLs; i++)
{
if (self->serverURLs[i] != NULL && Tcscasecmp(self->serverURLs[i], value.string) == 0)
{
dwSize = Tcslen(self->serverCertificateThumbprints[i]) + 1;
*thumbprint = (MI_Char*)DSC_malloc(dwSize*sizeof(MI_Char), NitsHere());
if (*thumbprint == NULL)
{
EH_Fail_(GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, cimErrorDetails, ID_LCMHELPER_MEMORY_ERROR));
}
retValue = Stprintf(*thumbprint, dwSize, MI_T("%T"), self->serverCertificateThumbprints[i]);
if (retValue == -1 || NitsShouldFault(NitsHere(), NitsAutomatic))
{
DSC_free(*thumbprint);
EH_Fail_(GetCimMIError(MI_RESULT_FAILED, cimErrorDetails, ID_LCMHELPER_PRINTF_ERROR));
}
result = MI_RESULT_OK;
break;
}
}
}
EH_UNWIND:
return result;
}
void SetJobDeviceName()
{
if (GetComputerHostName(g_JobInformation.deviceName, (int)DEVICE_NAME_SIZE) != 0)
{
Stprintf(g_JobInformation.deviceName, DEVICE_NAME_SIZE, MI_T("%T"), EMPTY_STRING);
return;
}
}
const MI_Char * GetErrorDetail( _In_ MI_Instance *inst)
{
MI_Result r = MI_RESULT_OK;
MI_Value value;
r = MI_Instance_GetElement(inst, MI_T("Message"), &value, NULL, NULL, NULL);
if( r != MI_RESULT_OK)
{
return NULL;
}
return (const MI_Char*)value.string;
}
MI_Result WriteServerURLToCache(
_In_ RegistrationManager* self,
_In_z_ MI_Char* serverURL,
_In_z_ MI_Char* thumbprint,
_Outptr_result_maybenull_ MI_Instance **cimErrorDetails)
{
size_t dwSize;
int retValue;
MI_Result result = MI_RESULT_OK;
if (cimErrorDetails)
{
*cimErrorDetails = NULL;
}
if (self->serverURLs == NULL)
{
result = InitializeServerURLs(self, cimErrorDetails);
EH_CheckResult(result);
}
dwSize = Tcslen(serverURL) + 1;
self->serverURLs[self->numberOfServerURLs] = (MI_Char*)DSC_malloc(dwSize* sizeof(MI_Char), NitsHere());
if (self->serverURLs[self->numberOfServerURLs] == NULL)
{
EH_Fail_(GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, cimErrorDetails, ID_LCMHELPER_MEMORY_ERROR));
}
retValue = Stprintf(self->serverURLs[self->numberOfServerURLs], dwSize, MI_T("%T"), serverURL);
if (retValue == -1 || NitsShouldFault(NitsHere(), NitsAutomatic))
{
DSC_free(self->serverURLs[self->numberOfServerURLs]);
EH_Fail_(GetCimMIError(MI_RESULT_FAILED, cimErrorDetails, ID_LCMHELPER_PRINTF_ERROR));
}
dwSize = Tcslen(thumbprint) + 1;
self->serverCertificateThumbprints[self->numberOfServerURLs] = (MI_Char*)DSC_malloc(dwSize* sizeof(MI_Char), NitsHere());
if (self->serverCertificateThumbprints[self->numberOfServerURLs] == NULL)
{
EH_Fail_(GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, cimErrorDetails, ID_LCMHELPER_MEMORY_ERROR));
}
retValue = Stprintf(self->serverCertificateThumbprints[self->numberOfServerURLs], dwSize, MI_T("%T"), thumbprint);
if (retValue == -1 || NitsShouldFault(NitsHere(), NitsAutomatic))
{
DSC_free(self->serverCertificateThumbprints[self->numberOfServerURLs]);
EH_Fail_(GetCimMIError(MI_RESULT_FAILED, cimErrorDetails, ID_LCMHELPER_PRINTF_ERROR));
}
self->numberOfServerURLs++;
EH_UNWIND:
return result;
}
static MI_Result WriteStreamParameter(_In_ MI_Context* context, const MI_Char* name, _In_ const MI_Value* value, _In_ MI_Type type, _In_ MI_Uint32 flags)
{
NativeResourceProvider* nativeResourceProvider = (NativeResourceProvider*)context;
if (!nativeResourceProvider->_private.resourceProviderClassLoaded) {
DSC_EventUnSupportedHostMethodCalled(MI_T("PostIndication"));
return MI_RESULT_NOT_SUPPORTED;
}
LCM_WriteStreamParameter(nativeResourceProvider->_private.callbackContext->lcmProviderContext, name, value, type, flags);
return MI_RESULT_OK;
}
void MI_CALL MSFT_Friends_AssociatorInstances(
MSFT_Friends_Self* self,
MI_Context* context,
const MI_Char* nameSpace,
const MI_Char* className,
const MI_Instance* instanceName,
const MI_Char* resultClass,
const MI_Char* role,
const MI_Char* resultRole,
const MI_PropertySet* propertySet,
MI_Boolean keysOnly,
const MI_Filter* filter)
{
if (MSFT_Person_IsA(instanceName))
{
if (_Match(role, MI_T("Left")) &&
_Match(resultRole, MI_T("Right")))
{
if (((MSFT_Person*)instanceName)->Key.exists && ((MSFT_Person*)instanceName)->Key.value == 1)
{
MSFT_Person inst;
MSFT_Person_Construct(&inst, context);
MSFT_Person_Set_Key(&inst, 2);
MSFT_Person_Set_First(&inst, MI_T("John"));
MSFT_Person_Set_Last(&inst, MI_T("Adams"));
MSFT_Person_Post(&inst, context);
MSFT_Person_Destruct(&inst);
}
}}
if (MSFT_Person_IsA(instanceName))
{
if (_Match(role, MI_T("Right")) &&
_Match(resultRole, MI_T("Left")))
{
if (((MSFT_Person*)instanceName)->Key.exists && ((MSFT_Person*)instanceName)->Key.value == 2)
{
MSFT_Person inst;
MSFT_Person_Construct(&inst, context);
MSFT_Person_Set_Key(&inst, 1);
MSFT_Person_Set_First(&inst, MI_T("George"));
MSFT_Person_Set_Last(&inst, MI_T("Washington"));
MSFT_Person_Post(&inst, context);
MSFT_Person_Destruct(&inst);
}
}}
MI_PostResult(context, MI_RESULT_OK);
}
static MI_Result WriteCimError(_In_ MI_Context* context, _In_ const MI_Instance *error, _Out_ MI_Boolean*flag)
{
NativeResourceProvider* nativeResourceProvider = (NativeResourceProvider*)context;
if (!nativeResourceProvider->_private.resourceProviderClassLoaded) {
DSC_EventUnSupportedHostMethodCalled(MI_T("PostIndication"));
return MI_RESULT_NOT_SUPPORTED;
}
*flag = MI_TRUE; // TRUE indicates the provider can continue (this is a non-terminating error)
DoWriteError(NULL, nativeResourceProvider->_private.callbackContext, /* const cast */ (MI_Instance *) error, NULL);
return MI_RESULT_OK;
}
/*Function to return true if registration needs to be done*/
MI_Boolean ShouldDoRegistration(
_In_ RegistrationManager* self,
_In_ RegistrationRequest* request,
_Outptr_result_maybenull_ MI_Instance **cimErrorDetails)
{
MI_Result result = MI_RESULT_OK;
MI_Uint32 i = 0;
MI_Value value;
MI_Char* url = NULL;
MI_Type type;
MI_Uint32 flags;
if (cimErrorDetails)
{
*cimErrorDetails = NULL;
}
MI_Instance *registrationDataInstance = request->registrationData;
result = MI_Instance_GetElement(registrationDataInstance, MSFT_ServerURL_Name, &value, NULL, NULL, NULL);
EH_CheckResult(result);
url = value.string;
result = DSC_MI_Instance_GetElement(registrationDataInstance, MSFT_RegistrationKey_Name, &value, &type, &flags, NULL);
if (result == MI_RESULT_OK && type == MI_STRING && (!(flags & MI_FLAG_NULL)))
{
if (Tcscasecmp(value.string, MI_T("")) != 0)
{
// This means that a non-empty RegistrationKey is specified. Then, we always do registration.
// If RegistrationKey is not specified, then we check the cache and do/skip registration based on ServerURL
DSC_EventWriteLCMAgentAttemptRegistration(g_ConfigurationDetails.jobGuidString, self->agentId, url);
return MI_TRUE;
}
}
for (i = 0; i < self->numberOfServerURLs; i++)
{
if (Tcscasecmp(self->serverURLs[i], url) == 0)
{
DSC_EventWriteLCMServerURLRegistered(g_ConfigurationDetails.jobGuidString, self->agentId, url);
return MI_FALSE;
}
}
EH_UNWIND:
return MI_TRUE;
}
MI_Result AppendWMIError1ParamID(
_Inout_ MI_Instance *cimErrorDetails,
_In_ MI_Uint32 errorStringId
)
{
MI_Result r = MI_RESULT_OK;
Intlstr intlstr = Intlstr_Null;
GetResourceString(errorStringId, &intlstr);
if( intlstr.str )
{
r = AppendWMIError1Param(cimErrorDetails, MI_T("%s %s"), intlstr.str);
Intlstr_Free(intlstr);
}
return r;
}
static MI_Result PostInstance(_In_ MI_Context* context, _In_ const MI_Instance * instance)
{
if (instance == NULL)
{
return MI_RESULT_INVALID_PARAMETER;
}
NativeResourceProvider* nativeResourceProvider = (NativeResourceProvider*)context;
if (!nativeResourceProvider->_private.resourceProviderClassLoaded) {
DSC_EventUnSupportedHostMethodCalled(MI_T("PostIndication"));
return MI_RESULT_NOT_SUPPORTED;
}
return MI_Instance_Clone(instance, &nativeResourceProvider->_private.outputResource);
}
MI_Result GetRegisteredServerURLsFromCache(
_Outptr_result_maybenull_z_ MI_Char** registeredServerURLs,
_Outptr_result_maybenull_ MI_Instance **cimErrorDetails)
{
MI_Value value;
MI_Type type;
MI_Uint32 flags;
size_t dwSize;
int retValue;
if (cimErrorDetails)
{
*cimErrorDetails = NULL;
}
memset(registeredServerURLs, 0, sizeof(MI_Char));
if (g_DSCInternalCache)
{
if (DSC_MI_Instance_GetElement(g_DSCInternalCache, DSC_InternalStateCache_RegisteredServerURLs, &value, &type, &flags, NULL) == MI_RESULT_OK)
{
dwSize = Tcslen(value.string) + 1;
*registeredServerURLs = (MI_Char*)DSC_malloc(dwSize*sizeof(MI_Char), NitsHere());
if (*registeredServerURLs == NULL)
{
EH_Fail_(GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, cimErrorDetails, ID_LCMHELPER_MEMORY_ERROR));
}
memset(*registeredServerURLs, 0, dwSize);
retValue = Stprintf(*registeredServerURLs, dwSize, MI_T("%T"), value.string);
if (retValue == -1 || NitsShouldFault(NitsHere(), NitsAutomatic))
{
DSC_free(*registeredServerURLs);
EH_Fail_(GetCimMIError(MI_RESULT_FAILED, cimErrorDetails, ID_LCMHELPER_PRINTF_ERROR));
}
}
}
EH_UNWIND:
return MI_RESULT_OK;
}
static MI_Result MI_CALL _SetIndicationProperties_Impl(
_In_ void* cfg,
_Outptr_ MI_Instance** indication)
{
MI_Result r = MI_RESULT_OK;
Config* config = (Config*)cfg;
DEBUG_ASSERT (indication);
*indication = NULL;
{
MI_Boolean match;
R_IndicationC1* inst;
MI_Context* context = config->postctx;
r = MI_Context_NewInstance(context, &R_IndicationC1_rtti, indication);
CHKMIRESULTRETURN(r, "MI_Context_NewInstance failed");
L_Indication_SetIndicationProperties(cfg, *indication);
CHKSETPROPERTY(r, "L_Indication Properties");
inst = (R_IndicationC1*) (*indication);
r = R_IndicationC1_Set_message(inst, MI_T("test indication message"));
CHKSETPROPERTY(r, "message");
r = R_IndicationC1_Set_id(inst, config->count);
CHKSETPROPERTY(r, "id");
r = R_IndicationC1_Set_rcode1(inst, config->count);
CHKSETPROPERTY(r, "rcode1");
r = class_TestFilter(config, &inst->__instance, &match);
if (r == MI_RESULT_OK)
{
if (match == MI_FALSE)
{
LOGMSG(("Indication does not match filter"));
}
}
}
return r;
}
*/
/*
**==============================================================================
**
** Dog
**
**==============================================================================
*/
/* property Dog.Key */
static MI_CONST MI_PropertyDecl Dog_Key_prop =
{
MI_FLAG_PROPERTY|MI_FLAG_KEY, /* flags */
0x006B7903, /* code */
MI_T("Key"), /* name */
NULL, /* qualifiers */
0, /* numQualifiers */
MI_STRING, /* type */
NULL, /* className */
0, /* subscript */
offsetof(Dog, Key), /* offset */
MI_T("XYZ_Dog"), /* origin */
MI_T("XYZ_Dog"), /* propagator */
NULL,
};
/* property Dog.Array1 */
static MI_CONST MI_PropertyDecl Dog_Array1_prop =
{
MI_FLAG_PROPERTY, /* flags */
MI_Result UpdateTask(
_In_z_ MI_Char* taskName,
_In_z_ MI_Char* taskTime,
_In_ MI_Uint32 refreshFrequencyInSeconds,
_Outptr_result_maybenull_ MI_Instance **extendedError)
{
int retValue = -1;
ssize_t read = 0;
size_t readLength = 0, writeLength = 0;
MI_Char *line = NULL, *lineToWrite = NULL, *taskInCrontab = NULL;
FILE *cronFile = NULL, *cronFileTmp = NULL;
MI_Uint32 errorCode = 0;
if (extendedError == NULL)
{
return MI_RESULT_INVALID_PARAMETER;
}
*extendedError = NULL;
// Preparation
if (refreshFrequencyInSeconds > THIRTY_ONE_DAYS_IN_SECONDS)
{
refreshFrequencyInSeconds = THIRTY_ONE_DAYS_IN_SECONDS;
}
if (refreshFrequencyInSeconds < FIFTEEN_MINUTES_IN_SECONDS)
{
refreshFrequencyInSeconds = FIFTEEN_MINUTES_IN_SECONDS;
}
// PLAN 1 -- process each line of crontab file to a tmp file and then copy tmp file back
// taskTime string is not used in Linux since we can simply register a task with frequency
// Allocate memory
line = (MI_Char *)DSC_malloc(UNIT_LINE_SIZE * sizeof(MI_Char), NitsHere());
if (line == NULL)
{
errorCode = ID_LCMHELPER_MEMORY_ERROR;
goto ExitWithError;
}
lineToWrite = (MI_Char *)DSC_malloc(UNIT_LINE_SIZE * sizeof(MI_Char), NitsHere());
if (lineToWrite == NULL)
{
errorCode = ID_LCMHELPER_MEMORY_ERROR;
goto ExitWithError;
}
taskInCrontab = (MI_Char *)DSC_malloc(UNIT_LINE_SIZE * sizeof(MI_Char), NitsHere());
if (taskInCrontab == NULL)
{
errorCode = ID_LCMHELPER_MEMORY_ERROR;
goto ExitWithError;
}
// Open files
if (File_ExistT(CRON_FILE) != -1)
{
cronFile = File_OpenT(CRON_FILE, MI_T("r"));
if (cronFile == NULL)
{
// Fail to open existing cron file should lead to error exit
errorCode = ID_ENGINEHELPER_OPENFILE_ERROR;
goto ExitWithError;
}
}
cronFileTmp = File_OpenT(CRON_FILE_TMP, MI_T("w"));
if (cronFileTmp == NULL)
{
// Fail to create tmp file should lead to error exit
errorCode = ID_LCMHELPER_CREATEFILE_ERROR;
goto ExitWithError;
}
// Read and process crontab file if it exists and opens appropriately
while (cronFile != NULL && (read = readline(&line, &readLength, cronFile)) != -1)
{
retValue = TcsStrlcpy(lineToWrite, line, Tcslen(line)+1);
retValue = sscanf(line, MI_T("%*s %*s %*s %*s %*s %*s %s"), taskInCrontab);
if (retValue == 0)
{
// Ignore the bad line that does not comply with crontab file format
continue;
}
else
{
if (Tcsncasecmp(taskName, taskInCrontab, Tcslen(taskName)) == 0)
{
// Ignore entry that duplicates registration of task
continue;
}
else
{
// Write the entry to tmp file
writeLength = fwrite(lineToWrite, 1, Tcslen(lineToWrite), cronFileTmp);
if (writeLength != read)
{
errorCode = ID_LCMHELPER_WRITEFILE_ERROR;
goto ExitWithError;
}
}
}
}
if (readLength == -1)
{
// Deal memory failure in readline function
errorCode = ID_ENGINEHELPER_READFILE_ERROR;
goto ExitWithError;
}
// Add the task entry
retValue = Stprintf(lineToWrite, UNIT_LINE_SIZE, MI_T("*/%d * * * * root %T\n"), refreshFrequencyInSeconds / 60, taskName);
if (retValue == -1)
{
errorCode = ID_LCMHELPER_PRINTF_ERROR;
goto ExitWithError;
}
writeLength = fwrite(lineToWrite, 1, Tcslen(lineToWrite), cronFileTmp);
if (writeLength != Tcslen(lineToWrite))
{
errorCode = ID_LCMHELPER_WRITEFILE_ERROR;
goto ExitWithError;
}
if (cronFile != NULL)
File_Close(cronFile);
File_Close(cronFileTmp);
File_CopyT(CRON_FILE_TMP, CRON_FILE);
File_RemoveT(CRON_FILE_TMP);
DSC_free(line);
DSC_free(lineToWrite);
DSC_free(taskInCrontab);
return MI_RESULT_OK;
ExitWithError:
// Close files and remove temp file if it exists
if (cronFile)
File_Close(cronFile);
if (cronFileTmp)
File_Close(cronFileTmp);
if (File_ExistT(CRON_FILE_TMP) != -1)
File_RemoveT(CRON_FILE_TMP);
// Free memory allocations
if (line != NULL)
DSC_free(line);
if (lineToWrite != NULL)
DSC_free(lineToWrite);
if (taskInCrontab != NULL)
DSC_free(taskInCrontab);
// Form rich CIM error
if (errorCode != 0)
return GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, extendedError, errorCode);
else
return MI_RESULT_FAILED;
}
/* Get config from instance */
_Use_decl_annotations_
MI_Result Config_FromInstance(
Batch* batch,
const MI_Instance *instance,
Config* config)
{
MI_Value v;
MI_Type t;
MI_Uint32 f;
MI_Result r;
memset((void*)config, 0, sizeof(Config));
r = MI_Instance_GetElement(instance, MI_T("className"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
if (v.string)
config->className = (const char*)Batch_ZStrdup(batch, v.string);
r = MI_Instance_GetElement(instance, MI_T("configFilepath"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
if (v.string)
config->configFilepath = (const char*)Batch_ZStrdup(batch, v.string);
r = MI_Instance_GetElement(instance, MI_T("testGroup"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->testGroup = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("testGroup"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->testGroup = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("intervalMS"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->intervalMS = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("failAfterCount"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->failAfterCount = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("failResult"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->failResult = (MI_Result)v.uint32;
r = MI_Instance_GetElement(instance, MI_T("initBehavior"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->initBehavior = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("initResultCode"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->initResultCode = (MI_Result)v.uint32;
r = MI_Instance_GetElement(instance, MI_T("initTimeoutMS"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->initTimeoutMS = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("finalizeBehavior"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->finalizeBehavior = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("finalizeResultCode"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->finalizeResultCode = (MI_Result)v.uint32;
r = MI_Instance_GetElement(instance, MI_T("postBehavior"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->postBehavior = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("miscTestSubGroup"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->miscTestSubGroup = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("subscribeBookmark"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
if (v.string)
config->subscribeBookmark = Batch_ZStrdup(batch, v.string);
r = MI_Instance_GetElement(instance, MI_T("providerBookmark"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
if (v.string)
config->providerBookmark = Batch_ZStrdup(batch, v.string);
r = MI_Instance_GetElement(instance, MI_T("dialect"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
if (v.string)
config->dialect = Batch_ZStrdup(batch, v.string);
r = MI_Instance_GetElement(instance, MI_T("expression"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
if (v.string)
config->expression = Batch_ZStrdup(batch, v.string);
r = MI_Instance_GetElement(instance, MI_T("evalResult"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->evalResult = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("logLoadUnloadCall"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->logLoadUnloadCall = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("currentSubscriptionTypes"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->currentSubscriptionTypes = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("supportedSubscriptionTypes"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
config->supportedSubscriptionTypes = v.uint32;
r = MI_Instance_GetElement(instance, MI_T("apicallseq"), &v, &t, &f, NULL);
if (r != MI_RESULT_OK)
return r;
if (t != MI_STRINGA)
return MI_RESULT_INVALID_PARAMETER;
{
MI_Uint32 count = MAXLOGENTRY;
MI_Uint32 i;
if (v.stringa.size < count)
count =v.stringa.size;
if (v.stringa.data)
{
for (i = 0; i < count; i++)
{
if (v.stringa.data[i])
{
char *str = Batch_ZStrdup(batch, v.stringa.data[i]);
if (!str)
return MI_RESULT_SERVER_LIMITS_EXCEEDED;
config->apicallseq[i] = str;
}
}
}
config->apicallseqcount = count;
}
return r;
}
/* Convert config to instance */
_Use_decl_annotations_
MI_Result Config_ToInstance(
Batch* batch,
const Config* config,
MI_Instance **instanceOut)
{
MI_Instance *instance;
MI_Result r;
MI_Value value;
MI_Char* className = Batch_StrTcsdup(batch, config->className);
r = Instance_NewDynamic(&instance, CONFIG_CLASSNAME, MI_FLAG_CLASS, batch);
if (r != MI_RESULT_OK)
return r;
value.string = className;
r = MI_Instance_AddElement(instance, MI_T("className"), &value, MI_STRING, MI_FLAG_KEY);
if (r != MI_RESULT_OK)
return r;
/*
value.string = Batch_StrTcsdup(batch, config->configFilepath);
r = MI_Instance_AddElement(instance, MI_T("configFilepath"), &value, MI_STRING, 0);
if (r != MI_RESULT_OK)
return r;
*/
value.uint32 = config->testGroup;
r = MI_Instance_AddElement(instance, MI_T("testGroup"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->intervalMS;
r = MI_Instance_AddElement(instance, MI_T("intervalMS"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->failAfterCount;
r = MI_Instance_AddElement(instance, MI_T("failAfterCount"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->failResult;
r = MI_Instance_AddElement(instance, MI_T("failResult"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->initBehavior;
r = MI_Instance_AddElement(instance, MI_T("initBehavior"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->initResultCode;
r = MI_Instance_AddElement(instance, MI_T("initResultCode"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->initTimeoutMS;
r = MI_Instance_AddElement(instance, MI_T("initTimeoutMS"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->finalizeBehavior;
r = MI_Instance_AddElement(instance, MI_T("finalizeBehavior"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->finalizeResultCode;
r = MI_Instance_AddElement(instance, MI_T("finalizeResultCode"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->postBehavior;
r = MI_Instance_AddElement(instance, MI_T("postBehavior"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->miscTestSubGroup;
r = MI_Instance_AddElement(instance, MI_T("miscTestSubGroup"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
if (config->subscribeBookmark)
{
value.string = Batch_StrTcsdup(batch, config->subscribeBookmark);
r = MI_Instance_AddElement(instance, MI_T("subscribeBookmark"), &value, MI_STRING, 0);
if (r != MI_RESULT_OK)
return r;
}
if (config->providerBookmark)
{
value.string = Batch_StrTcsdup(batch, config->providerBookmark);
r = MI_Instance_AddElement(instance, MI_T("providerBookmark"), &value, MI_STRING, 0);
if (r != MI_RESULT_OK)
return r;
}
if (config->dialect)
{
value.string = Batch_StrTcsdup(batch, config->dialect);
r = MI_Instance_AddElement(instance, MI_T("dialect"), &value, MI_STRING, 0);
if (r != MI_RESULT_OK)
return r;
}
if (config->expression)
{
value.string = Batch_StrTcsdup(batch, config->expression);
r = MI_Instance_AddElement(instance, MI_T("expression"), &value, MI_STRING, 0);
if (r != MI_RESULT_OK)
return r;
}
value.uint32 = config->evalResult;
r = MI_Instance_AddElement(instance, MI_T("evalResult"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->logLoadUnloadCall;
r = MI_Instance_AddElement(instance, MI_T("logLoadUnloadCall"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->currentSubscriptionTypes;
r = MI_Instance_AddElement(instance, MI_T("currentSubscriptionTypes"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
value.uint32 = config->supportedSubscriptionTypes;
r = MI_Instance_AddElement(instance, MI_T("supportedSubscriptionTypes"), &value, MI_UINT32, 0);
if (r != MI_RESULT_OK)
return r;
*instanceOut = instance;
return MI_RESULT_OK;
}
static MI_Result MI_CALL CreateOMIError_FromMiResult_shared(
MI_Result miResult,
const MI_ClassDecl *classDecl,
_Outptr_ MI_Instance **omiError)
{
const MI_Char* message;
MI_Uint16 errorCategory;
/* The code to do error category conversion is already present in
wmi\WmiV2\Common\ErrorCodesConversion.cpp
but we need a standalone copy under wmi\winomi */
/* TODO/FIXME: need to use localized strings (once the localization story is figured out)
(BTW: I am not sure where WMIv2 is taking its error messages from.
Some (but not all) are in here:
SD://depot/fbl_srv2_ci/admin/wmi/wbem/common/WMIUTILS/msgtable.mc#2) */
switch (miResult)
{
case MI_RESULT_OK:
assert(0 && "Why would one call CreateOMIError_FromMiResult(MI_RESULT_OK)?");
message = MI_T("MI_RESULT_OK");
errorCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
break;
case MI_RESULT_FAILED :
message = MI_T("MI_RESULT_FAILED");
errorCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
break;
case MI_RESULT_ACCESS_DENIED :
message = MI_T("MI_RESULT_ACCESS_DENIED");
errorCategory = MI_ERRORCATEGORY_ACCESS_DENIED;
break;
case MI_RESULT_INVALID_NAMESPACE :
message = MI_T("MI_RESULT_INVALID_NAMESPACE");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_INVALID_PARAMETER :
message = MI_T("MI_RESULT_INVALID_PARAMETER");
errorCategory = MI_ERRORCATEGORY_INVALID_ARGUMENT;
break;
case MI_RESULT_INVALID_CLASS :
message = MI_T("MI_RESULT_INVALID_CLASS");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_NOT_FOUND :
message = MI_T("MI_RESULT_NOT_FOUND");
errorCategory = MI_ERRORCATEGORY_OBJECT_NOT_FOUND;
break;
case MI_RESULT_NOT_SUPPORTED :
message = MI_T("MI_RESULT_NOT_SUPPORTED");
errorCategory = MI_ERRORCATEGORY_NOT_IMPLEMENTED;
break;
case MI_RESULT_CLASS_HAS_CHILDREN :
message = MI_T("MI_RESULT_CLASS_HAS_CHILDREN");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_CLASS_HAS_INSTANCES :
message = MI_T("MI_RESULT_CLASS_HAS_INSTANCES");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_INVALID_SUPERCLASS :
message = MI_T("MI_RESULT_INVALID_SUPERCLASS");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_ALREADY_EXISTS :
message = MI_T("MI_RESULT_ALREADY_EXISTS");
errorCategory = MI_ERRORCATEGORY_RESOURCE_EXISTS;
break;
case MI_RESULT_NO_SUCH_PROPERTY :
message = MI_T("MI_RESULT_NO_SUCH_PROPERTY");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_TYPE_MISMATCH :
message = MI_T("MI_RESULT_TYPE_MISMATCH");
errorCategory = MI_ERRORCATEGORY_INVALID_TYPE;
break;
case MI_RESULT_QUERY_LANGUAGE_NOT_SUPPORTED :
message = MI_T("MI_RESULT_QUERY_LANGUAGE_NOT_SUPPORTED");
errorCategory = MI_ERRORCATEGORY_NOT_IMPLEMENTED;
break;
case MI_RESULT_INVALID_QUERY :
message = MI_T("MI_RESULT_INVALID_QUERY");
errorCategory = MI_ERRORCATEGORY_INVALID_ARGUMENT;
break;
case MI_RESULT_METHOD_NOT_AVAILABLE :
message = MI_T("MI_RESULT_METHOD_NOT_AVAILABLE");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_METHOD_NOT_FOUND :
message = MI_T("MI_RESULT_METHOD_NOT_FOUND");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_NAMESPACE_NOT_EMPTY :
message = MI_T("MI_RESULT_NAMESPACE_NOT_EMPTY");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_INVALID_ENUMERATION_CONTEXT :
message = MI_T("MI_RESULT_INVALID_ENUMERATION_CONTEXT");
errorCategory = MI_ERRORCATEGORY_METADATA_ERROR;
break;
case MI_RESULT_INVALID_OPERATION_TIMEOUT :
message = MI_T("MI_RESULT_INVALID_OPERATION_TIMEOUT");
errorCategory = MI_ERRORCATEGORY_INVALID_ARGUMENT;
break;
case MI_RESULT_PULL_HAS_BEEN_ABANDONED :
message = MI_T("MI_RESULT_PULL_HAS_BEEN_ABANDONED");
errorCategory = MI_ERRORCATEGORY_OPERATION_STOPPED;
break;
case MI_RESULT_PULL_CANNOT_BE_ABANDONED :
message = MI_T("MI_RESULT_PULL_CANNOT_BE_ABANDONED");
errorCategory = MI_ERRORCATEGORY_CLOS_EERROR;
break;
case MI_RESULT_FILTERED_ENUMERATION_NOT_SUPPORTED :
message = MI_T("MI_RESULT_FILTERED_ENUMERATION_NOT_SUPPORTED");
errorCategory = MI_ERRORCATEGORY_NOT_IMPLEMENTED;
break;
case MI_RESULT_CONTINUATION_ON_ERROR_NOT_SUPPORTED :
message = MI_T("MI_RESULT_CONTINUATION_ON_ERROR_NOT_SUPPORTED");
errorCategory = MI_ERRORCATEGORY_NOT_IMPLEMENTED;
break;
case MI_RESULT_SERVER_LIMITS_EXCEEDED :
message = MI_T("MI_RESULT_SERVER_LIMITS_EXCEEDED");
errorCategory = MI_ERRORCATEGORY_RESOURCE_BUSY;
break;
case MI_RESULT_SERVER_IS_SHUTTING_DOWN :
message = MI_T("MI_RESULT_SERVER_IS_SHUTTING_DOWN");
errorCategory = MI_ERRORCATEGORY_RESOURCE_UNAVAILABLE;
break;
default:
errorCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
message = MI_T("Unrecognized MI_Result");
break;
}
return CreateOMIError_shared(message, miResult, MI_RESULT_TYPE_MI, errorCategory, classDecl, omiError);
}
#include "omiutils.h"
#include <strings.h>
#include "OMI_Error.h"
#include "OMI_DebugError.h"
#if defined(_MSC_VER)
#ifdef _PREFAST_
#pragma warning(pop)
#endif
#endif
#include <assert.h>
static struct { const MI_Char *name; MI_Uint64 id; }
DeclIdMap[] = {
{ MI_T("MSFT_GUID"), 1 },
{ MI_T("MSFT_ETWEventHeader"), 2 },
{ MI_T("MSFT_ETWEventPayload"), 3 },
{ MI_T("MSFT_ETWExtendedData"), 4 },
{ MI_T("MSFT_ETWEvent"), 5 },
{ MI_T("CIM_Error"), 6 },
{ MI_T("OMI_Error"), 7 },
{ MI_T("OMI_DebugError"), 8 },
{ MI_T("MSFT_CounterValue"), 9 },
{ MI_T("MSFT_FormattedCounterValueReal64"), 10 },
{ MI_T("MSFT_FormattedCounterValueUint32"), 11 },
{ MI_T("MSFT_FormattedCounterValueUint64"), 12 },
{ MI_T("MSFT_RawCounterValue"), 13 },
{ NULL }
};
*/
/*
**==============================================================================
**
** ABC_Widget
**
**==============================================================================
*/
/* property ABC_Widget.Key */
static MI_CONST MI_PropertyDecl ABC_Widget_Key_prop =
{
MI_FLAG_PROPERTY|MI_FLAG_KEY, /* flags */
0x006B7903, /* code */
MI_T("Key"), /* name */
NULL, /* qualifiers */
0, /* numQualifiers */
MI_STRING, /* type */
NULL, /* className */
0, /* subscript */
offsetof(ABC_Widget, Key), /* offset */
MI_T("ABC_Widget"), /* origin */
MI_T("ABC_Widget"), /* propagator */
NULL,
};
/* property ABC_Widget.Color */
static MI_CONST MI_PropertyDecl ABC_Widget_Color_prop =
{
MI_FLAG_PROPERTY, /* flags */
MI_EXTERN_C MI_SchemaDecl schemaDecl;
/*
**==============================================================================
**
** Qualifier declarations
**
**==============================================================================
*/
static MI_CONST MI_Boolean Abstract_qual_decl_value = 0;
static MI_CONST MI_QualifierDecl Abstract_qual_decl =
{
MI_T("Abstract"), /* name */
MI_BOOLEAN, /* type */
MI_FLAG_ASSOCIATION|MI_FLAG_CLASS|MI_FLAG_INDICATION, /* scope */
MI_FLAG_ENABLEOVERRIDE|MI_FLAG_RESTRICTED, /* flavor */
0, /* subscript */
&Abstract_qual_decl_value, /* value */
};
static MI_CONST MI_Boolean Aggregate_qual_decl_value = 0;
static MI_CONST MI_QualifierDecl Aggregate_qual_decl =
{
MI_T("Aggregate"), /* name */
MI_BOOLEAN, /* type */
MI_FLAG_REFERENCE, /* scope */
MI_FLAG_DISABLEOVERRIDE|MI_FLAG_TOSUBCLASS, /* flavor */
MI_Boolean IsMatchedKeyProperties(
_In_ MI_Instance* instance0,
_In_ MI_Instance* instance1,
_Outptr_result_maybenull_z_ MI_Char** keywords,
_Out_ MI_Result* miResult,
_Outptr_result_maybenull_ MI_Instance **extendedError)
{
MI_Uint32 i, j;
MI_Result result0, result1;
MI_Value value0, value1;
MI_Type type0, type1;
Intlstr intlstr = Intlstr_Null;
MI_Char* tempKeywords = NULL;
MI_Char* tempKeywordsBackup = NULL;
size_t length;
MI_PropertyDecl** properties;
if (extendedError == NULL)
{
return MI_RESULT_INVALID_PARAMETER;
}
*extendedError = NULL; // Explicitly set *extendedError to NULL as _Outptr_ requires setting this at least once.
*miResult = MI_RESULT_OK;
*keywords = NULL;
properties = (MI_PropertyDecl**)instance0->classDecl->properties;
for (i = 0; i < instance0->classDecl->numProperties; i++)
{
for (j = 0; j < properties[i]->numQualifiers; j++)
{
if (Tcscasecmp(properties[i]->qualifiers[j]->name, MI_T("Key")) == 0)
{
result0 = DSC_MI_Instance_GetElement(instance0, properties[i]->name, &value0, &type0, NULL, NULL);
result1 = DSC_MI_Instance_GetElement(instance1, properties[i]->name, &value1, &type1, NULL, NULL);
if (result0 == MI_RESULT_OK
&& result1 == MI_RESULT_OK
&& type0 == type1
&& IsSameMiValue(&value0, &value1, type0))
{
// key is the same, building keywords list.
length = Tcslen(properties[i]->name) + 1;
if (tempKeywords == NULL)
{
// the first keyword.
tempKeywords = (MI_Char*)DSC_malloc(length * sizeof (MI_Char), NitsHere());
if (tempKeywords == NULL)
{
*miResult = CreateMemoryError(extendedError);
return MI_TRUE;
}
memcpy(tempKeywords, properties[i]->name, length * sizeof(MI_Char) );
}
else
{
// the second or more keywords.
if (intlstr.str == NULL)
{
// create separator string once.
GetResourceString(ID_CA_COMMA_SEPARATOR, &intlstr);
if (intlstr.str == NULL)
{
*miResult = CreateMemoryError(extendedError);
DSC_free(tempKeywords);
return MI_TRUE;
}
}
length += Tcslen(tempKeywords) + Tcslen(intlstr.str);
tempKeywordsBackup = tempKeywords;
tempKeywords = (MI_Char*)DSC_realloc(tempKeywordsBackup, length * sizeof (MI_Char), NitsHere());
if (tempKeywords == NULL)
{
*miResult = CreateMemoryError(extendedError);
DSC_free(tempKeywordsBackup);
Intlstr_Free(intlstr);
return MI_TRUE;
}
Stprintf(tempKeywords, length, MI_T("%T%T"), intlstr.str, properties[i]->name);
}
}
else
{
if (tempKeywords)
{
DSC_free(tempKeywords);
}
if (intlstr.str)
{
Intlstr_Free(intlstr);
}
if(result0 != MI_RESULT_OK)
{
*miResult = result0;
}
else if(result1 != MI_RESULT_OK)
{
*miResult = result1;
}
return MI_FALSE;
}
break;
}
}
}
if (intlstr.str)
{
Intlstr_Free(intlstr);
}
// at least one key was found, and all matched.
if (tempKeywords)
{
*keywords = tempKeywords;
return MI_TRUE;
}
return MI_FALSE;
}
MI_Result ResolvePath(_Outptr_opt_result_maybenull_z_ MI_Char **envResolvedPath,
_Outptr_opt_result_maybenull_z_ MI_Char **searchPath,
_In_z_ const MI_Char *envPath,
_In_z_ const MI_Char *searchPattern,
_Outptr_result_maybenull_ MI_Instance **extendedError)
{
MI_Uint32 dwReturnSizeInitial = 0, dwReturnSize = (MI_Uint32) (Tcslen(envPath)+1);
int result = 0;
const MI_Char *pathToUse = envPath;
if (extendedError == NULL)
{
return MI_RESULT_INVALID_PARAMETER;
}
*extendedError = NULL; // Explicitly set *extendedError to NULL as _Outptr_ requires setting this at least once.
if( searchPath)
{
*searchPath = NULL;
}
if( envResolvedPath != NULL )
{
#if defined(_MSC_VER)
dwReturnSizeInitial = ExpandEnvironmentStrings(envPath, NULL, 0);
#else
dwReturnSizeInitial = Tcslen(envPath) + 1;
#endif
*envResolvedPath = (MI_Char*)DSC_malloc(dwReturnSizeInitial* sizeof(MI_Char), NitsHere());
if( *envResolvedPath == NULL)
{
return GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, extendedError, ID_LCMHELPER_MEMORY_ERROR);
}
#if defined(_MSC_VER)
dwReturnSize = ExpandEnvironmentStrings(envPath, *envResolvedPath, dwReturnSizeInitial);
if( dwReturnSize == 0 || (dwReturnSize > dwReturnSizeInitial ) || NitsShouldFault(NitsHere(), NitsAutomatic))
{
//memory error
DSC_free(*envResolvedPath);
*envResolvedPath = NULL;
return GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, extendedError, ID_LCMHELPER_EXPANDENV_FAILED);
}
#else
memcpy(*envResolvedPath, envPath, dwReturnSizeInitial * sizeof(MI_Char));
#endif
pathToUse = *envResolvedPath;
}
if( searchPath != NULL)
{
dwReturnSize += (MI_Uint32) (Tcslen(searchPattern) + 1);// %s\\%s
/* Create Search Path*/
*searchPath = (MI_Char*)DSC_malloc(dwReturnSize* sizeof(MI_Char), NitsHere()); // %s\\%s
if( *searchPath == NULL)
{
if( envResolvedPath != NULL )
{
DSC_free(*envResolvedPath);
*envResolvedPath = NULL;
}
return GetCimMIError(MI_RESULT_SERVER_LIMITS_EXCEEDED, extendedError, ID_LCMHELPER_MEMORY_ERROR);
}
#if defined(_MSC_VER)
result = Stprintf(*searchPath, dwReturnSize, MI_T("%T\\%T"), pathToUse, searchPattern);
#else
result = Stprintf(*searchPath, dwReturnSize, MI_T("%T/%T"), pathToUse, searchPattern);
#endif
if( result <= 0 || NitsShouldFault(NitsHere(), NitsAutomatic))
{
if( envResolvedPath != NULL )
{
DSC_free(*envResolvedPath);
*envResolvedPath = NULL;
}
DSC_free(*searchPath);
return GetCimMIError(MI_RESULT_FAILED, extendedError, ID_LCMHELPER_PRINTF_ERROR);
}
}
return MI_RESULT_OK;
}
*/
/*
**==============================================================================
**
** XYZ_Frog
**
**==============================================================================
*/
/* property XYZ_Frog.Name */
static MI_CONST MI_PropertyDecl XYZ_Frog_Name_prop =
{
MI_FLAG_PROPERTY|MI_FLAG_KEY, /* flags */
0x006E6504, /* code */
MI_T("Name"), /* name */
NULL, /* qualifiers */
0, /* numQualifiers */
MI_STRING, /* type */
NULL, /* className */
0, /* subscript */
offsetof(XYZ_Frog, Name), /* offset */
MI_T("XYZ_Frog"), /* origin */
MI_T("XYZ_Frog"), /* propagator */
NULL,
};
/* property XYZ_Frog.Weight */
static MI_CONST MI_PropertyDecl XYZ_Frog_Weight_prop =
{
MI_FLAG_PROPERTY, /* flags */
#include <windows.h>
#include "Win32_EngineHelper.h"
#include <objbase.h>
#include <winsqm.h>
#endif
extern Loc_Mapping g_LocMappingTable[];
extern MI_Uint32 g_LocMappingTableSize;
void *g_registrationManager;
char g_currentError[5001];
StatusReport_ResourceNotInDesiredState * g_rnids = NULL;
BaseResourceConfiguration g_BaseResourceConfiguration[] =
{
{MI_T("ResourceId"), MI_STRING},
{MI_T("SourceInfo"), MI_STRING},
{MI_T("DependsOn"), MI_STRINGA},
{MI_T("ModuleName"), MI_STRING},
{MI_T("ModuleVersion"), MI_STRING},
{MI_T("ConfigurationName"), MI_STRING},
{NULL, 0}
};
const MI_Char * GetSchemaSearchPath()
{
return CONFIGURATION_SCHEMA_SEARCH_PATH;
}
const MI_Char * GetSchemaSearchPathProgFiles()
{
