openwsman 2.3.0 → 2.3.2

data/ext/openwsman/openwsman_wrap.c

@@ -1828,7 +1828,7 @@ static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0};
 
 /* -------- TYPES TABLE (END) -------- */
 
-#define SWIG_init    Init_openwsman
+#define SWIG_init    Init_Openwsman
 #define SWIG_name    "Openwsman"
 
 static VALUE mOpenwsman;
@@ -1877,9 +1877,12 @@ static VALUE mOpenwsman;
 #if defined(SWIGRUBY)
 #include <ruby/helpers.h>
 
-SWIGEXPORT void Init_openwsman(void);
+/* Init_ for the %module, defined by Swig */
+SWIGEXPORT void Init_Openwsman(void);
+
+/* Init_ for the .so lib, called by Ruby */
 SWIGEXPORT void Init__openwsman(void) {
-  Init_openwsman();
+  Init_Openwsman();
 }
 #endif
 #if defined(SWIGPYTHON)
@@ -1931,6 +1934,102 @@ static WsXmlDocH create_doc_from_file(const char *filename, const char *encoding
   return xml_parser_file_to_doc( filename, encoding, 0);                 
 }
 
+static WsXmlDocH create_doc_from_string(const char *buf, const char *encoding);
+
+static WsXmlDocH create_doc_from_string(const char *buf, const char *encoding) {
+  return xml_parser_memory_to_doc( buf, strlen(buf), encoding, 0);
+}
+
+static char *uri_classname(const char *uri);
+/* get classname from resource URI */
+static char *uri_classname(const char *uri) {
+  const char *lastslash = strrchr(uri,'/');
+  if (lastslash) {
+    return strdup(lastslash+1);
+  }
+  return NULL;
+}
+
+
+static const char *uri_prefix(const char *classname);
+/* get resource URI prefix for a specific classname (resp class schema) */
+static const char *uri_prefix(const char *classname) {
+  static struct map {
+    int len;
+    const char *schema;
+    const char *prefix;
+  } mapping[] = {
+    /* dmtf CIM */
+    { 3, "CIM", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2" },
+    /* dmtf reserved */
+    { 3, "PRS", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2" },
+    /* Microsoft WMI */
+    { 5, "Win32", "http://schemas.microsoft.com/wbem/wsman/1/wmi" },
+    /* openwbem.org */
+    { 8, "OpenWBEM", "http://schema.openwbem.org/wbem/wscim/1/cim-schema/2" },
+    /* sblim */
+    { 5, "Linux", "http://sblim.sf.net/wbem/wscim/1/cim-schema/2" },
+    /* omc-project */
+    { 3, "OMC", "http://schema.omc-project.org/wbem/wscim/1/cim-schema/2" },
+    /* pegasus.org */
+    { 2, "PG", "http://schema.openpegasus.org/wbem/wscim/1/cim-schema/2" },
+    /* Intel AMT */
+    { 3, "AMT", "http://intel.com/wbem/wscim/1/amt-schema/1" },
+    /* Intel */
+    { 3, "IPS", "http://intel.com/wbem/wscim/1/ips-schema/1" },
+    { 0, NULL, NULL }
+  };
+  const char *schema_end;
+  struct map *map;
+  int len;
+  if (classname == NULL)
+    return NULL;
+  schema_end = strchr(classname, '_');
+  if (schema_end == NULL)
+    return NULL; /* Bad class name */
+  len = schema_end - classname;
+  map = mapping;
+  while (map->len > 0) {
+    if ((len == map->len)
+        && (strncmp(classname, map->schema, map->len) == 0)) {
+      return map->prefix;
+    }
+    ++map;
+  }
+  return NULL;
+}
+
+
+static epr_t *my_epr_deserialize(WsXmlNodeH node);
+static epr_t *my_epr_deserialize(WsXmlNodeH node) {
+  fprintf(stderr, "my_epr_deserialize(%s)\n", ws_xml_get_node_local_name(node));
+  if (strcmp(WSA_EPR, ws_xml_get_node_local_name(node)) == 0) {
+    /* Use node as-is if its already a WSA_EPR */
+    return epr_deserialize(node, NULL, NULL, 1);
+  }
+  /* else search the WSA_EPR node */
+  return epr_deserialize(node, XML_NS_ADDRESSING, WSA_EPR, 1);
+}
+
+
+static char *epr_prefix(const char *uri);
+/* Get prefix from a EPR uri */
+static char *epr_prefix(const char *uri) {
+  char *classname = uri_classname(uri);
+  const char *prefix = uri_prefix(classname);
+  if (prefix) {
+    const char *lastslash;
+    if (strncmp(uri, prefix, strlen(prefix)) == 0) {
+      return strdup(prefix);
+    }
+    lastslash = strrchr(uri, '/');
+    if (lastslash) {
+      return strndup(uri, lastslash-uri);
+    }
+  }
+  return strdup(uri);
+}
+
 
 
 #include <limits.h>
@@ -2237,8 +2336,19 @@ SWIGINTERN WsXmlNodeH __WsXmlNode_get__SWIG_1(struct __WsXmlNode *self,char cons
 
 
   }
-SWIGINTERN WsXmlAttrH __WsXmlNode_attr(struct __WsXmlNode *self,int index){
-    return ws_xml_get_node_attr( self, index );
+SWIGINTERN WsXmlAttrH __WsXmlNode_attr(struct __WsXmlNode *self,VALUE index,VALUE namespace){
+    if (NIL_P(index)) { /* nil */
+      return ws_xml_get_node_attr( self, 0 );
+    } else if (FIXNUM_P(index)) { /* numeric */
+      return ws_xml_get_node_attr( self, FIX2INT(index) );      
+    } else { /* convert to string */
+      const char *ns = NULL;
+      const char *name = as_string(index);
+      if (!NIL_P(namespace)) {
+        ns = as_string(namespace);
+      }
+      return ws_xml_find_node_attr( self, ns, name );
+    }
   }
 SWIGINTERN int __WsXmlNode_attr_count(struct __WsXmlNode *self){
     return ws_xml_get_node_attr_count( self );
@@ -2271,8 +2381,34 @@ SWIGINTERN char *__WsXmlAttr_value(struct __WsXmlAttr *self){
 SWIGINTERN void __WsXmlAttr_remove(struct __WsXmlAttr *self){
     ws_xml_remove_node_attr( self );
   }
-SWIGINTERN epr_t *new_epr_t(char const *uri,char const *address){
-    return epr_create( uri, NULL, address);
+SWIGINTERN epr_t *new_epr_t(VALUE uri,VALUE address,VALUE selectors){
+    extern swig_class SwigClassXmlNode;
+    extern swig_class SwigClassXmlDoc;
+    if (!NIL_P(address)) {
+      const char *uri_s = as_string(uri);
+      const char *address_s = as_string(uri);
+      return epr_create(uri_s, value2hash(NULL,selectors), address_s);
+    }
+    else if (CLASS_OF(uri) == SwigClassXmlNode.klass) {
+      WsXmlNodeH node;
+      SWIG_ConvertPtr(uri, (void **)&node, SWIGTYPE_p___WsXmlNode, 0);
+      return my_epr_deserialize(node);
+    }
+    else if (CLASS_OF(uri) == SwigClassXmlDoc.klass) {
+      WsXmlDocH doc;
+      WsXmlNodeH node;
+      SWIG_ConvertPtr(uri, (void **)&doc, SWIGTYPE_p__WsXmlDoc, 0);
+      node = ws_xml_get_soap_body(doc);
+      if (node == NULL)
+        node = ws_xml_get_doc_root(doc);
+      return my_epr_deserialize(node);
+    }
+    else {
+      return epr_from_string(as_string(uri));
+    }
+  }
+SWIGINTERN epr_t *epr_t_clone(epr_t *self,epr_t *epr){
+    return epr_copy(epr);
   }
 SWIGINTERN void epr_t_add_selector(epr_t *self,char const *name,char const *text){
     epr_add_selector_text(self, name, text);
@@ -2281,13 +2417,14 @@ SWIGINTERN int epr_t_serialize(epr_t *self,WsXmlNodeH node,char const *ns,char c
     return epr_serialize(node, ns, epr_node_name, self, embedded);
   }
 SWIGINTERN int epr_t_cmp(epr_t *self,epr_t *epr2){
+    fprintf(stderr, "%p.cmp(%p)\n", self, epr2);
     return epr_cmp(self, epr2);
   }
 SWIGINTERN char *epr_t_to_xml(epr_t *self,char const *ns,char const *epr_node_name){
-    return epr_to_txt(self, ns, epr_node_name);
+    return epr_to_txt(self, ns?ns:"http://schemas.xmlsoap.org/ws/2004/08/addressing", epr_node_name?epr_node_name:"EndpointReference");
   }
 SWIGINTERN char *epr_t_string(epr_t *self){
-	  return epr_to_txt(self, "http://www.w3.org/2003/05/soap-envelope", "Header");
+    return epr_to_string(self);
   }
 SWIGINTERN int epr_t_selector_count(epr_t *self){
     return epr_selector_count(self);
@@ -2295,8 +2432,77 @@ SWIGINTERN int epr_t_selector_count(epr_t *self){
 SWIGINTERN char *epr_t_resource_uri(epr_t *self){
     return epr_get_resource_uri(self);
   }
-SWIGINTERN char *epr_t_selector(epr_t *self,char const *name){
-  	return wsman_epr_selector_by_name(self, name);
+SWIGINTERN char *epr_t_selector(epr_t *self,VALUE v){
+    const char *name = as_string(v);
+
+
+
+    return wsman_epr_selector_by_name(self, name);
+  }
+SWIGINTERN VALUE epr_t_selector_names(epr_t *self){
+    int i;
+    VALUE ary = rb_ary_new2(self->refparams.selectorset.count);
+    Selector *p = self->refparams.selectorset.selectors;
+    for (i = 0; i < self->refparams.selectorset.count; i++) {
+      rb_ary_store(ary, i, SWIG_FromCharPtr(p->name));
+      ++p;
+    }
+    return ary;
+  }
+SWIGINTERN void epr_t_each(epr_t *self){
+    int i;
+    Selector *p = NULL;
+    VALUE value, ary;
+    p = self->refparams.selectorset.selectors;
+    for (i = 0; i < self->refparams.selectorset.count; i++) {
+      ary = rb_ary_new2(2);
+      rb_ary_store(ary, 0, SWIG_FromCharPtr(p->name));
+      if (p->type == 0) {
+        value = SWIG_FromCharPtr(p->value);
+      } else {
+        char *epr_value = epr_to_string((epr_t *)p->value);
+        value = SWIG_FromCharPtr(epr_value);
+        u_free(epr_value);
+      }
+      rb_ary_store(ary, 1, value);
+      rb_yield(ary);
+      p++;
+    }
+  }
+SWIGINTERN char *epr_t_classname(epr_t *self){
+    return uri_classname(self->refparams.uri);
+  }
+SWIGINTERN char *epr_t_namespace(epr_t *self){
+    char *classname;
+    int classnamelen, namespacelen;
+    const char *prefix;
+    const char *uri;
+
+    /* try to get namespace from selectors (WS-Management style) */
+    char *ns = get_cimnamespace_from_selectorset(&(self->refparams.selectorset));
+    if (ns) {
+      return strdup(ns);
+    }
+    /* WMI style? - extract namespace from uri */
+
+    uri = self->refparams.uri;
+    prefix = epr_prefix(uri);
+    if (prefix == NULL) {
+      return NULL; /* bad classname in URI */
+    }
+    classname = uri_classname(uri);
+    if (classname == NULL)
+      return NULL; /* bad URI */
+    classnamelen = strlen(classname);
+    free(classname);
+    namespacelen = strlen(uri) - classnamelen - strlen(prefix) - 2; /* drop enclosing slashes */
+    if (namespacelen <= 0)
+      return strdup("");
+    /* copy after prefix slash (+ 1) */
+    return strndup(uri + strlen(prefix) + 1, namespacelen);
+  }
+SWIGINTERN char *epr_t_prefix(epr_t *self){
+    return epr_prefix(self->refparams.uri);
   }
 SWIGINTERN filter_t *new_filter_t(){
     return filter_initialize();
@@ -2713,9 +2919,15 @@ SWIGINTERN void client_opt_t_clear_dump_request(client_opt_t *self){
 SWIGINTERN void client_opt_t_set_flags(client_opt_t *self,int flags){
     wsmc_set_action_option(self, flags);
   }
+SWIGINTERN unsigned int client_opt_t_get_flags(client_opt_t *self){
+    return wsmc_get_action_option(self);
+  }
 SWIGINTERN void client_opt_t_clear_flags(client_opt_t *self,int flags){
     wsmc_clear_action_option(self, flags);
   }
+SWIGINTERN void client_opt_t_reset_flags(client_opt_t *self){
+    wsmc_clear_action_option(self, ~0x0000);
+  }
 SWIGINTERN void client_opt_t_set_max_envelope_size(client_opt_t *self,unsigned long size){
     self->max_envelope_size = size;
   }
@@ -3133,15 +3345,17 @@ _wrap_XmlDoc_dump_file(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (struct _WsXmlDoc *)(argp1);
   {
-    struct OpenFile *fptr;
+    struct rb_io_t *fptr;
+    
+    
     
     Check_Type(argv[0], T_FILE);
     GetOpenFile(argv[0], fptr);
     /*rb_io_check_writable(fptr);*/
     
+    arg2 = rb_io_stdio_file(fptr);
     
     
-    arg2 = GetReadFile(fptr);
     
   }
   _WsXmlDoc_dump_file(arg1,arg2);
@@ -3636,15 +3850,17 @@ _wrap_XmlNode_dump_file(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (struct __WsXmlNode *)(argp1);
   {
-    struct OpenFile *fptr;
+    struct rb_io_t *fptr;
+    
+    
     
     Check_Type(argv[0], T_FILE);
     GetOpenFile(argv[0], fptr);
     /*rb_io_check_writable(fptr);*/
     
+    arg2 = rb_io_stdio_file(fptr);
     
     
-    arg2 = GetReadFile(fptr);
     
   }
   __WsXmlNode_dump_file(arg1,arg2);
@@ -4759,7 +4975,7 @@ fail:
   Document-method: Openwsman::XmlNode.attr
 
   call-seq:
-    attr(int index=0) -> WsXmlAttrH
+    attr(VALUE index=Qnil, VALUE namespace=Qnil) -> WsXmlAttrH
 
 An instance method.
 
@@ -4767,15 +4983,14 @@ An instance method.
 SWIGINTERN VALUE
 _wrap_XmlNode_attr(int argc, VALUE *argv, VALUE self) {
   struct __WsXmlNode *arg1 = (struct __WsXmlNode *) 0 ;
-  int arg2 = (int) 0 ;
+  VALUE arg2 = (VALUE) Qnil ;
+  VALUE arg3 = (VALUE) Qnil ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
   WsXmlAttrH result;
   VALUE vresult = Qnil;
   
-  if ((argc < 0) || (argc > 1)) {
+  if ((argc < 0) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p___WsXmlNode, 0 |  0 );
@@ -4784,13 +4999,12 @@ _wrap_XmlNode_attr(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (struct __WsXmlNode *)(argp1);
   if (argc > 0) {
-    ecode2 = SWIG_AsVal_int(argv[0], &val2);
-    if (!SWIG_IsOK(ecode2)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","attr", 2, argv[0] ));
-    } 
-    arg2 = (int)(val2);
+    arg2 = argv[0];
+  }
+  if (argc > 1) {
+    arg3 = argv[1];
   }
-  result = (WsXmlAttrH)__WsXmlNode_attr(arg1,arg2);
+  result = (WsXmlAttrH)__WsXmlNode_attr(arg1,arg2,arg3);
   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p___WsXmlAttr, 0 |  0 );
   return vresult;
 fail:
@@ -5203,88 +5417,6 @@ fail:
 */
 swig_class SwigClassEndPointReference;
 
-
-/*
-  Document-method: Openwsman::EndPointReference.address
-
-  call-seq:
-    address -> char
-
-Get value of attribute.
-
-*/
-
-/*
-  Document-method: Openwsman::EndPointReference.address=
-
-  call-seq:
-    address=(x) -> char
-
-Set new value for attribute.
-
-*/
-SWIGINTERN VALUE
-_wrap_EndPointReference_address_set(int argc, VALUE *argv, VALUE self) {
-  epr_t *arg1 = (epr_t *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","address", 1, self )); 
-  }
-  arg1 = (epr_t *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","address", 2, argv[0] ));
-  }
-  arg2 = (char *)(buf2);
-  if (arg1->address) free((char*)arg1->address);
-  if (arg2) {
-    size_t size = strlen((const char *)(arg2)) + 1;
-    arg1->address = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
-  } else {
-    arg1->address = 0;
-  }
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return Qnil;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_EndPointReference_address_get(int argc, VALUE *argv, VALUE self) {
-  epr_t *arg1 = (epr_t *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  char *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","address", 1, self )); 
-  }
-  arg1 = (epr_t *)(argp1);
-  result = (char *) ((arg1)->address);
-  vresult = SWIG_FromCharPtr((const char *)result);
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
 _wrap_EndPointReference_allocate(VALUE self) {
@@ -5307,44 +5439,32 @@ _wrap_EndPointReference_allocate(VALUE self) {
   Document-method: Openwsman::EndPointReference.new
 
   call-seq:
-    EndPointReference.new(char uri, char address)
+    EndPointReference.new(VALUE uri, VALUE address=Qnil, VALUE selectors=Qnil)
 
 Class constructor.
 
 */
 SWIGINTERN VALUE
 _wrap_new_EndPointReference(int argc, VALUE *argv, VALUE self) {
-  char *arg1 = (char *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
+  VALUE arg1 = (VALUE) 0 ;
+  VALUE arg2 = (VALUE) Qnil ;
+  VALUE arg3 = (VALUE) Qnil ;
   epr_t *result = 0 ;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","epr_t", 1, argv[0] ));
+  arg1 = argv[0];
+  if (argc > 1) {
+    arg2 = argv[1];
   }
-  arg1 = (char *)(buf1);
-  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","epr_t", 2, argv[1] ));
+  if (argc > 2) {
+    arg3 = argv[2];
   }
-  arg2 = (char *)(buf2);
-  result = (epr_t *)new_epr_t((char const *)arg1,(char const *)arg2);
+  result = (epr_t *)new_epr_t(arg1,arg2,arg3);
   DATA_PTR(self) = result;
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return self;
 fail:
-  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return Qnil;
 }
 
@@ -5358,6 +5478,47 @@ free_epr_t(epr_t *arg1) {
 }
 
 
+/*
+  Document-method: Openwsman::EndPointReference.clone
+
+  call-seq:
+    clone(epr) -> EndPointReference
+
+Create a duplicate of the class.
+*/
+SWIGINTERN VALUE
+_wrap_EndPointReference_clone(int argc, VALUE *argv, VALUE self) {
+  epr_t *arg1 = (epr_t *) 0 ;
+  epr_t *arg2 = (epr_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  epr_t *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","clone", 1, self )); 
+  }
+  arg1 = (epr_t *)(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_epr_t, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "epr_t *","clone", 2, argv[0] )); 
+  }
+  arg2 = (epr_t *)(argp2);
+  result = (epr_t *)epr_t_clone(arg1,arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_epr_t, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
 /*
   Document-method: Openwsman::EndPointReference.add_selector
 
@@ -5517,7 +5678,7 @@ _wrap_EndPointReference_cmp(int argc, VALUE *argv, VALUE self) {
   }
   arg2 = (epr_t *)(argp2);
   result = (int)epr_t_cmp(arg1,arg2);
-  vresult = SWIG_From_int((int)(result));
+  vresult = (result == 0) ? Qtrue : Qfalse;
   return vresult;
 fail:
   return Qnil;
@@ -5529,7 +5690,7 @@ fail:
   Document-method: Openwsman::EndPointReference.to_xml
 
   call-seq:
-    to_xml(char ns, char epr_node_name) -> char
+    to_xml(char ns=nil, char epr_node_name=nil) -> char
 
 An instance method.
 
@@ -5537,8 +5698,8 @@ An instance method.
 SWIGINTERN VALUE
 _wrap_EndPointReference_to_xml(int argc, VALUE *argv, VALUE self) {
   epr_t *arg1 = (epr_t *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
+  char *arg2 = (char *) NULL ;
+  char *arg3 = (char *) NULL ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 ;
@@ -5550,24 +5711,28 @@ _wrap_EndPointReference_to_xml(int argc, VALUE *argv, VALUE self) {
   char *result = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","to_xml", 1, self )); 
   }
   arg1 = (epr_t *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","to_xml", 2, argv[0] ));
+  if (argc > 0) {
+    res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","to_xml", 2, argv[0] ));
+    }
+    arg2 = (char *)(buf2);
   }
-  arg2 = (char *)(buf2);
-  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","to_xml", 3, argv[1] ));
+  if (argc > 1) {
+    res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","to_xml", 3, argv[1] ));
+    }
+    arg3 = (char *)(buf3);
   }
-  arg3 = (char *)(buf3);
   result = (char *)epr_t_to_xml(arg1,(char const *)arg2,(char const *)arg3);
   vresult = SWIG_FromCharPtr((const char *)result);
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
@@ -5582,16 +5747,16 @@ fail:
 
 
 /*
-  Document-method: Openwsman::EndPointReference.string
+  Document-method: Openwsman::EndPointReference.to_s
 
   call-seq:
-    string -> char
+    to_s -> char
 
 An instance method.
 
 */
 SWIGINTERN VALUE
-_wrap_EndPointReference_string(int argc, VALUE *argv, VALUE self) {
+_wrap_EndPointReference_to_s(int argc, VALUE *argv, VALUE self) {
   epr_t *arg1 = (epr_t *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -5688,7 +5853,7 @@ fail:
   Document-method: Openwsman::EndPointReference.selector
 
   call-seq:
-    selector(char name) -> char
+    selector(VALUE v) -> char
 
 An instance method.
 
@@ -5696,12 +5861,9 @@ An instance method.
 SWIGINTERN VALUE
 _wrap_EndPointReference_selector(int argc, VALUE *argv, VALUE self) {
   epr_t *arg1 = (epr_t *) 0 ;
-  char *arg2 = (char *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
   char *result = 0 ;
   VALUE vresult = Qnil;
   
@@ -5713,17 +5875,180 @@ _wrap_EndPointReference_selector(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","selector", 1, self )); 
   }
   arg1 = (epr_t *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","selector", 2, argv[0] ));
+  arg2 = argv[0];
+  result = (char *)epr_t_selector(arg1,arg2);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Openwsman::EndPointReference.selector_names
+
+  call-seq:
+    selector_names(void ?) -> VALUE
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_EndPointReference_selector_names(int argc, VALUE *argv, VALUE self) {
+  epr_t *arg1 = (epr_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  arg2 = (char *)(buf2);
-  result = (char *)epr_t_selector(arg1,(char const *)arg2);
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","selector_names", 1, self )); 
+  }
+  arg1 = (epr_t *)(argp1);
+  result = (VALUE)epr_t_selector_names(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Openwsman::EndPointReference.each
+
+  call-seq:
+    each
+
+Iterate thru each element in the EndPointReference.  A block must be provided.
+*/
+SWIGINTERN VALUE
+_wrap_EndPointReference_each(int argc, VALUE *argv, VALUE self) {
+  epr_t *arg1 = (epr_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","each", 1, self )); 
+  }
+  arg1 = (epr_t *)(argp1);
+  epr_t_each(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Openwsman::EndPointReference.classname
+
+  call-seq:
+    classname(void ?) -> char
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_EndPointReference_classname(int argc, VALUE *argv, VALUE self) {
+  epr_t *arg1 = (epr_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  char *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","classname", 1, self )); 
+  }
+  arg1 = (epr_t *)(argp1);
+  result = (char *)epr_t_classname(arg1);
   vresult = SWIG_FromCharPtr((const char *)result);
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  free(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Openwsman::EndPointReference.namespace
+
+  call-seq:
+    namespace(void ?) -> char
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_EndPointReference_namespace(int argc, VALUE *argv, VALUE self) {
+  epr_t *arg1 = (epr_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  char *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","namespace", 1, self )); 
+  }
+  arg1 = (epr_t *)(argp1);
+  result = (char *)epr_t_namespace(arg1);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  free(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Openwsman::EndPointReference.prefix
+
+  call-seq:
+    prefix(void ?) -> char
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_EndPointReference_prefix(int argc, VALUE *argv, VALUE self) {
+  epr_t *arg1 = (epr_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  char *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_epr_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "epr_t *","prefix", 1, self )); 
+  }
+  arg1 = (epr_t *)(argp1);
+  result = (char *)epr_t_prefix(arg1);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  free(result);
   return vresult;
 fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return Qnil;
 }
 
@@ -12122,6 +12447,40 @@ fail:
 
 
 
+/*
+  Document-method: Openwsman::ClientOptions.flags
+
+  call-seq:
+    flags -> unsigned int
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_ClientOptions_flags(int argc, VALUE *argv, VALUE self) {
+  client_opt_t *arg1 = (client_opt_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_client_opt_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "client_opt_t *","get_flags", 1, self )); 
+  }
+  arg1 = (client_opt_t *)(argp1);
+  result = (unsigned int)client_opt_t_get_flags(arg1);
+  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
 /*
   Document-method: Openwsman::ClientOptions.clear_flags
 
@@ -12161,6 +12520,37 @@ fail:
 
 
 
+/*
+  Document-method: Openwsman::ClientOptions.reset_flags
+
+  call-seq:
+    reset_flags
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_ClientOptions_reset_flags(int argc, VALUE *argv, VALUE self) {
+  client_opt_t *arg1 = (client_opt_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_client_opt_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "client_opt_t *","reset_flags", 1, self )); 
+  }
+  arg1 = (client_opt_t *)(argp1);
+  client_opt_t_reset_flags(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
 /*
   Document-method: Openwsman::ClientOptions.max_envelope_size=
 
@@ -13346,15 +13736,17 @@ _wrap_Client_dumpfilee___(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (WsManClient *)(argp1);
   {
-    struct OpenFile *fptr;
+    struct rb_io_t *fptr;
+    
+    
     
     Check_Type(argv[0], T_FILE);
     GetOpenFile(argv[0], fptr);
     /*rb_io_check_writable(fptr);*/
     
+    arg2 = rb_io_stdio_file(fptr);
     
     
-    arg2 = GetReadFile(fptr);
     
   }
   WsManClient_set_dumpfile(arg1,arg2);
@@ -14847,6 +15239,93 @@ fail:
 
 
 
+/*
+  Document-method: Openwsman.create_doc_from_string
+
+  call-seq:
+    create_doc_from_string(char buf, char encoding="UTF-8") -> WsXmlDocH
+
+A module function.
+
+*/
+SWIGINTERN VALUE
+_wrap_create_doc_from_string(int argc, VALUE *argv, VALUE self) {
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) "UTF-8" ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  WsXmlDocH result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","create_doc_from_string", 1, argv[0] ));
+  }
+  arg1 = (char *)(buf1);
+  if (argc > 1) {
+    res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","create_doc_from_string", 2, argv[1] ));
+    }
+    arg2 = (char *)(buf2);
+  }
+  result = (WsXmlDocH)create_doc_from_string((char const *)arg1,(char const *)arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__WsXmlDoc, 0 |  0 );
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return vresult;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Openwsman.uri_prefix
+
+  call-seq:
+    uri_prefix(char classname) -> char
+
+A module function.
+
+*/
+SWIGINTERN VALUE
+_wrap_uri_prefix(int argc, VALUE *argv, VALUE self) {
+  char *arg1 = (char *) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  char *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","uri_prefix", 1, argv[0] ));
+  }
+  arg1 = (char *)(buf1);
+  result = (char *)uri_prefix((char const *)arg1);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  return vresult;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+  return Qnil;
+}
+
+
+
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
@@ -15219,7 +15698,7 @@ SWIG_PropagateClientData(void) {
 #ifdef __cplusplus
 extern "C"
 #endif
-SWIGEXPORT void Init_openwsman(void) {
+SWIGEXPORT void Init_Openwsman(void) {
   size_t i;
   
   SWIG_InitRuntime();
@@ -15233,8 +15712,8 @@ SWIGEXPORT void Init_openwsman(void) {
   SWIG_RubyInitializeTrackings();
   rb_define_const(mOpenwsman, "OPENWSMAN_MAJOR", SWIG_From_int((int)(2)));
   rb_define_const(mOpenwsman, "OPENWSMAN_MINOR", SWIG_From_int((int)(3)));
-  rb_define_const(mOpenwsman, "OPENWSMAN_PATCH", SWIG_From_int((int)(0)));
-  rb_define_const(mOpenwsman, "OPENWSMAN_VERSION", SWIG_FromCharPtr("2.3.0"));
+  rb_define_const(mOpenwsman, "OPENWSMAN_PATCH", SWIG_From_int((int)(2)));
+  rb_define_const(mOpenwsman, "OPENWSMAN_VERSION", SWIG_FromCharPtr("2.3.2"));
   
   SwigClassXmlNs.klass = rb_define_class_under(mOpenwsman, "XmlNs", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p___WsXmlNs, (void *) &SwigClassXmlNs);
@@ -15611,16 +16090,21 @@ SWIGEXPORT void Init_openwsman(void) {
   SWIG_TypeClientData(SWIGTYPE_p_epr_t, (void *) &SwigClassEndPointReference);
   rb_define_alloc_func(SwigClassEndPointReference.klass, _wrap_EndPointReference_allocate);
   rb_define_method(SwigClassEndPointReference.klass, "initialize", _wrap_new_EndPointReference, -1);
-  rb_define_method(SwigClassEndPointReference.klass, "address=", _wrap_EndPointReference_address_set, -1);
-  rb_define_method(SwigClassEndPointReference.klass, "address", _wrap_EndPointReference_address_get, -1);
+  rb_define_method(SwigClassEndPointReference.klass, "clone", _wrap_EndPointReference_clone, -1);
   rb_define_method(SwigClassEndPointReference.klass, "add_selector", _wrap_EndPointReference_add_selector, -1);
   rb_define_method(SwigClassEndPointReference.klass, "serialize", _wrap_EndPointReference_serialize, -1);
   rb_define_method(SwigClassEndPointReference.klass, "cmp", _wrap_EndPointReference_cmp, -1);
+  rb_define_alias(SwigClassEndPointReference.klass, "==", "cmp");
   rb_define_method(SwigClassEndPointReference.klass, "to_xml", _wrap_EndPointReference_to_xml, -1);
-  rb_define_method(SwigClassEndPointReference.klass, "string", _wrap_EndPointReference_string, -1);
+  rb_define_method(SwigClassEndPointReference.klass, "to_s", _wrap_EndPointReference_to_s, -1);
   rb_define_method(SwigClassEndPointReference.klass, "selector_count", _wrap_EndPointReference_selector_count, -1);
   rb_define_method(SwigClassEndPointReference.klass, "resource_uri", _wrap_EndPointReference_resource_uri, -1);
   rb_define_method(SwigClassEndPointReference.klass, "selector", _wrap_EndPointReference_selector, -1);
+  rb_define_method(SwigClassEndPointReference.klass, "selector_names", _wrap_EndPointReference_selector_names, -1);
+  rb_define_method(SwigClassEndPointReference.klass, "each", _wrap_EndPointReference_each, -1);
+  rb_define_method(SwigClassEndPointReference.klass, "classname", _wrap_EndPointReference_classname, -1);
+  rb_define_method(SwigClassEndPointReference.klass, "namespace", _wrap_EndPointReference_namespace, -1);
+  rb_define_method(SwigClassEndPointReference.klass, "prefix", _wrap_EndPointReference_prefix, -1);
   SwigClassEndPointReference.mark = 0;
   SwigClassEndPointReference.destroy = (void (*)(void *)) free_epr_t;
   SwigClassEndPointReference.trackObjects = 0;
@@ -16032,7 +16516,9 @@ SWIGEXPORT void Init_openwsman(void) {
   rb_define_method(SwigClassClientOptions.klass, "set_dump_request", _wrap_ClientOptions_set_dump_request, -1);
   rb_define_method(SwigClassClientOptions.klass, "clear_dump_request", _wrap_ClientOptions_clear_dump_request, -1);
   rb_define_method(SwigClassClientOptions.klass, "flags=", _wrap_ClientOptions_flagse___, -1);
+  rb_define_method(SwigClassClientOptions.klass, "flags", _wrap_ClientOptions_flags, -1);
   rb_define_method(SwigClassClientOptions.klass, "clear_flags", _wrap_ClientOptions_clear_flags, -1);
+  rb_define_method(SwigClassClientOptions.klass, "reset_flags", _wrap_ClientOptions_reset_flags, -1);
   rb_define_method(SwigClassClientOptions.klass, "max_envelope_size=", _wrap_ClientOptions_max_envelope_sizee___, -1);
   rb_define_method(SwigClassClientOptions.klass, "max_envelope_size", _wrap_ClientOptions_max_envelope_size, -1);
   rb_define_method(SwigClassClientOptions.klass, "max_elements=", _wrap_ClientOptions_max_elementse___, -1);
@@ -16102,5 +16588,7 @@ SWIGEXPORT void Init_openwsman(void) {
   rb_define_module_function(mOpenwsman, "debug", _wrap_debug, -1);
   rb_define_module_function(mOpenwsman, "create_soap_envelope", _wrap_create_soap_envelope, -1);
   rb_define_module_function(mOpenwsman, "create_doc_from_file", _wrap_create_doc_from_file, -1);
+  rb_define_module_function(mOpenwsman, "create_doc_from_string", _wrap_create_doc_from_string, -1);
+  rb_define_module_function(mOpenwsman, "uri_prefix", _wrap_uri_prefix, -1);
 }
 

data/lib/openwsman/openwsman.rb

@@ -24,4 +24,32 @@ module Openwsman
       # return nil to abort authentication
     end
   end
-end
+  #
+  # return endpoint-reference (EPR) prefix for given classname and namespace
+  #
+  # * +classname+ - classname (using the <schema>_<name> format)
+  # * +namespace+ - optional namespace, required for Windows WMI which embeds the namespace in the EPR
+  #
+  # ==== Examples
+  #   prefix = Openwsman.epr_prefix_for "CIM_Managed_Element"
+  #   prefix = Openwsman.epr_prefix_for "Win32_Foo", "root/cimv2"
+  #
+  def self.epr_prefix_for classname, namespace = nil
+    prefix = Openwsman::uri_prefix classname
+    prefix += "/#{namespace}" if namespace
+    prefix
+  end
+  
+  # create full endpoint reference URI for namespace and classname
+  def self.epr_uri_for namespace, classname
+    raise "Namespace must not be nil" unless namespace
+    raise "Classname must not be nil" unless classname
+    "#{self.epr_prefix_for(classname)}/#{namespace}/#{classname}"
+  end
+  
+  class EndPointReference
+    def method_missing name, *args
+      selector(name)
+    end
+  end
+end

data/lib/openwsman/version.rb

@@ -2,7 +2,7 @@
 
 module Openwsman
   require 'rbconfig'
-  OPENWSMAN_RUBY_VERSION = "1.8"
+  OPENWSMAN_RUBY_VERSION = "1.9"
   SYSTEM_RUBY_VERSION = "#{RbConfig::CONFIG['MAJOR']}.#{RbConfig::CONFIG['MINOR']}"
   if SYSTEM_RUBY_VERSION != OPENWSMAN_RUBY_VERSION
     STDERR.puts "** Warning: Ruby version mismatch: Openwsman Ruby #{OPENWSMAN_RUBY_VERSION}, Runtime Ruby #{SYSTEM_RUBY_VERSION}"

metadata

@@ -1,79 +1,59 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: openwsman
-version: !ruby/object:Gem::Version 
-  hash: 3
+version: !ruby/object:Gem::Version
+  version: 2.3.2
   prerelease: 
-  segments: 
-  - 2
-  - 3
-  - 0
-  version: 2.3.0
 platform: ruby
-authors: 
-- "Klaus K\xC3\xA4mpf"
+authors:
+- Klaus Kämpf
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-02-07 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake-compiler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &5667040 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: mocha
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *5667040
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &5665920 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 25
-        segments: 
-        - 0
-        - 9
-        version: "0.9"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: yard
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *5665920
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &5665240 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 1
-        segments: 
-        - 0
-        - 5
-        version: "0.5"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.5'
   type: :development
-  version_requirements: *id003
-description: |-
-  The openwsman gem provides a Ruby API to manage
-  systems using the WS-Management protocol.
-email: 
+  prerelease: false
+  version_requirements: *5665240
+description: ! 'The openwsman gem provides a Ruby API to manage
+
+  systems using the WS-Management protocol.'
+email:
 - kkaempf@suse.de
 executables: []
-
-extensions: 
+extensions:
 - ext/openwsman/extconf.rb
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/openwsman.rb
 - lib/openwsman/xmlnode.rb
 - lib/openwsman/xmldoc.rb
@@ -84,43 +64,30 @@ files:
 - ext/openwsman/openwsman_wrap.c
 - ext/openwsman/openwsman.c
 - ext/openwsman/extconf.rb
-has_rdoc: true
 homepage: http://www.github.com/openwsman/openwsman
 licenses: []
-
-post_install_message: "  ____\n\
-  /@    ~-.\n\
-  / __ .- | remember to have fun! \n // //  @  \n\n"
+post_install_message: ! "  ____\n/@    ~-.\n/ __ .- | remember to have fun! \n //
+  //  @  \n\n"
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 23
-      segments: 
-      - 1
-      - 3
-      - 6
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Ruby client bindings for Openwsman
 test_files: []
-
+has_rdoc: