sfcc 0.1.0

data/ext/sfcc/cim_client.c

@@ -0,0 +1,862 @@
+#include "cim_client.h"
+#include "cim_enumeration.h"
+#include "cim_object_path.h"
+#include "cim_class.h"
+#include "cim_instance.h"
+
+static void
+dealloc(CMCIClient *client)
+{
+  SFCC_DEC_REFCOUNT(client);
+}
+
+/**
+ * call-seq:
+ *  get_class(object_path, flags=0, properties=nil)
+ *
+ * Get Class using +object_path+ as reference. Class structure can be
+ * controled using the flags parameter.
+ *
+ * +object_path+ ObjectPath containing nameSpace and classname components.
+ *
+ * +flags+ Any combination of the following flags are supported:
+ *  Flags::LocalOnly, Flags::IncludeQualifiers and Flags::IncludeClassOrigin.
+ *
+ * +properties+ If not nil, the members of the array define one or more Property
+ * names. Each returned Object MUST NOT include elements for any Properties
+ * missing from this list
+ */
+static VALUE get_class(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE flags;
+  VALUE properties;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  CMPIConstClass *cimclass = NULL;
+  CMPIConstClass *cimclassnew = NULL;
+  char **props;
+
+  rb_scan_args(argc, argv, "12", &object_path, &flags, &properties);
+
+  if (NIL_P(flags)) flags = INT2NUM(0);
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  props = sfcc_value_array_to_string_array(properties);
+  cimclass = client->ft->getClass(client, op, NUM2INT(flags), props, &status);
+  free(props);
+
+  cimclassnew = cimclass->ft->clone(cimclass, NULL);
+  cimclass->ft->release(cimclass);
+
+  sfcc_rb_raise_if_error(status, "Can't get class");
+  return Sfcc_wrap_cim_class(cimclassnew);
+}
+
+/**
+ * call-seq:
+ *  class_names(object_path, flags=0)
+ *
+ * return the available class names for the given
+ * +object_path+ and +flags+
+ */
+static VALUE class_names(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE flags;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  VALUE rbenm = Qnil;
+
+  rb_scan_args(argc, argv, "11", &object_path, &flags);
+  if (NIL_P(flags)) flags = INT2NUM(0);
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  CMPIEnumeration *enm = client->ft->enumClassNames(client, op, NUM2INT(flags), &status);
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, NULL));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+
+  sfcc_rb_raise_if_error(status, "Can't get class names");
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  classes(object_path, flags=0)
+ *
+ * classes and subclasses in the namespace defined by +object_path+.
+ *
+ * Class structure and inheritance scope can be controled using the +flags+ parameter
+ * Any combination of the following flags are supported:
+ * Flags::LocalOnly, Flags::IncludeQualifiers and Flags::IncludeClassOrigin.
+ */
+static VALUE classes(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE flags;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  VALUE rbenm = Qnil;
+
+  rb_scan_args(argc, argv, "11", &object_path, &flags);
+  if (NIL_P(flags)) flags = INT2NUM(0);
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  CMPIEnumeration *enm = client->ft->enumClasses(client, op, NUM2INT(flags), &status);
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, NULL));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+
+  sfcc_rb_raise_if_error(status, "Can't get classes");
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  get_instance(object_path, flags=0, properties=nil)
+ *
+ * get instance using +object_path+ as reference. Instance structure
+ * can be controlled using the flags parameter.
+ *
+ * +object_path+ an ObjectPath containing namespace, class name and key
+ * components.
+ *
+ * +flags+ Any combination of the following flags are supported:
+ * Flags::LocalOnly, Flags::IncludeQualifiers and Flags::IncludeClassOrigin.
+ *
+ * +properties+ If not nil, the members of the array define one or more Property
+ * names. Each returned Object MUST NOT include elements for any Properties
+ * missing from this list
+ */
+static VALUE get_instance(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE flags;
+  VALUE properties;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  CMPIInstance *ciminstance = NULL;
+  char **props;
+
+  rb_scan_args(argc, argv, "12", &object_path, &flags, &properties);
+  if (NIL_P(flags)) flags = INT2NUM(0);
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  props = sfcc_value_array_to_string_array(properties);
+
+  ciminstance = client->ft->getInstance(client, op, NUM2INT(flags), props, &status);
+  free(props);
+
+  if (!status.rc)
+    return Sfcc_wrap_cim_instance(ciminstance->ft->clone(ciminstance, NULL));
+
+  sfcc_rb_raise_if_error(status, "Can't get instance");
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   create_instance(object_path, instance)
+ *
+ * Create Instance from +object_path+ as reference.
+ *
+ * +object_path+ ObjectPath containing nameSpace, classname and key components.
+ *
+ * +instance+ Complete instance.
+ *
+ * returns the assigned instance reference (object path)
+ */
+static VALUE create_instance(VALUE self, VALUE object_path, VALUE instance)
+{
+  CMPIStatus status;
+  CMCIClient *ptr = NULL;
+  CMPIObjectPath *op = NULL;
+  CMPIObjectPath *new_op = NULL;
+  CMPIInstance *inst = NULL;
+
+  Data_Get_Struct(self, CMCIClient, ptr);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+  Data_Get_Struct(instance, CMPIInstance, inst);
+  new_op = ptr->ft->createInstance(ptr, op, inst, &status);
+
+  if (!status.rc)
+    return Sfcc_wrap_cim_object_path(new_op->ft->clone(new_op, NULL));
+
+  sfcc_rb_raise_if_error(status, "Can't create instance");
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  set_instance(object_path, instance, flags=0, properties=nil)
+ *
+ * Replace an existing Instance from +instance+, using +object_path+ as reference.
+ *
+ * +object_path+ ObjectPath containing nameSpace, classname and key components.
+ *
+ * +instance+ Complete instance.
+ *
+ * +flags+ The following flag is supported: Flags::IncludeQualifiers.
+ *
+ * + properties+ If not nil, the members of the array define one or more Property
+ * names, only those properties will be updated. Else, all properties will be updated.
+ */
+static VALUE set_instance(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE instance;
+  VALUE flags;
+  VALUE properties;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMPIInstance *inst = NULL;
+  CMCIClient *client = NULL;
+  char **props;
+
+  rb_scan_args(argc, argv, "22", &object_path, &instance, &flags, &properties);
+  if (NIL_P(flags)) flags = INT2NUM(0);
+
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+  Data_Get_Struct(instance, CMPIInstance, inst);
+
+  props = sfcc_value_array_to_string_array(properties);
+
+  status = client->ft->setInstance(client, op, inst, NUM2INT(flags), props);
+  free(props);
+
+  sfcc_rb_raise_if_error(status, "Can't set instance");
+  return instance;
+}
+
+/**
+ * call-seq:
+ *  delete_instance(object_path)
+ *
+ * Delete an existing Instance using +object_path+ as reference.
+ * +object_path+ ObjectPath containing nameSpace, classname and key components.
+ */
+static VALUE delete_instance(VALUE self, VALUE object_path)
+{
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  status = client->ft->deleteInstance(client, op);
+  sfcc_rb_raise_if_error(status, "Can't delete instance '%s'", CMGetCharsPtr(CMObjectPathToString(op, NULL), NULL));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   query(object_path, query, lang)
+ *
+ * Query the enumeration of instances of the class (and subclasses) defined
+ * by +object_path+ using +query+ expression.
+ *
+ * +object_path+ ObjectPath containing nameSpace and classname components.
+ *
+ * +query+ Query expression
+ *
+ * +lang+ Query Language
+ *
+ * returns resulting eumeration of instances
+ */
+static VALUE query(VALUE self,
+                   VALUE object_path,
+                   VALUE query,
+                   VALUE lang)
+{
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+  VALUE rbenm = Qnil;
+
+  CMPIEnumeration *enm = client->ft->execQuery(client,
+                                               op,
+                                               StringValuePtr(query),
+                                               StringValuePtr(lang),
+                                               &status);
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, NULL));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+
+  sfcc_rb_raise_if_error(status, "Can't get instances from query");
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  instance_names(object_path, flags)
+ *
+ * instance names of the class defined by +object_path+
+ */
+static VALUE instance_names(VALUE self, VALUE object_path)
+{
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  VALUE rbenm = Qnil;
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  CMPIEnumeration *enm = client->ft->enumInstanceNames(client, op, &status);
+
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, NULL));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+  sfcc_rb_raise_if_error(status, "Can't get instance names");
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  instances(object_path, flags=0, properties=nil)
+ *
+ * Enumerate the instance names of the class defined by +object_path+
+ *
+ * +object_path+ ObjectPath containing nameSpace and classname components.
+ *
+ * +flags+ Any combination of the following flags are supported:
+ * Flags::LocalOnly, Flags::DeepInheritance,
+ * Flags::IncludeQualifiers and Flags::IncludeClassOrigin.
+ *
+ * +properties+ If not NULL, the members of the array define one or more
+ * Property names.
+ * Each returned Object MUST NOT include elements for any Properties
+ * missing from this list
+ * 
+ */
+static VALUE instances(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE flags;
+  VALUE properties;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  char **props;
+  VALUE rbenm = Qnil;
+
+  rb_scan_args(argc, argv, "12", &object_path, &flags, &properties);
+  if (NIL_P(flags)) flags = INT2NUM(0);
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  props = sfcc_value_array_to_string_array(properties);
+
+  CMPIEnumeration *enm = client->ft->enumInstances(client, op, NUM2INT(flags), props, &status);
+
+  free(props);
+
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, NULL));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+
+  sfcc_rb_raise_if_error(status, "Can't get instances");
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  associators(object_path, association_class=nil,
+ *              result_class=nil, role=nil, result_role=nil, flags=0
+ *              properties=nil)
+ *
+ * Enumerate instances associated with the Instance defined by the +object_path+
+ * 
+ * +object_path+ Source ObjectPath containing nameSpace, classname
+ * and key components.
+ *
+ * +association_class+ If not nil, MUST be a valid Association Class name.
+ * It acts as a filter on the returned set of Objects by mandating that
+ * each returned Object MUST be associated to the source Object via an
+ * Instance of this Class or one of its subclasses.
+ *
+ * +result_class+ If not nil, MUST be a valid Class name.
+ * It acts as a filter on the returned set of Objects by mandating that
+ * each returned Object MUST be either an Instance of this Class (or one
+ * of its subclasses).
+ *
+ * +role+ If not nil, MUST be a valid Property name.
+ * It acts as a filter on the returned set of Objects by mandating
+ * that each returned Object MUST be associated to the source Object
+ * via an Association in which the source Object plays the specified role
+ * (i.e. the name of the Property in the Association Class that refers
+ * to the source Object MUST match the value of this parameter).
+ *
+ * +result_role+ If not nil, MUST be a valid Property name.
+ * It acts as a filter on the returned set of Objects by mandating
+ * that each returned Object MUST be associated to the source Object
+ * via an Association in which the returned Object plays the specified role
+ * (i.e. the name of the Property in the Association Class that refers to
+ * the returned Object MUST match the value of this parameter).
+ *
+ * +flags+ Any combination of the following flags are supported:
+ * Flags::IncludeQualifiers and Flags::IncludeClassOrigin.
+ *
+ * +properties+ If not nil, the members of the array define one or more Property
+ * names. Each returned Object MUST NOT include elements for any Properties
+ * missing from this list
+ *
+ * returns enumeration of instances
+ */
+static VALUE associators(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE assoc_class;
+  VALUE result_class;
+  VALUE role;
+  VALUE result_role;
+  VALUE flags;
+  VALUE properties;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  char **props;
+  CMPIEnumeration *enm = NULL;
+  VALUE rbenm = Qnil;
+
+  rb_scan_args(argc, argv, "16", &object_path,
+               &assoc_class, &result_class,
+               &role, &result_role, &flags, &properties);
+
+  if (NIL_P(flags)) flags = INT2NUM(0);
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  props = sfcc_value_array_to_string_array(properties);
+
+  enm = client->ft->associators(client,
+                                op,
+                                NIL_P(assoc_class) ? NULL : StringValuePtr(assoc_class),
+                                NIL_P(result_class) ? NULL : StringValuePtr(result_class),
+                                NIL_P(role) ? NULL : StringValuePtr(role),
+                                NIL_P(result_role) ? NULL : StringValuePtr(result_role),
+                                NUM2INT(flags), props, &status);
+  free(props);
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, NULL));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+
+  sfcc_rb_raise_if_error(status, "Can't get associators for '%s'", CMGetCharsPtr(CMObjectPathToString(op, NULL), NULL));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  associator_names(object_path, association_class=nil,
+ *                   result_class=nil, role=nil, result_role=nil, flags=0
+ *                   properties=nil)
+ *
+ * Enumerate object paths associated with the Instance defined by the
+ * +object_path+
+ * 
+ * +object_path+ Source ObjectPath containing nameSpace, classname
+ * and key components.
+ *
+ * +association_class+ If not nil, MUST be a valid Association Class name.
+ * It acts as a filter on the returned set of Objects by mandating that
+ * each returned Object MUST be associated to the source Object via an
+ * Instance of this Class or one of its subclasses.
+ *
+ * +result_class+ If not nil, MUST be a valid Class name.
+ * It acts as a filter on the returned set of Objects by mandating that
+ * each returned Object MUST be either an Instance of this Class (or one
+ * of its subclasses).
+ *
+ * +role+ If not nil, MUST be a valid Property name.
+ * It acts as a filter on the returned set of Objects by mandating
+ * that each returned Object MUST be associated to the source Object
+ * via an Association in which the source Object plays the specified role
+ * (i.e. the name of the Property in the Association Class that refers
+ * to the source Object MUST match the value of this parameter).
+ *
+ * +result_role+ If not nil, MUST be a valid Property name.
+ * It acts as a filter on the returned set of Objects by mandating
+ * that each returned Object MUST be associated to the source Object
+ * via an Association in which the returned Object plays the specified role
+ * (i.e. the name of the Property in the Association Class that refers to
+ * the returned Object MUST match the value of this parameter).
+ *
+ * returns enumeration of object paths
+ */
+static VALUE associator_names(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE assoc_class;
+  VALUE result_class;
+  VALUE role;
+  VALUE result_role;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  CMPIEnumeration *enm = NULL;
+  VALUE rbenm = Qnil;
+
+  rb_scan_args(argc, argv, "14", &object_path,
+               &assoc_class, &result_class,
+               &role, &result_role);
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  enm = client->ft->associatorNames(client,
+                                    op,
+                                    NIL_P(assoc_class) ? NULL : StringValuePtr(assoc_class),
+                                    NIL_P(result_class) ? NULL : StringValuePtr(result_class),
+                                    NIL_P(role) ? NULL : StringValuePtr(role),
+                                    NIL_P(result_role) ? NULL : StringValuePtr(result_role),
+                                    &status);
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, NULL));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+  sfcc_rb_raise_if_error(status, "Can't get associator names for '%s'", CMGetCharsPtr(CMObjectPathToString(op, NULL), NULL));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  references(object_path, result_class=nil, role=nil, flags=0, properties=nil)
+ *
+ * Enumerates the association instances that refer to the instance defined by
+ * +object_path+
+ *
+ * +object_path+ Source ObjectPath containing nameSpace, classname and key components.
+ *
+ * +result_class+ If not nil, MUST be a valid Class name.
+ * It acts as a filter on the returned set of Objects by mandating that
+ * each returned Object MUST be either an Instance of this Class (or one
+ * of its subclasses).
+ *
+ * +role+ If not nil, MUST be a valid Property name.
+ * It acts as a filter on the returned set of Objects by mandating
+ * that each returned Object MUST be associated to the source Object
+ * via an Association in which the source Object plays the specified role
+ * (i.e. the name of the Property in the Association Class that refers
+ * to the source Object MUST match the value of this parameter).
+ *
+ * +flags+ Any combination of the following flags are supported:
+ * Flags::IncludeQualifiers and Flags::IncludeClassOrigin.
+ *
+ * +properties+ If not nil, the members of the array define one or more Property
+ * names. Each returned Object MUST NOT include elements for any Properties
+ * missing from this list
+ *
+ * returns enumeration of ObjectPaths
+ */
+static VALUE references(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path;
+  VALUE result_class;
+  VALUE role;
+  VALUE flags;
+  VALUE properties;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  char **props;
+  CMPIEnumeration *enm = NULL;
+  VALUE rbenm = Qnil;
+
+  rb_scan_args(argc, argv, "14", &object_path,
+               &result_class, &role,
+               &flags, &properties);
+
+  if (NIL_P(flags)) flags = INT2NUM(0);
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  props = sfcc_value_array_to_string_array(properties);
+
+  enm = client->ft->references(client,
+                               op,
+                               NIL_P(result_class) ? NULL : StringValuePtr(result_class),
+                               NIL_P(role) ? NULL : StringValuePtr(role),
+                               NUM2INT(flags), props, &status);
+  free(props);
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, NULL));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+  sfcc_rb_raise_if_error(status, "Can't get references for '%s'", CMGetCharsPtr(CMObjectPathToString(op, NULL), NULL));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *  reference_names(object_path, result_class=nil, role=nil, flags=0, properties=nil)
+ *
+ * Enumerates the association instances that refer to the instance defined by
+ * +object_path+
+ *
+ * +object_path+ Source ObjectPath containing nameSpace, classname and key components.
+ *
+ * +result_class+ If not nil, MUST be a valid Class name.
+ * It acts as a filter on the returned set of Objects by mandating that
+ * each returned Object MUST be either an Instance of this Class (or one
+ * of its subclasses).
+ *
+ * +role+ If not nil, MUST be a valid Property name.
+ * It acts as a filter on the returned set of Objects by mandating
+ * that each returned Object MUST be associated to the source Object
+ * via an Association in which the source Object plays the specified role
+ * (i.e. the name of the Property in the Association Class that refers
+ * to the source Object MUST match the value of this parameter).
+ *
+ * returns enumeration of ObjectPaths
+ */
+static VALUE reference_names(int argc, VALUE *argv, VALUE self)
+{
+  VALUE object_path = Qnil;
+  VALUE result_class = Qnil;
+  VALUE role = Qnil;
+
+  CMPIStatus status;
+  CMPIObjectPath *op = NULL;
+  CMCIClient *client = NULL;
+  CMPIEnumeration *enm = NULL;
+  VALUE rbenm = Qnil;
+
+  rb_scan_args(argc, argv, "14", &object_path,
+               &result_class, &role);
+
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, client);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  enm = client->ft->referenceNames(client,
+                                   op,
+                                   NIL_P(result_class) ? NULL : StringValuePtr(result_class),
+                                   NIL_P(role) ? NULL : StringValuePtr(role),
+                                   &status);
+  if (enm && !status.rc ) {
+    rbenm = Sfcc_wrap_cim_enumeration(enm->ft->clone(enm, &status));
+    enm->ft->release(enm);
+    return rbenm;
+  }
+  sfcc_rb_raise_if_error(status, "Can't get reference names for '%s'", CMGetCharsPtr(CMObjectPathToString(op, NULL), NULL));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   invoke_method(object_path, method_name, argin, argout)
+ *
+ * Invoke a named, extrinsic method of an instance defined by +object_path+
+ *
+ * +object_path+ containing namespace, classname, and key
+ * components.
+ *
+ * +argin+ hash containing the input parameters (keys can be symbols) or
+ * strings.
+ *
+ * +argout+ hash where output parameters will be returned
+ */
+static VALUE invoke_method(VALUE self,
+                           VALUE object_path,
+                           VALUE method_name,
+                           VALUE argin,
+                           VALUE argout)
+{
+  CMPIStatus status;
+  CMCIClient *ptr = NULL;
+  CMPIObjectPath *op = NULL;
+  CMPIArgs *cmpiargsout;
+  VALUE method_name_str;
+  char *method_name_cstr;
+  CMPIData ret;
+  Check_Type(argin, T_HASH);
+  memset(&status, 0, sizeof(CMPIStatus));
+
+  cmpiargsout = newCMPIArgs(NULL);
+
+  Data_Get_Struct(self, CMCIClient, ptr);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+
+  method_name_str = rb_funcall(method_name, rb_intern("to_s"), 0);
+  method_name_cstr = StringValuePtr(method_name_str);
+  ret = ptr->ft->invokeMethod(ptr,
+                              op,
+                              method_name_cstr,
+                              sfcc_hash_to_cimargs(argin),
+                              cmpiargsout,
+                              &status);
+  if (!status.rc) {
+    if (cmpiargsout && ! NIL_P(argout)) {
+      Check_Type(argout, T_HASH);
+      rb_funcall(argout, rb_intern("merge!"), 1, sfcc_cimargs_to_hash(cmpiargsout));
+    }
+    return sfcc_cimdata_to_value(ret);
+  }
+  sfcc_rb_raise_if_error(status, "Can't invoke method '%s'", method_name_cstr);
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   set_property(object_path, name, value)
+ *
+ * Sets the named property value of an instance defined by
+ * +object_path+
+ *
+ * +object_path+ containing namespace, classname, and key
+ * components.
+ */
+static VALUE set_property(VALUE self,
+                          VALUE object_path,
+                          VALUE name,
+                          VALUE value)
+{
+  CMPIStatus status;
+  CMCIClient *ptr = NULL;
+  CMPIObjectPath *op = NULL;
+  CMPIData data;
+  Data_Get_Struct(self, CMCIClient, ptr);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+  data = sfcc_value_to_cimdata(value);
+  status = ptr->ft->setProperty(ptr, op, StringValuePtr(name), &data.value, data.type);
+
+  if ( !status.rc )
+    return value;
+  sfcc_rb_raise_if_error(status, "Can't set property '%s'", StringValuePtr(name));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   property(object_path, name)
+ *
+ * Gets the named property value of an instance defined by
+ * +object_path+
+ *
+ * +object_path+ containing namespace, classname, and key
+ * components.
+ */
+static VALUE property(VALUE self, VALUE object_path, VALUE name)
+{
+  CMCIClient *ptr = NULL;
+  CMPIObjectPath *op = NULL;
+  CMPIStatus status;
+  CMPIData data;
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMCIClient, ptr);
+  Data_Get_Struct(object_path, CMPIObjectPath, op);
+  data = ptr->ft->getProperty(ptr, op, StringValuePtr(name), &status);
+  if ( !status.rc )
+    return sfcc_cimdata_to_value(data);
+
+  sfcc_rb_raise_if_error(status, "Can't retrieve property '%s'", StringValuePtr(name));
+  return Qnil;
+}
+
+static VALUE connect(VALUE klass, VALUE host, VALUE scheme, VALUE port, VALUE user, VALUE pwd)
+{
+  CMCIClient *client = NULL;
+  CMPIStatus status;
+  client = cmciConnect(NIL_P(host) ? NULL : StringValuePtr(host),
+                       NIL_P(scheme) ? NULL : StringValuePtr(scheme),
+                       NIL_P(port) ? NULL : StringValuePtr(port),
+                       NIL_P(user) ? NULL : StringValuePtr(user),
+                       NIL_P(pwd) ? NULL : StringValuePtr(pwd),
+                       &status);
+  if ( !status.rc )
+    return Sfcc_wrap_cim_client(client);
+  sfcc_rb_raise_if_error(status, "Can't create CIM client");
+  return Qnil;
+}
+
+VALUE
+Sfcc_wrap_cim_client(CMCIClient *client)
+{
+  assert(client);
+  SFCC_INC_REFCOUNT(client);
+  return Data_Wrap_Struct(cSfccCimClient, NULL, dealloc, client);
+}
+
+VALUE cSfccCimClient;
+void init_cim_client()
+{
+  VALUE sfcc = rb_define_module("Sfcc");
+  VALUE cimc = rb_define_module_under(sfcc, "Cim");
+
+  /**
+   * CIM client which can communicate with a CIMOM
+   */
+  VALUE klass = rb_define_class_under(cimc, "Client", rb_cObject);
+  cSfccCimClient = klass;
+
+  rb_define_singleton_method(klass, "native_connect", connect, 5);
+  rb_define_method(klass, "get_class", get_class, -1);
+  rb_define_method(klass, "class_names", class_names, -1);
+  rb_define_method(klass, "classes", classes, -1);
+  rb_define_method(klass, "get_instance", get_instance, -1);
+  rb_define_method(klass, "create_instance", create_instance, 2);
+  rb_define_method(klass, "set_instance", set_instance, -1);
+  rb_define_method(klass, "delete_instance", delete_instance, 1);  
+  rb_define_method(klass, "query", query, 3);
+  rb_define_method(klass, "instance_names", instance_names, 1);
+  rb_define_method(klass, "instances", instances, -1);
+  rb_define_method(klass, "associators", associators, -1);
+  rb_define_method(klass, "associator_names", associator_names, -1);
+  rb_define_method(klass, "references", references, -1);
+  rb_define_method(klass, "reference_names", reference_names, -1);
+  rb_define_method(klass, "invoke_method", invoke_method, 4);
+  rb_define_method(klass, "set_property", set_property, 3);
+  rb_define_method(klass, "property", property, 2);
+}