cmpi_brokerenc.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

   static CMPIString* mbEncToString(const CMPIBroker*,const void *o, CMPIStatus *rc) {
      CMPI_Object *obj=(CMPI_Object*)o;
      String str;
      char msg[128];
      if (obj==NULL) {
         sprintf(msg,"** Null object ptr (%p) **",o);
         if (rc) CMSetStatus(rc,CMPI_RC_ERR_FAILED);
         return reinterpret_cast<CMPIString*>(new CMPI_Object(msg));
      }

      if (obj->getHdl()==NULL) {
         sprintf(msg,"** Null object hdl (%p) **",o);
         if (rc) CMSetStatus(rc,CMPI_RC_ERR_FAILED);
         return reinterpret_cast<CMPIString*>(new CMPI_Object(msg));
      }

      if (obj->getFtab()==(void*)CMPI_Instance_Ftab ||
         obj->getFtab()==(void*)CMPI_InstanceOnStack_Ftab) {
         CIMInstance *ci=(CIMInstance*)obj->getHdl();
         str="Instance of "+ci->getClassName().getString()+" {\n";
         for (int i=0,m=ci->getPropertyCount(); i<m; i++) {
            CIMConstProperty p=ci->getProperty(i);
            str.append("  "+typeToString(p.getType())+
               " "+p.getName().getString()+
               " = "+p.getValue().toString()+";\n");
         }
         str.append("};\n");
      }

      else if (obj->getFtab()==(void*)CMPI_ObjectPath_Ftab ||
         obj->getFtab()==(void*)CMPI_ObjectPathOnStack_Ftab) {
         str=((CIMObjectPath*)obj->getHdl())->toString();
      }
	  else if (obj->getFtab()==(void*)CMPI_String_Ftab) {
		str=String((const char*)obj->getHdl());
	  }
	  else if (obj->getFtab()==(void*)CMPI_Args_Ftab ||
			  obj->getFtab()==(void*)CMPI_ArgsOnStack_Ftab)
			  {
			      const Array<CIMParamValue>* arg=(Array<CIMParamValue>*)obj->getHdl();
				  for (int i=0,m=arg->size(); i < m; i++) {
						  const CIMParamValue &p=(*arg)[i];
				  		  str.append(p.getParameterName()+":"+p.getValue().toString()+"\n");
				 }
			  }
      else {
         sprintf(msg,"** Object not recognized (%p) **",o);
         if (rc) CMSetStatus(rc,CMPI_RC_ERR_FAILED);
         return reinterpret_cast<CMPIString*>(new CMPI_Object(msg));
      }

      sprintf(msg,"%p: ",o);
      return reinterpret_cast<CMPIString*>(new CMPI_Object(String(msg)+str));
   }

   static CMPIBoolean mbEncClassPathIsA(const CMPIBroker *mb, const CMPIObjectPath *eCp, const char *type, CMPIStatus *rc) {

	  if ((eCp==NULL) || (type==NULL)) {
		if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
	    return false;
	  }
      if (CIMName::legal(type) == false)
		{
      if (rc) CMSetStatus(rc,CMPI_RC_ERR_INVALID_CLASS);
	   return 0;
		}
      CIMObjectPath* cop=(CIMObjectPath*)eCp->hdl;

      const CIMName tcn(type);

      if (tcn==cop->getClassName()) return 1;

      CIMClass *cc=mbGetClass(mb,*cop);
      if (cc==NULL) return 0;
      CIMObjectPath  scp(*cop);
      scp.setClassName(cc->getSuperClassName());

      for (; !scp.getClassName().isNull(); ) {
         cc=mbGetClass(mb,scp);
         if (cc==NULL) return 0;
         if (cc->getClassName()==tcn) return 1;
         scp.setClassName(cc->getSuperClassName());
      };
      return 0;
   }

   static CMPIBoolean mbEncIsOfType(const CMPIBroker *mb, const void *o, const char *type, CMPIStatus *rc) {
      CMPI_Object *obj=(CMPI_Object*)o;
      char msg[128];
      void *Ftab = NULL;

      if (obj==NULL) {
         sprintf(msg,"** Null object ptr (%p) **",o);
         if (rc) { CMSetStatusWithChars(mb,rc,CMPI_RC_ERR_FAILED,msg); }
         return 0;
      }

      if (rc) CMSetStatus(rc,CMPI_RC_OK);

      Ftab = obj->getFtab();

      if (((Ftab==(void*)CMPI_Instance_Ftab) || (Ftab==(void*)CMPI_InstanceOnStack_Ftab)) &&
            strncmp(type,CMPIInstance_str, CMPIInstance_str_l)==0) return 1;
      if (((Ftab==(void*)CMPI_ObjectPath_Ftab) || (Ftab==(void*)CMPI_ObjectPathOnStack_Ftab)) &&
            strncmp(type,CMPIObjectPath_str, CMPIObjectPath_str_l)==0) return 1;

      if (((Ftab==(void*)CMPI_Args_Ftab) || (Ftab==(void*)CMPI_ArgsOnStack_Ftab)) &&
            strncmp(type,CMPIArgs_str, CMPIArgs_str_l)==0) return 1;

      if (((Ftab==(void*)CMPI_Context_Ftab) || (Ftab==(void*)CMPI_ContextOnStack_Ftab)) &&
            strncmp(type,CMPIContext_str, CMPIContext_str_l)==0) return 1;

      if (((Ftab==(void*)CMPI_ResultRefOnStack_Ftab) || (Ftab==(void*)CMPI_ResultInstOnStack_Ftab) ||
		   (Ftab==(void*)CMPI_ResultData_Ftab) || (Ftab==(void*)CMPI_ResultMethOnStack_Ftab) ||
           (Ftab==(void*)CMPI_ResultResponseOnStack_Ftab) || (Ftab==(void*)CMPI_ResultExecQueryOnStack_Ftab)) &&
            strncmp(type,CMPIResult_str, CMPIResult_str_l)==0) return 1;

      if (Ftab==(void*)CMPI_DateTime_Ftab &&
            strncmp(type,CMPIDateTime_str, CMPIDateTime_str_l)==0) return 1;

      if (Ftab==(void*)CMPI_Array_Ftab &&
            strncmp(type,CMPIArray_str, CMPIArray_str_l)==0) return 1;

      if (Ftab==(void*)CMPI_String_Ftab &&
            strncmp(type,CMPIString_str, CMPIString_str_l)==0) return 1;

      if (Ftab==(void*)CMPI_SelectExp_Ftab &&
            strncmp(type,CMPISelectExp_str, CMPISelectExp_str_l)==0) return 1;

      if (Ftab==(void*)CMPI_SelectCond_Ftab &&
            strncmp(type,CMPISelectCond_str, CMPISelectCond_str_l)==0) return 1;

      if (Ftab==(void*)CMPI_SubCond_Ftab &&
            strncmp(type,CMPISubCond_str, CMPISubCond_str_l)==0) return 1;

      if (Ftab==(void*)CMPI_Predicate_Ftab &&
            strncmp(type,CMPIPredicate_str, CMPIPredicate_str_l)==0) return 1;

      if (Ftab==(void*)CMPI_Broker_Ftab &&
            strncmp(type,CMPIBroker_str, CMPIBroker_str_l)==0) return 1;

      if (((Ftab==(void*)CMPI_ObjEnumeration_Ftab) ||
		  (Ftab==(void*)CMPI_InstEnumeration_Ftab) ||
          (Ftab==(void*)CMPI_OpEnumeration_Ftab)) &&
            strncmp(type,CMPIEnumeration_str, CMPIEnumeration_str_l)==0) return 1;

      sprintf(msg,"** Object not recognized (%p) **",o);
      if (rc) { CMSetStatusWithChars(mb,rc,CMPI_RC_ERR_FAILED,msg); }
      return 0;
   }

   static CMPIString* mbEncGetType(const CMPIBroker *mb,const  void* o, CMPIStatus *rc) {
      CMPI_Object *obj=(CMPI_Object*)o;
      char msg[128];
      void *Ftab= NULL;

      if (obj==NULL) {
         sprintf(msg,"** Null object ptr (%p) **",o);
         if (rc) { CMSetStatusWithChars(mb,rc,CMPI_RC_ERR_FAILED,msg); }
         return 0;
      }

      if (rc) CMSetStatus(rc,CMPI_RC_OK);
	  Ftab = obj->getFtab();

      if ((Ftab==(void*)CMPI_Instance_Ftab) || (Ftab==(void*)CMPI_InstanceOnStack_Ftab))
            return mb->eft->newString(mb,CMPIInstance_str,rc);

      if ((Ftab==(void*)CMPI_ObjectPath_Ftab) || (Ftab==(void*)CMPI_ObjectPathOnStack_Ftab))
            return mb->eft->newString(mb,CMPIObjectPath_str,rc);

      if ((Ftab==(void*)CMPI_Args_Ftab) || (Ftab==(void*)CMPI_ArgsOnStack_Ftab))
            return mb->eft->newString(mb,CMPIArgs_str,rc);

      if ((Ftab==(void*)CMPI_Context_Ftab) || (Ftab==(void*)CMPI_ContextOnStack_Ftab))
            return mb->eft->newString(mb,CMPIContext_str,rc);

      if ((Ftab==(void*)CMPI_ResultRefOnStack_Ftab) || (Ftab==(void*)CMPI_ResultInstOnStack_Ftab) ||
		   (Ftab==(void*)CMPI_ResultData_Ftab) || (Ftab==(void*)CMPI_ResultMethOnStack_Ftab) ||
           (Ftab==(void*)CMPI_ResultResponseOnStack_Ftab) || (Ftab==(void*)CMPI_ResultExecQueryOnStack_Ftab))
            return mb->eft->newString(mb,CMPIResult_str,rc);

      if (Ftab==(void*)CMPI_DateTime_Ftab)
            return mb->eft->newString(mb,CMPIDateTime_str,rc);

      if (Ftab==(void*)CMPI_Array_Ftab)
            return mb->eft->newString(mb,CMPIArray_str,rc);

      if (Ftab==(void*)CMPI_String_Ftab)
            return mb->eft->newString(mb,CMPIString_str,rc);

      if (Ftab==(void*)CMPI_SelectExp_Ftab)
            return mb->eft->newString(mb,CMPISelectExp_str,rc);

      if (Ftab==(void*)CMPI_SelectCond_Ftab)
            return mb->eft->newString(mb,CMPISelectCond_str,rc);

      if (Ftab==(void*)CMPI_SubCond_Ftab)
            return mb->eft->newString(mb,CMPISubCond_str,rc);

      if (Ftab==(void*)CMPI_Predicate_Ftab)
            return mb->eft->newString(mb,CMPIPredicate_str,rc);

      if (Ftab==(void*)CMPI_Broker_Ftab)
            return mb->eft->newString(mb,CMPIBroker_str,rc);

      if ((Ftab==(void*)CMPI_ObjEnumeration_Ftab) ||
		  (Ftab==(void*)CMPI_InstEnumeration_Ftab) ||
          (Ftab==(void*)CMPI_OpEnumeration_Ftab))
            return mb->eft->newString(mb,CMPIEnumeration_str,rc);

      sprintf(msg,"** Object not recognized (%p) **",o);
      if (rc) { CMSetStatusWithChars(mb,rc,CMPI_RC_ERR_FAILED,msg); }
      return 0;
   }

#if defined (CMPI_VER_85)

   static CMPIString* mbEncGetMessage(const CMPIBroker *mb, const char *msgId, const char *defMsg,
               CMPIStatus* rc, CMPICount count, ...) {

      MessageLoaderParms parms(msgId,defMsg);
      DDD(cout<<"--- mbEncGetMessage() count: "<<count<<endl);
      int err=0;
      if (rc) rc->rc=CMPI_RC_OK;

      if (count>0) {
         va_list argptr;
         va_start(argptr,count);
         for (;;) {
            if (count>0) parms.arg0=formatValue(&argptr,rc,&err);
            else break;
            if (count>1) parms.arg1=formatValue(&argptr,rc,&err);
            else break;
            if (count>2) parms.arg2=formatValue(&argptr,rc,&err);
            else break;
            if (count>3) parms.arg3=formatValue(&argptr,rc,&err);
            else break;
            if (count>4) parms.arg4=formatValue(&argptr,rc,&err);
            else break;
            if (count>5) parms.arg5=formatValue(&argptr,rc,&err);
            else break;
            if (count>6) parms.arg6=formatValue(&argptr,rc,&err);
            else break;
            if (count>7) parms.arg7=formatValue(&argptr,rc,&err);
            else break;
            if (count>8) parms.arg8=formatValue(&argptr,rc,&err);
            else break;
            if (count>9) parms.arg9=formatValue(&argptr,rc,&err);
            break;
         }
         va_end(argptr);
      }
      String nMsg=MessageLoader::getMessage(parms);
      return string2CMPIString(nMsg);
   }
#endif

#ifdef CMPI_VER_200
   static CMPIStatus mbEncOpenMessageFile(const CMPIBroker *mb,
               const char* msgFile, CMPIMsgFileHandle* msgFileHandle) {
      CMPIStatus rc = { CMPI_RC_OK, NULL };
      MessageLoaderParms *parms = new MessageLoaderParms();
      parms->msg_src_path = String(msgFile);
      // Get the AcceptLanguage entry
      const CMPIContext *ctx = CMPI_ThreadContext::getContext ();
      CMPIData data = ctx->ft->getEntry (ctx, CMPIAcceptLanguage, &rc);
      if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY)
      {
          if (rc.rc == CMPI_RC_OK)
          {
              parms->acceptlanguages = LanguageParser::parseAcceptLanguageHeader(CMGetCharPtr(data.value.string));
          }
          else
          {
              return rc; // should be CMPI_RC_ERR_INVALID_HANDLE
          }
      }
      MessageLoader::openMessageFile(*parms);
      
      ContentLanguageList cll = parms->contentlanguages;
      // Check that we have at least one content language (ie. matching 
      // resource bundle was found) before adding to Invocation Context.
      if (cll.size() > 0)
      {
          ctx->ft->addEntry (ctx, 
              CMPIContentLanguage,
              (CMPIValue*)(const char*)
                  LanguageParser::buildContentLanguageHeader(cll).getCString(),
              CMPI_chars);
      }

      *msgFileHandle = (void *)parms;
      CMReturn(CMPI_RC_OK);
   }

   static CMPIStatus mbEncCloseMessageFile(const CMPIBroker *mb,
               const CMPIMsgFileHandle msgFileHandle) {
      MessageLoaderParms* parms;
      parms = (MessageLoaderParms*)msgFileHandle;
      MessageLoader::closeMessageFile(*parms);
      delete parms;
      CMReturn(CMPI_RC_OK);
   }

   static CMPIString* mbEncGetMessage2(const CMPIBroker *mb, const char *msgId, 
               const CMPIMsgFileHandle msgFileHandle, const char *defMsg,
               CMPIStatus* rc, CMPICount count, ...) {

      MessageLoaderParms* parms;
      parms = (MessageLoaderParms*)msgFileHandle;
      parms->msg_id = String(msgId);
      parms->default_msg = String(defMsg);
      DDD(cout<<"--- mbEncGetMessage2() count: "<<count<<endl);
      int err=0;
      if (rc) rc->rc=CMPI_RC_OK;

      if (count>0) {
         va_list argptr;
         va_start(argptr,count);
         for (;;) {
            if (count>0) parms->arg0=formatValue(&argptr,rc,&err);
            else break;
            if (count>1) parms->arg1=formatValue(&argptr,rc,&err);
            else break;
            if (count>2) parms->arg2=formatValue(&argptr,rc,&err);
            else break;
            if (count>3) parms->arg3=formatValue(&argptr,rc,&err);
            else break;
            if (count>4) parms->arg4=formatValue(&argptr,rc,&err);
            else break;
            if (count>5) parms->arg5=formatValue(&argptr,rc,&err);
            else break;
            if (count>6) parms->arg6=formatValue(&argptr,rc,&err);
            else break;
            if (count>7) parms->arg7=formatValue(&argptr,rc,&err);
            else break;
            if (count>8) parms->arg8=formatValue(&argptr,rc,&err);
            else break;
            if (count>9) parms->arg9=formatValue(&argptr,rc,&err);
            break;
         }
         va_end(argptr);
      }
      String nMsg=MessageLoader::getMessage2(*parms);
      return string2CMPIString(nMsg);
   }
#endif

#if defined(CMPI_VER_100)
  CMPIStatus mbEncLogMessage
       (const CMPIBroker*,int severity ,const char *id,
        const char *text, const CMPIString *string) {

	  if ( !id || !(text || string))
			  CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);