| #if defined(SWIGRUBY) |
| %module Openwsman |
| |
| %{ |
| #include <ruby.h> |
| #if HAVE_RUBY_IO_H |
| #include <ruby/io.h> /* Ruby 1.9 style */ |
| #else |
| #include <rubyio.h> |
| #endif |
| %} |
| |
| %typemap(in) FILE* { |
| #if RUBY_VERSION > 18 |
| struct rb_io_t *fptr; |
| #else |
| struct OpenFile *fptr; |
| #endif |
| Check_Type($input, T_FILE); |
| GetOpenFile($input, fptr); |
| /*rb_io_check_writable(fptr);*/ |
| #if RUBY_VERSION > 18 |
| $1 = rb_io_stdio_file(fptr); |
| #else |
| $1 = GetReadFile(fptr); |
| #endif |
| } |
| |
| #endif |
| |
| #if defined(SWIGJAVA) |
| %module OpenWSMan |
| |
| /* evaluate constants */ |
| %javaconst(1); |
| |
| /* extend JNI class to automatically load shared library from jar file */ |
| %pragma(java) jniclassimports=%{ |
| import java.io.File; |
| import java.io.InputStream; |
| import java.io.FileOutputStream; |
| %} |
| %pragma(java) jniclasscode=%{ |
| public final static String libraryFileName = "libjwsman.so"; |
| |
| static { |
| InputStream inputStream = OpenWSManJNI.class.getClassLoader() |
| .getResourceAsStream(libraryFileName); |
| |
| try { |
| File libraryFile = File.createTempFile(libraryFileName, null); |
| libraryFile.deleteOnExit(); |
| |
| FileOutputStream fileOutputStream = new FileOutputStream(libraryFile); |
| byte[] buffer = new byte[8192]; |
| int bytesRead; |
| while ((bytesRead = inputStream.read(buffer)) > 0) { |
| fileOutputStream.write(buffer, 0, bytesRead); |
| } |
| fileOutputStream.close(); |
| inputStream.close(); |
| |
| try { |
| System.load(libraryFile.getPath()); |
| } catch (UnsatisfiedLinkError e) { |
| System.err.println("Arch: " + System.getProperty("os.arch")); |
| System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); |
| } |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } |
| %} |
| |
| /* get the java environment so we can throw exceptions */ |
| %{ |
| static JNIEnv *jenv; |
| /*:nodoc:*/ |
| jint JNI_OnLoad(JavaVM *vm, void *reserved) { |
| (*vm)->AttachCurrentThread(vm, (void **)&jenv, NULL); |
| return JNI_VERSION_1_2; |
| } |
| %} |
| #endif |
| |
| #if defined(SWIGPYTHON) |
| %module pywsman |
| #endif |
| |
| #if defined(SWIGPERL) |
| %module openwsman |
| |
| //================================== |
| // Typemap: Allow FILE* as PerlIO |
| //---------------------------------- |
| %typemap(in) FILE* { |
| $1 = PerlIO_findFILE(IoIFP(sv_2io($input))); |
| } |
| #endif |
| |
| %{ |
| #if defined(SWIGPERL) |
| /* filter_t is defined in Perls CORE/perl.h */ |
| #define filter_t filter_type |
| |
| /* undef Perl's die and warn macros as libu is going to reuse this names */ |
| #undef die |
| #undef warn |
| #endif |
| |
| #include <u/libu.h> |
| #include <wsman-types.h> |
| #include <wsman-client.h> |
| #include <wsman-client-transport.h> |
| #include <wsman-api.h> |
| #include <wsman-xml-binding.h> |
| #include <wsman-xml.h> |
| #include <wsman-epr.h> |
| #include <wsman-filter.h> |
| #include <wsman-soap.h> |
| #include <wsman-soap-envelope.h> |
| #include <openwsman.h> |
| #if defined(SWIGRUBY) |
| #include <ruby/helpers.h> |
| |
| SWIGEXPORT |
| /* Init_ for the %module, defined by Swig |
| * :nodoc: |
| */ |
| void Init_Openwsman(void); |
| |
| SWIGEXPORT |
| /* Init_ for the .so lib, called by Ruby |
| * :nodoc: |
| */ |
| void Init__openwsman(void) { |
| Init_Openwsman(); |
| } |
| #endif |
| #if defined(SWIGPYTHON) |
| #include <python/helpers.h> |
| #endif |
| #if defined(SWIGJAVA) |
| #include <java/helpers.h> |
| #endif |
| #if defined(SWIGPERL) |
| #include <perl/helpers.h> |
| #endif |
| |
| /* Provide WsManTransport definition so it can be used as |
| * dedicated datatype in bindings. |
| * :nodoc:ly, its aliased to WsManClient |
| */ |
| struct _WsManTransport { }; |
| typedef struct _WsManTransport WsManTransport; |
| |
| static void set_debug(int dbg); |
| |
| /* |
| * Set openwsman debug level. |
| * call-seq: |
| * Openwsman::debug = -1 # full debug |
| */ |
| static void set_debug(int dbg) { |
| static int init = 0; |
| |
| if (!init && dbg != 0) { |
| init = 1; |
| debug_add_handler( debug_message_handler, DEBUG_LEVEL_ALWAYS, NULL ); |
| } |
| wsman_debug_set_level( dbg ); |
| |
| } |
| |
| /* module-level methods */ |
| |
| static int get_debug(void); |
| |
| /* |
| * Return openwsman debug level. |
| * call-seq: |
| * Openwsman::debug -> Integer |
| */ |
| static int get_debug(void) { |
| return (int)wsman_debug_get_level(); |
| } |
| |
| static WsXmlDocH create_soap_envelope(void); |
| /* |
| * Create empty SOAP envelope |
| * call-seq: |
| * Openwsman::create_soap_envelope -> XmlDoc |
| */ |
| static WsXmlDocH create_soap_envelope() { |
| return ws_xml_create_soap_envelope(); |
| } |
| |
| static WsXmlDocH create_doc_from_file(const char *filename, const char *encoding); |
| |
| /* |
| * Read XmlDoc from file |
| * call-seq: |
| * Openwsman::create_doc_from_file("/path/to/file", "utf-8") -> XmlDoc |
| * |
| */ |
| 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); |
| |
| /* |
| * Read XmlDoc from string |
| * call-seq: |
| * Openwsman::create_doc_from_string("<xml ...>", "utf-8") -> XmlDoc |
| * |
| */ |
| 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 |
| * call-seq: |
| * Openwsman::uri_classname("http://sblim.sf.net/wbem/wscim/1/cim-schema/2/Linux_OperatingSystem") -> "Linux_OperatingSystem" |
| * |
| */ |
| 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); |
| /* |
| * Map classname (class schema) to resource uri prefix |
| * call-seq: |
| * Openwsman::uri_prefix("Linux") -> "http://sblim.sf.net/wbem/wscim/1/cim-schema/2" |
| * Openwsman::uri_prefix("Win32") -> "http://schemas.microsoft.com/wbem/wsman/1/wmi" |
| * |
| */ |
| 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" }, |
| /* Sun */ |
| { 3, "Sun","http://schemas.sun.com/wbem/wscim/1/cim-schema/2" }, |
| /* Microsoft HyperV */ |
| { 4, "Msvm", "http://schemas.microsoft.com/wbem/wsman/1/wmi" }, |
| /* Dell DRAC */ |
| { 4, "DCIM", "http://schemas.dell.com/wbem/wscim/1/cim-schema/2" }, |
| /* Unisys */ |
| { 4, "SPAR", "http://schema.unisys.com/wbem/wscim/1/cim-schema/2" }, |
| /* Fujitsu */ |
| { 3, "SVS", "http://schemas.ts.fujitsu.com/wbem/wscim/1/cim-schema/2" }, |
| { 0, NULL, NULL } |
| }; |
| const char *schema_end; |
| struct map *map; |
| int len; |
| if (classname == NULL) |
| return NULL; |
| if (strcmp(classname, "*") == 0) { |
| return "http://schemas.dmtf.org/wbem/wscim/1"; |
| } |
| if ((strcmp(classname, "meta_class") == 0) |
| ||(strncmp(classname, "__", 2) == 0)) { |
| return "http://schemas.microsoft.com/wbem/wsman/1/wmi"; |
| } |
| 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) |
| && (strncasecmp(classname, map->schema, map->len) == 0)) { |
| return map->prefix; |
| } |
| ++map; |
| } |
| return NULL; |
| } |
| |
| #if defined(SWIGRUBY) |
| static epr_t *my_epr_deserialize(WsXmlNodeH node); |
| /*:nodoc:*/ |
| static epr_t *my_epr_deserialize(WsXmlNodeH 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); |
| } |
| #endif |
| |
| static char *epr_prefix(const char *uri); |
| /* Get prefix from a EPR uri |
| * :nodoc: |
| */ |
| 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); |
| } |
| |
| %} |
| |
| #if RUBY_VERSION > 18 |
| %{ |
| typedef struct { |
| WsManClient *client; |
| client_opt_t *options; |
| filter_t *filter; |
| const char *resource_uri; |
| epr_t *epr; |
| const char *context; |
| const char *identifier; |
| const char *data; |
| size_t size; |
| const char *encoding; |
| const char *method; |
| WsXmlDocH method_args; |
| } wsmc_action_args_t; |
| |
| WsXmlDocH |
| ruby_enumerate_thread(wsmc_action_args_t *args) { |
| return wsmc_action_enumerate(args->client, args->resource_uri, args->options, args->filter); |
| } |
| WsXmlDocH |
| ruby_identify_thread(wsmc_action_args_t *args) { |
| return wsmc_action_identify(args->client, args->options); |
| } |
| WsXmlDocH |
| ruby_get_from_epr_thread(wsmc_action_args_t *args) { |
| return wsmc_action_get_from_epr(args->client, args->epr, args->options); |
| } |
| WsXmlDocH |
| ruby_delete_from_epr_thread(wsmc_action_args_t *args) { |
| return wsmc_action_delete_from_epr(args->client, args->epr, args->options); |
| } |
| WsXmlDocH |
| ruby_pull_thread(wsmc_action_args_t *args) { |
| return wsmc_action_pull(args->client, args->resource_uri, args->options, args->filter, args->context); |
| } |
| WsXmlDocH |
| ruby_create_fromtext_thread(wsmc_action_args_t *args) { |
| return wsmc_action_create_fromtext(args->client, args->resource_uri, args->options, args->data, args->size, args->encoding); |
| } |
| WsXmlDocH |
| ruby_put_fromtext_thread(wsmc_action_args_t *args) { |
| return wsmc_action_put_fromtext(args->client, args->resource_uri, args->options, args->data, args->size, args->encoding); |
| } |
| WsXmlDocH |
| ruby_release_thread(wsmc_action_args_t *args) { |
| return wsmc_action_release(args->client, args->resource_uri, args->options, args->context); |
| } |
| WsXmlDocH |
| ruby_get_thread(wsmc_action_args_t *args) { |
| return wsmc_action_get(args->client, args->resource_uri, args->options); |
| } |
| WsXmlDocH |
| ruby_delete_thread(wsmc_action_args_t *args) { |
| return wsmc_action_delete(args->client, args->resource_uri, args->options); |
| } |
| WsXmlDocH |
| ruby_invoke_thread(wsmc_action_args_t *args) { |
| return wsmc_action_invoke(args->client, args->resource_uri, args->options, args->method, args->method_args); |
| } |
| WsXmlDocH |
| ruby_subscribe_thread(wsmc_action_args_t *args) { |
| return wsmc_action_subscribe(args->client, args->resource_uri, args->options, args->filter); |
| } |
| WsXmlDocH |
| ruby_unsubscribe_thread(wsmc_action_args_t *args) { |
| return wsmc_action_unsubscribe(args->client, args->resource_uri, args->options, args->identifier); |
| } |
| WsXmlDocH |
| ruby_renew_thread(wsmc_action_args_t *args) { |
| return wsmc_action_renew(args->client, args->resource_uri, args->options, args->identifier); |
| } |
| %} |
| #endif |
| |
| |
| /* |
| * hash_t typemaps |
| */ |
| #if defined(SWIGJAVA) |
| %typemap(jni) hash_t * "jobject" |
| %typemap(jtype) hash_t * "java.util.Map" |
| %typemap(jstype) hash_t * "java.util.Map" |
| %typemap(javaout) hash_t * { |
| return $jnicall; |
| } |
| #endif |
| %typemap(out) hash_t * { |
| #if defined(SWIGJAVA) |
| $result = hash2value(jenv, $1); |
| #else |
| $result = hash2value($1); |
| #endif |
| } |
| |
| %typemap(in) hash_t * { |
| $input = value2hash(NULL, $1, 0); |
| } |
| |
| %ignore __undefined; |
| |
| %include exception.i |
| |
| #if defined(SWIGJAVA) |
| |
| /* if java, pass the new exception macro to C not just SWIG */ |
| #undef SWIG_exception |
| #define SWIG_exception(code, msg) {SWIG_JavaException(jenv, code, msg); goto fail;} |
| %inline %{ |
| #undef SWIG_exception |
| #define SWIG_exception(code, msg) {SWIG_JavaException(jenv, code, msg); goto fail;} |
| %} |
| |
| #endif |
| |
| %include "version.i" |
| |
| /* start with wsman-xml to get the __WsXmlFoo -> XmlFoo renames right */ |
| %include "wsman-xml.i" |
| |
| %include "wsman-names.i" |
| |
| %include "wsman-epr.i" |
| |
| %include "wsman-filter.i" |
| |
| %include "wsman-soap.i" |
| |
| %include "wsman-transport.i" |
| |
| %include "client_opt.i" |
| |
| %include "wsman-client.i" |
| |
| /*-----------------------------------------------------------------*/ |
| /* debug */ |
| |
| #if defined(SWIGRUBY) |
| %rename("debug=") set_debug(int debug); |
| #endif |
| static void set_debug(int dbg); |
| #if defined(SWIGRUBY) |
| %rename("debug") get_debug(); |
| #endif |
| static int get_debug(); |
| static WsXmlDocH create_soap_envelope(); |
| static WsXmlDocH create_doc_from_file(const char *filename, const char *encoding = "UTF-8"); |
| static WsXmlDocH create_doc_from_string(const char *buf, const char *encoding = "UTF-8"); |
| static const char *uri_prefix(const char* classname); |