microsoft · ganeshkamath89 · Feb 17, 2023 · Feb 23, 2023 · Feb 23, 2023 · Feb 23, 2023
diff --git a/Unix/agent/agent.c b/Unix/agent/agent.c
@@ -100,7 +100,7 @@ void ResetLog()
     conf = Conf_Open(path);
     if (!conf)
     {
-        trace_CriticalError("Failed to open configuration file");
+        trace_CriticalError(MI_T("Failed to open configuration file"));
         return;
     }
 
@@ -113,7 +113,7 @@ void ResetLog()
 
         if (r == -1)
         {
-            trace_CriticalError("Incorrect entry in configuration file");
+            trace_CriticalError(MI_T("Incorrect entry in configuration file"));
             break;
         }
 
@@ -124,7 +124,7 @@ void ResetLog()
         {
             if (Log_SetLevelFromString(value) != 0)
             {
-                trace_CriticalError("Incorrect loglevel set in configuration file");
+                trace_CriticalError(MI_T("Incorrect loglevel set in configuration file"));
             }
             break;
         }
@@ -312,7 +312,7 @@ static void GetCommandLineOptions(int* argc, const char* argv[])
         else if (strcmp(state.opt, "--version") == 0)
         {
             Tprintf(ZT("%s: %s\n"), scs(arg0),
-                scs(CONFIG_PRODUCT "-" CONFIG_VERSION " - " CONFIG_DATE));
+                scs((const char *)(CONFIG_PRODUCT MI_T("-") CONFIG_VERSION MI_T(" - ") CONFIG_DATE)));
             exit(0);
         }
         else if (strcmp(state.opt, "--providerdir") == 0)
@@ -330,7 +330,7 @@ static void GetCommandLineOptions(int* argc, const char* argv[])
                     scs(state.arg));
             }
 
-            s_opts.idletimeout = x;
+            s_opts.idletimeout = (MI_Uint32)x;
         }
         else if (strcmp(state.opt, "--loglevel") == 0)
         {
@@ -474,7 +474,7 @@ int agent_main(int argc, const char* argv[])
     if (s_opts.idletimeout)
     {
         /* convert it to usec */
-        s_data.provmgr.idleTimeoutUsec = s_opts.idletimeout * 1000000;
+        s_data.provmgr.idleTimeoutUsec = (MI_Uint64)s_opts.idletimeout * 1000000;
         trace_Agent_ChangingIdleTimeout(s_opts.idletimeout);
 
     }

diff --git a/Unix/base/class.c b/Unix/base/class.c
@@ -290,7 +290,7 @@ MI_Result MI_CALL Class_GetElementAt(
     }
     if (referenceClass)
     {
-        *referenceClass = propertyDecl->className;
+        *referenceClass = (MI_Char*) propertyDecl->className;
     }
     if (qualifierSet)
     {
@@ -366,12 +366,12 @@ MI_Result MI_CALL Class_GetElementAtExt(
 
     if(originClass)
     {
-        *originClass = propertyDecl->origin;
+        *originClass = (MI_Char*) propertyDecl->origin;
     }
 
     if(propagatorClass)
     {
-        *propagatorClass = propertyDecl->propagator;
+        *propagatorClass = (MI_Char*) propertyDecl->propagator;
     }
 
     return MI_RESULT_OK;
@@ -489,12 +489,12 @@ MI_Result MI_CALL Class_GetMethodAtExt(
 
     if(originClass)
     {
-        *originClass = methodDecl->origin;
+        *originClass = (MI_Char*) methodDecl->origin;
     }
 
     if(propagatorClass)
     {
-        *propagatorClass = methodDecl->propagator;
+        *propagatorClass = (MI_Char*) methodDecl->propagator;
     }
 
     if(flags)
@@ -680,7 +680,7 @@ MI_Result _ParameterSet_GetParameterAt(
     (*qualifierSet).reserved2 = (ptrdiff_t) parameterDecl[index]->qualifiers;
     if (referenceClass)
     {
-        *referenceClass = parameterDecl[index]->className;
+        *referenceClass = (MI_Char*) parameterDecl[index]->className;
     }
     return MI_RESULT_OK;
 }
@@ -1517,7 +1517,7 @@ void* Class_Clone_Value(
             MI_Char *string = NULL;
             MI_Char **pointerToString = NULL;
 
-            pointerToString =  (MI_Char**)Batch_Get(batch, sizeof(MI_Char**));
+            pointerToString =  (MI_Char**)Batch_Get(batch, sizeof(MI_Char*));
             if (pointerToString == NULL)
             {
                 return NULL; /* Returning NULL causes whole batch to destruct */
@@ -1538,7 +1538,7 @@ void* Class_Clone_Value(
             MI_Instance *instance = NULL;
             MI_Instance **pointerToInstance= NULL;
 
-            pointerToInstance =  (MI_Instance**)Batch_Get(batch, sizeof(MI_Instance**));
+            pointerToInstance =  (MI_Instance**)Batch_Get(batch, sizeof(MI_Instance*));
             if (pointerToInstance == NULL)
             {
                 return NULL; /* Returning NULL causes whole batch to destruct */
@@ -1649,22 +1649,22 @@ MI_PropertyDecl * Class_Clone_Property(
     MI_PropertyDecl *newProperty = Batch_Get(batch, sizeof(MI_PropertyDecl));
     if (newProperty == NULL)
     {
-        return NULL;  /* Returning NULL causes whole batch to destruct */
+        return (MI_PropertyDecl*)NULL;  /* Returning NULL causes whole batch to destruct */
     }
     memset(newProperty, 0, sizeof(*newProperty));
     newProperty->flags = property->flags;
     newProperty->code = property->code;
     newProperty->name = Batch_Tcsdup(batch, property->name);
     if (newProperty->name == NULL)
     {
-        return NULL;  /* Returning NULL causes whole batch to destruct */
+        return (MI_PropertyDecl*)NULL;  /* Returning NULL causes whole batch to destruct */
     }
     if (property->qualifiers && property->numQualifiers)
     {
-        newProperty->qualifiers = Class_Clone_Qualifiers(batch, property->qualifiers, property->numQualifiers);
+        newProperty->qualifiers = (MI_Qualifier**)Class_Clone_Qualifiers(batch, property->qualifiers, property->numQualifiers);
         if (newProperty->qualifiers == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_PropertyDecl*)NULL;  /* Returning NULL causes whole batch to destruct */
         }
         newProperty->numQualifiers = property->numQualifiers;
     }
@@ -1674,7 +1674,7 @@ MI_PropertyDecl * Class_Clone_Property(
         newProperty->className = Batch_Tcsdup(batch, property->className); /* embedded/reference stringly typed class name */
         if (newProperty->className == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_PropertyDecl*)NULL;  /* Returning NULL causes whole batch to destruct */
         }
     }
     newProperty->subscript = property->subscript;
@@ -1684,23 +1684,23 @@ MI_PropertyDecl * Class_Clone_Property(
         newProperty->origin = Batch_Tcsdup(batch, property->origin);
         if (newProperty->origin == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_PropertyDecl*)NULL;  /* Returning NULL causes whole batch to destruct */
         }
     }
     if (property->propagator)
     {
         newProperty->propagator = Batch_Tcsdup(batch, property->propagator);
         if (newProperty->propagator == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_PropertyDecl*)NULL;  /* Returning NULL causes whole batch to destruct */
         }
     }
     if (((property->flags & MI_FLAG_NULL) != MI_FLAG_NULL) && property->value)
     {
         newProperty->value = Class_Clone_Value(batch, property->type, property->value);
         if (newProperty->value == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_PropertyDecl*)NULL;  /* Returning NULL causes whole batch to destruct */
         }
     }
     else
@@ -1761,7 +1761,7 @@ MI_ParameterDecl * Class_Clone_Parameter(
     }
     if (parameter->qualifiers && parameter->numQualifiers)
     {
-        newParameter->qualifiers = Class_Clone_Qualifiers(batch, parameter->qualifiers, parameter->numQualifiers);
+        newParameter->qualifiers = (MI_Qualifier**)Class_Clone_Qualifiers(batch, parameter->qualifiers, parameter->numQualifiers);
         if (newParameter->qualifiers == NULL)
         {
             return NULL;  /* Returning NULL causes whole batch to destruct */
@@ -1823,31 +1823,31 @@ MI_MethodDecl * Class_Clone_Method(
     MI_MethodDecl *newMethod = Batch_Get(batch, sizeof(MI_MethodDecl));
     if (newMethod == NULL)
     {
-        return NULL;  /* Returning NULL causes whole batch to destruct */
+        return (MI_MethodDecl *)NULL;  /* Returning NULL causes whole batch to destruct */
     }
     memset(newMethod, 0, sizeof(*newMethod));
     newMethod->flags = method->flags;
     newMethod->code = method->code;
     newMethod->name = Batch_Tcsdup(batch, method->name);
     if (newMethod->name == NULL)
     {
-        return NULL;  /* Returning NULL causes whole batch to destruct */
+        return (MI_MethodDecl *)NULL;  /* Returning NULL causes whole batch to destruct */
     }
     if (method->qualifiers && method->numQualifiers)
     {
-        newMethod->qualifiers = Class_Clone_Qualifiers(batch, method->qualifiers, method->numQualifiers);
+        newMethod->qualifiers = (struct _MI_Qualifier**)Class_Clone_Qualifiers(batch, method->qualifiers, method->numQualifiers);
         if (newMethod->qualifiers == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_MethodDecl *)NULL;  /* Returning NULL causes whole batch to destruct */
         }
         newMethod->numQualifiers = method->numQualifiers;
     }
     if (method->parameters && method->numParameters)
     {
-        newMethod->parameters = Class_Clone_Parameters(batch, method->parameters, method->numParameters, className);
+        newMethod->parameters = (struct _MI_ParameterDecl**)Class_Clone_Parameters(batch, method->parameters, method->numParameters, className);
         if (newMethod->parameters == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_MethodDecl *)NULL;  /* Returning NULL causes whole batch to destruct */
         }
         newMethod->numParameters = method->numParameters;
     }
@@ -1858,15 +1858,15 @@ MI_MethodDecl * Class_Clone_Method(
         newMethod->origin = Batch_Tcsdup(batch, method->origin);
         if (newMethod->origin == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_MethodDecl *)NULL;  /* Returning NULL causes whole batch to destruct */
         }
     }
     if (method->propagator)
     {
         newMethod->propagator = Batch_Tcsdup(batch, method->propagator);
         if (newMethod->propagator == NULL)
         {
-            return NULL;  /* Returning NULL causes whole batch to destruct */
+            return (MI_MethodDecl *)NULL;  /* Returning NULL causes whole batch to destruct */
         }
     }
     /* Leave owning schema NULL otherwise we would need to potentially clone that and every other class in there */
@@ -1925,7 +1925,7 @@ MI_ClassDecl* Class_Clone_ClassDecl(
     }
     if (classDecl->qualifiers && classDecl->numQualifiers)
     {
-        newClassDecl->qualifiers = Class_Clone_Qualifiers(batch, classDecl->qualifiers, classDecl->numQualifiers);
+        newClassDecl->qualifiers = (struct _MI_Qualifier**)Class_Clone_Qualifiers(batch, classDecl->qualifiers, classDecl->numQualifiers);
         if (newClassDecl->qualifiers == NULL)
         {
             return NULL;  /* Returning NULL causes whole batch to destruct */
@@ -1934,7 +1934,7 @@ MI_ClassDecl* Class_Clone_ClassDecl(
     }
     if (classDecl->properties && classDecl->numProperties)
     {
-        newClassDecl->properties = Class_Clone_Properties(batch, classDecl->properties, classDecl->numProperties);
+        newClassDecl->properties = (struct _MI_PropertyDecl**)Class_Clone_Properties(batch, classDecl->properties, classDecl->numProperties);
         if (newClassDecl->properties == NULL)
         {
             return NULL;  /* Returning NULL causes whole batch to destruct */
@@ -1962,7 +1962,7 @@ MI_ClassDecl* Class_Clone_ClassDecl(
     }
     if (classDecl->methods && classDecl->numMethods)
     {
-        newClassDecl->methods = Class_Clone_Methods(batch, classDecl->methods, classDecl->numMethods, classDecl->name);
+        newClassDecl->methods = (struct _MI_MethodDecl**)Class_Clone_Methods(batch, classDecl->methods, classDecl->numMethods, classDecl->name);
         if (newClassDecl->methods == NULL)
         {
             return NULL;  /* Returning NULL causes whole batch to destruct */

diff --git a/Unix/base/helpers.c b/Unix/base/helpers.c
@@ -969,10 +969,10 @@ static int _Base64DecCallback(
 
     start = *str;
     {
-        unsigned char b1 = (totalSize & 0xFF000000) >> 24;
-        unsigned char b2 = (totalSize & 0x00FF0000) >> 16;
-        unsigned char b3 = (totalSize & 0x0000FF00) >> 8;
-        unsigned char b4 = (totalSize & 0x000000FF);
+        unsigned char b1 = (unsigned char)((totalSize & 0xFF000000) >> 24);
+        unsigned char b2 = (unsigned char)((totalSize & 0x00FF0000) >> 16);
+        unsigned char b3 = (unsigned char)((totalSize & 0x0000FF00) >> 8);
+        unsigned char b4 = (unsigned char)((totalSize & 0x000000FF));
         (*str)[0] = b1;
         (*str)[1] = b2;
         (*str)[2] = b3;
@@ -1061,7 +1061,7 @@ MI_Result MI_CALL Instance_SetElementFromStringA(
             && ((msgFlags & WSMANFlag) == WSMANFlag))
         {
             size_t sizeIncoming = Tcslen(*data);
-            int sizeDec = 0;
+            size_t sizeDec = 0;
             char * src = (char*) *data;
             sizeDec = Base64Dec((const void *)src, sizeIncoming, _Base64DecCallback, &v.array);
 
@@ -1257,7 +1257,7 @@ int UsecToDatetime(
     timeAsUsec /= 60; /* trim down to hours */
     x->u.interval.hours = timeAsUsec % 24;
     timeAsUsec /= 24;/* trim down to days */
-    x->u.interval.days = timeAsUsec;
+    x->u.interval.days = (MI_Uint32)timeAsUsec;
     return 0;
 }
 
diff --git a/Unix/base/instance.c b/Unix/base/instance.c
@@ -499,7 +499,7 @@ MI_Result MI_CALL Instance_Construct(
         if (result != MI_RESULT_OK)
             return result;
 
-        self->classDecl = newClass->classDecl;
+		self->classDecl = (MI_ClassDecl*)newClass->classDecl;
     }
     else if (cd->flags & (MI_FLAG_CLASS|MI_FLAG_ASSOCIATION|MI_FLAG_INDICATION))
     {
@@ -1076,7 +1076,7 @@ MI_Result MI_CALL Instance_Clone(
         MI_Result result = MI_Class_Clone(self->classDecl->owningClass, &clonedClass);
         if (result != MI_RESULT_OK)
             MI_RETURN(result);
-        inst->classDecl = clonedClass->classDecl;
+		inst->classDecl = (MI_ClassDecl*)clonedClass->classDecl;
     }
     else//We had better do a hard clone
     {
@@ -1135,7 +1135,7 @@ MI_Result MI_CALL Instance_SetClassName(
         MI_RETURN(MI_RESULT_INVALID_PARAMETER);
 
     /* Save old className */
-    oldClassName = self->classDecl->name;
+	oldClassName = (ZChar*)self->classDecl->name;
 
     /* Set new className */
     {
@@ -1252,7 +1252,7 @@ MI_Result MI_CALL Instance_NewDynamic(
             MI_PropertyDecl** data;
 
             data = (MI_PropertyDecl**)BAlloc(batch,
-                _CAPACITY * sizeof(MI_PropertyDecl), CALLSITE);
+				_CAPACITY * sizeof(MI_PropertyDecl*), CALLSITE);
 
             if (!data)
             {
@@ -1459,13 +1459,13 @@ MI_Result MI_CALL __MI_Instance_Destruct(
         for (i = 0; i < self->classDecl->numProperties; i++)
         {
             MI_PropertyDecl* pd = self->classDecl->properties[i];
-            BFree(batch, pd->name, CALLSITE);
-            BFree(batch, pd, CALLSITE);
+			BFree(batch, (void *)pd->name, CALLSITE);
+			BFree(batch, (void *)pd, CALLSITE);
         }
 
-        BFree(batch, self->classDecl->name, CALLSITE);
-        BFree(batch, self->classDecl->properties, CALLSITE);
-        BFree(batch, self->classDecl, CALLSITE);
+		BFree(batch, (void *)self->classDecl->name, CALLSITE);
+		BFree(batch, (void *)self->classDecl->properties, CALLSITE);
+		BFree(batch, (void *)self->classDecl, CALLSITE);
 
         if ((void*)self != (void*)self_)
             _FreeInstance(batch, self);

diff --git a/Unix/base/log.c b/Unix/base/log.c
@@ -188,7 +188,7 @@ static void _PutHeader(
     unsigned int line, 
     Log_Level level)
 {
-    char buf[TIMESTAMP_SIZE];
+    char buf[TIMESTAMP_SIZE] = { 0 };
 
     GetTimeStamp(buf);
     Ftprintf(os, ZT("%s "), scs(buf));

diff --git a/Unix/base/oi_traces.h b/Unix/base/oi_traces.h
@@ -1013,7 +1013,7 @@ void trace_SigTERM_received_OBSOLETE(const char* user);
 OI_EVENT("Starting %s: version: (%s), platform: (%s)")
 void trace_Product_Version(const char* product, const char* version, const char* platform);
 OI_EVENT("New request received: command=(%T), namespace=(%T), class=(%T)")
-void trace_New_Request(const TChar* cmd, const TChar* namespace, const TChar* class);
+void trace_New_Request(const TChar* cmd, const TChar* namespace_, const TChar* class_);
 OI_EVENT("WARNING: one or more blocks still allocated!")
 void trace_DumpAllocList_Warning();
 OI_EVENT("BLOCK: %s(%u): ptr=%p: magic=%08X id=%u size=%u")

diff --git a/Unix/base/packing.c b/Unix/base/packing.c
@@ -461,7 +461,7 @@ MI_Result Instance_Pack(
         /* Pack the flags */
         MI_RETURN_ERR(Buf_PackU32(buf, pd->flags));
 
-        pName = pd->name;
+        pName = (MI_Char*)pd->name;
         if ((pd->flags & MI_FLAG_PARAMETER) && (pd->flags & MI_FLAG_OUT))
         {
             if (pName && pName[0] == ZT('M') && Tcscmp(pName, ZT("MIReturn"))== 0)