cimop.cpp

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

// referenceNames
// ===============================================================

int _referenceNames(const int argc, const char **argv)
{
  cerr << "Not yet implemented" << endl;
  return 1;
}

// ===============================================================
// execQuery
// ===============================================================

int _execQuery(const int argc, const char **argv)
{
  cerr << "Not yet implemented" << endl;
  return 1;
}

// ===============================================================
// getQualifier
// ===============================================================

int _getQualifier(const int argc, const char **argv)
{
  cerr << "Not yet implemented" << endl;
  return 1;
}

// ===============================================================
// setQualifier
// ===============================================================

int _setQualifier(const int argc, const char **argv)
{
  cerr << "Not yet implemented" << endl;
  return 1;
}

// ===============================================================
// deleteQualifier
// ===============================================================

int _deleteQualifier(const int argc, const char **argv)
{
  cerr << "Not yet implemented" << endl;
  return 1;
}

// ===============================================================
// enumerateQualifiers
// ===============================================================

int _enumerateQualifiers(const int argc, const char **argv)
{
  cerr << "Not yet implemented" << endl;
  return 1;
}

// ===============================================================
// Auxiliary function _inputInstanceKeys()
//
// Prompt user for values of key properties of specified class
// ===============================================================

Array<CIMKeyBinding> _inputInstanceKeys(CIMClass &cldef)
{
  Array<CIMKeyBinding> kb;
  for (Uint32 i=0; i<cldef.getPropertyCount(); i++)
  {
    CIMProperty prop = cldef.getProperty(i);
    if (_isKey(prop))
    {
      cout << prop.getName().getString() << " (" << cimTypeToString(prop.getType()) << "): " << flush;
      char s[1024];
      gets(s);
      enum CIMKeyBinding::Type t;
      switch (prop.getType())
      {
      case CIMTYPE_BOOLEAN:
        t = CIMKeyBinding::BOOLEAN; break;
      case CIMTYPE_UINT8:
      case CIMTYPE_SINT8:
      case CIMTYPE_UINT16:
      case CIMTYPE_SINT16:
      case CIMTYPE_UINT32:
      case CIMTYPE_SINT32:
      case CIMTYPE_UINT64:
      case CIMTYPE_SINT64:
      case CIMTYPE_REAL32:
      case CIMTYPE_REAL64:
        t = CIMKeyBinding::NUMERIC; break;
      case CIMTYPE_STRING:
      case CIMTYPE_DATETIME:
      default:
        t = CIMKeyBinding::STRING; break;
      case CIMTYPE_REFERENCE:
        t = CIMKeyBinding::REFERENCE; break;
      }
      kb.append(CIMKeyBinding(prop.getName(), s, t));
    }
  }
  return kb;
}

// ===============================================================
// Auxiliary function _selectInstance()
//
// Display list of instance names and ask which
// ===============================================================

CIMObjectPath _selectInstance(const String &clnam)
{
  // Get all the instance handles
  Array<CIMObjectPath> iNames;
  try
  {
    iNames = _c.enumerateInstanceNames(_nameSpace,clnam);
  }
  catch (Exception& e)
  {
    cerr << /* "enumerateInstanceNames: " << */ e.getMessage() << endl;
    return CIMObjectPath();
  }

  if (iNames.size() == 0)
  {
    cerr << "No instances found." << endl;
    return CIMObjectPath();
  }

  // Display them, numbered starting at 1
  Uint32 i;
  for (i=0; i<iNames.size(); i++)
    cout << i+1 << ": " << iNames[i].toString() << endl;
  i = 0;

  // Ask user to pick one
  while (i < 1 || i > iNames.size())
  {
    cout << "Instance (1.." << iNames.size() << ")? " << flush;
    cin >> i;
  }
  return iNames[i-1];
}


// ===============================================================
// Auxiliary function _displayInstance()
//
// Print property names and values
// ===============================================================

void _displayInstance(CIMInstance &inst)
{
  for (Uint32 j=0; j<inst.getPropertyCount(); j++)
    cout << "  " << _displayProperty(inst.getProperty(j)) << endl;
}


// ===============================================================
// Auxiliary function _isKey()
// ===============================================================

Boolean _isKey(const CIMProperty &p)
{
  int i;
  if ( (i=p.findQualifier("key")) == PEG_NOT_FOUND )
    return false;

  CIMValue v = p.getQualifier(i).getValue();
  if (v.isNull())
    return false;

  Boolean isKey;
  v.get(isKey);
  if (isKey)
    return true;
  else
    return false;
}

// ===============================================================
// Auxiliary function _displayProperty()
// ===============================================================

String _displayProperty(const CIMProperty &p)
{
  String s = p.getName().getString();

  CIMValue v = p.getValue();

  if (v.isArray())
  {
    char buf[40];
    sprintf( buf, "[%u]", v.getArraySize() );
    s.append(buf);
  }

  s.append(" = ");

  if (v.isNull())
    cout << "NULL";
  else if (v.getType() == CIMTYPE_STRING ||
           v.getType() == CIMTYPE_CHAR16 ||
           v.getType() == CIMTYPE_DATETIME)
  {
   s.append("\"");
   s.append(v.toString());
   s.append("\"");
  }
  else
    s.append(v.toString());

  return s;
}


// ===============================================================
// Auxiliary function _usage()
// ===============================================================

void _usage()
{
  cerr << "Usage:" << endl;
  cerr << "  cimop <cimoperation> [arg, ...]" << endl;
  cerr << "Implemented operations (not case sensitive) are:" << endl;
  cerr << "  getClass|gc <class>" << endl;
  // cerr << "  enumerateClasses|ec [ <class> ]" << endl;
  cerr << "  enumerateClassNames|ecn [ <class> ]" << endl;
  cerr << "  getInstance|gi <class> [ list ]" << endl;
  cerr << "  enumerateInstances|ei <class>" << endl;
  cerr << "  enumerateInstanceNames|ein <class>" << endl;
  cerr << "  getProperty|gp <class> { ask | list } [ <propnam> ]" << endl;
  // cerr << "  setProperty|sp <class>|{instanceID [prop[=value]]}" << endl;
  // cerr << "  invokeMethod|im <class>|{instanceID [method [args...]]}" << endl;
  // cerr << "  createClass|cc classdef" << endl;
  // cerr << "  modifyClass|mc classdef" << endl;
  cerr << "  deleteClass|dc <class>" << endl;
  // cerr << "  createInstance|ci <class>|<instancedef>" << endl;
  cerr << "  createInstance|ci <class>" << endl;
  cerr << "  modifyInstance|mi <class> [ list ]" << endl;
  cerr << "  deleteInstance|di <class> [ list ]" << endl;
  // cerr << "  associators|a class|instanceID" << endl;
  // cerr << "  associatorNames|an class|instanceID" << endl;
  // cerr << "  references|r class|instanceID" << endl;
  // cerr << "  referenceNames|rn class|instanceID" << endl;
  // cerr << "  execQuery|exq [query]" << endl;
  // cerr << "  getQualifier|gq qualifiername" << endl;
  // cerr << "  setQualifier|sq qualifierdef" << endl;
  // cerr << "  deleteQualifier|dq qualifiername" << endl;
  // cerr << "  enumerateQualifiers|eq" << endl;
  cerr << "Examples:" << endl;
  cerr << "  cimop ecn" << endl;
  cerr << "  cimop enumerateinstancenames pg_operatingsystem" << endl;
  cerr << "  cimop gi pg_unixprocess list" << endl;
  cerr << "Environment variables:" << endl;
  cerr << "  CIM_HOST -- local connect if not defined" << endl;
  cerr << "  CIM_PORT -- port number (default determined by CIM_NOSSL)" << endl;
  cerr << "  CIM_NOSSL -- if defined, connect unencrypted to 5988, else 5989" << endl;
  cerr << "  CIM_NAMESPACE -- if not defined use root/cimv2" << endl;
  cerr << "  CIM_USER -- user" << endl;
  cerr << "  CIM_PASSWORD -- password" << endl;
}

// ===============================================================
// Auxiliary function _giUsage()
// ===============================================================

void _giUsage()
{
  // cerr << "Usage: cimop getInstance|gi { <class> [list] | <instanceRef> }" << endl;
  cerr << "Usage: cimop getInstance|gi <class> [list]" << endl;
  cerr << "  \"list\" displays list from which to choose" << endl;
  cerr << "  otherwise asks for keys (empty ok for many)" << endl;
}


// ===============================================================
// Auxiliary function _diUsage()
// ===============================================================

void _diUsage()
{
  // cerr << "Usage: cimop deleteInstance|di { <class> [list] | <instanceRef> }" << endl;
  cerr << "Usage: cimop deleteInstance|di <class> [ list ]" << endl;
  cerr << "  \"list\" displays list from which to choose" << endl;
  cerr << "  otherwise asks for keys (empty ok for many)" << endl;
}


// ===============================================================
// Auxiliary function _gpUsage()
// ===============================================================

void _gpUsage()
{
  cerr << "Usage: cimop getProperty|gp <class> { ask | list } [<propnam>]" << endl;
  cerr << "  \"list\" displays list from which to choose" << endl;
  cerr << "  \"ask\" asks for keys (empty ok for many)" << endl;
}


// ===============================================================
// Auxiliary function _miUsage()
// ===============================================================

void _miUsage()
{
  cerr << "Usage: cimop modifyInstance|mi <class> [ list ]" << endl;
  cerr << "  \"list\" displays list from which to choose" << endl;
  cerr << "  otherwise asks for keys (empty ok for many)" << endl;
}


// ===============================================================
// Auxiliary function _ciUsage()
// ===============================================================

void _ciUsage()
{
  cerr << "Usage: cimop createInstance|ci <class>" << endl;
}


// ===============================================================
// Auxiliary function _spUsage()
// ===============================================================

void _spUsage()
{
  cerr << "Usage: cimop getProperty|gp <class> { ask | list } [ <propnam> [ <value> ] ]" << endl;
  cerr << "  \"list\" displays list from which to choose" << endl;
  cerr << "  \"ask\" asks for keys (empty ok for many)" << endl;
}


// ===============================================================
// Auxiliary function _makeKey()
//
// Build a CIMKeyBinding object from the specified property
// ===============================================================
CIMKeyBinding _makeKey(const CIMProperty &prop)
{
  // Figure out what type of key
  enum CIMKeyBinding::Type t;
  switch (prop.getType())
  {
  case CIMTYPE_BOOLEAN:
    t = CIMKeyBinding::BOOLEAN; break;
  case CIMTYPE_UINT8:
  case CIMTYPE_SINT8:
  case CIMTYPE_UINT16:
  case CIMTYPE_SINT16:
  case CIMTYPE_UINT32:
  case CIMTYPE_SINT32:
  case CIMTYPE_UINT64:
  case CIMTYPE_SINT64:
  case CIMTYPE_REAL32:
  case CIMTYPE_REAL64:
    t = CIMKeyBinding::NUMERIC; break;
  case CIMTYPE_STRING:
  case CIMTYPE_DATETIME:
  default:
    t = CIMKeyBinding::STRING; break;
  case CIMTYPE_REFERENCE:
    t = CIMKeyBinding::REFERENCE; break;
  }

  // Return a built CIMKeyBinding
  return CIMKeyBinding(prop.getName(),              // name
                    prop.getValue().toString(),  // value
                    t);                          // type
}


// ===============================================================
// Auxiliary function _makeValue()
// ===============================================================

CIMValue _makeValue(const char *v, const CIMProperty &pDef)
{
  // create a value from a string depending on property's type
  // start with null value and then set it appropriately
  CIMValue val;
  switch (pDef.getType())
  {
    case CIMTYPE_BOOLEAN:
    {
      val.set(String::equalNoCase(v,"true"));
      break;
    }

    case CIMTYPE_UINT8:
    {
      Uint8 t;
      sscanf(v,"%hu",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_SINT8:
    {
      Sint8 t;
      sscanf(v,"%hd",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_UINT16:
    {
      Uint16 t;
      sscanf(v,"%hu",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_SINT16:
    {
      Sint16 t;
      sscanf(v,"%hd",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_UINT32:
    {
      Uint32 t;
      sscanf(v,"%u",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_SINT32:
    {
      Sint32 t;
      sscanf(v,"%d",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_UINT64:
    {
      Uint64 t;
      sscanf(v,"%lu",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_SINT64:
    {
      Sint64 t;
      sscanf(v,"%ld",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_REAL32:
    {
      Real32 t;
      sscanf(v,"%f",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_REAL64:
    {
      Real64 t;
      sscanf(v,"%lf",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_CHAR16:
    {
      Char16 t;
      sscanf(v,"%hu",&t);
      val.set(t);
      break;
    }

    case CIMTYPE_STRING:
    {
      val.set(String(v));
      break;
    }

    case CIMTYPE_DATETIME:
    {
      try
      {
        val.set(CIMDateTime(v));
      }
      catch (Exception &e)
      {
        cerr << e.getMessage() << endl;
        exit(1);
      }
      break;
    }

    case CIMTYPE_REFERENCE:
    {
      val.set(CIMObjectPath(v));
      break;
    }

    default: break; // can't happen
  }
  return val;
}


// ==============================================================
// Auxiliary function _makeNamespaceClass()
//
// Returns a class definition of __Namespace
// ==============================================================

CIMClass _makeNamespaceClass()
{
  CIMClass cldef("__Namespace");
  CIMProperty p("Name",CIMValue(CIMTYPE_STRING,false));
  p.addQualifier(CIMQualifier("Key",                         // name
                              CIMValue(true),                // value
                              CIMFlavor(CIMFlavor::DISABLEOVERRIDE))); // flavor
  cldef.addProperty(p);
  return cldef;
}


// ===============================================================
// Auxiliary function _recursiveClassEnum()
// ===============================================================

int _recursiveClassEnum(const CIMName &className, String tab)
{
  Array<CIMName> cn;

  try
  {
    cn = _c.enumerateClassNames( _nameSpace, className );
  }
  catch (Exception &e)
  {
    cerr << e.getMessage() << endl;
    return 1;
  }

  for (Uint32 i=0; i<cn.size(); i++)
  {
    cout << tab << cn[i].getString() << endl;
    if (_recursiveClassEnum( cn[i], tab+"  " ) != 0) return 1;
  }
  return 0;
}

Boolean verifyServerCertificate(SSLCertificateInfo &certInfo)
{
    return true;
}