%{ /* * type definitions to keep the C code generic */ #if defined(SWIGPYTHON) #define Target_Null_p(x) (x == Py_None) #define Target_INCREF(x) Py_INCREF(x) #define Target_DECREF(x) Py_DECREF(x) #define Target_True Py_True #define Target_False Py_False #define Target_Null Py_None #define Target_Type PyObject* #define Target_Bool(x) PyBool_FromLong(x) #define Target_Char16(x) PyInt_FromLong(x) #define Target_Int(x) PyInt_FromLong(x) #define Target_String(x) PyString_FromString(x) #define Target_Real(x) Py_None #define Target_Array() PyList_New(0) #define Target_SizedArray(len) PyList_New(len) #define Target_ListSet(x,n,y) PyList_SetItem(x,n,y) #define Target_Append(x,y) PyList_Append(x,y) #include #define TARGET_THREAD_BEGIN_BLOCK SWIG_PYTHON_THREAD_BEGIN_BLOCK #define TARGET_THREAD_END_BLOCK SWIG_PYTHON_THREAD_END_BLOCK #define TARGET_THREAD_BEGIN_ALLOW SWIG_PYTHON_THREAD_BEGIN_ALLOW #define TARGET_THREAD_END_ALLOW SWIG_PYTHON_THREAD_END_ALLOW #endif #if defined(SWIGRUBY) #define Target_Null_p(x) NIL_P(x) #define Target_INCREF(x) #define Target_DECREF(x) #define Target_True Qtrue #define Target_False Qfalse #define Target_Null Qnil #define Target_Type VALUE #define Target_Bool(x) ((x)?Qtrue:Qfalse) #define Target_Char16(x) INT2FIX(x) #define Target_Int(x) INT2FIX(x) #define Target_String(x) rb_str_new2(x) #define Target_Real(x) rb_float_new(x) #define Target_Array() rb_ary_new() #define Target_SizedArray(len) rb_ary_new2(len) #define Target_ListSet(x,n,y) rb_ary_store(x,n,y) #define Target_Append(x,y) rb_ary_push(x,y) #define TARGET_THREAD_BEGIN_BLOCK do {} while(0) #define TARGET_THREAD_END_BLOCK do {} while(0) #define TARGET_THREAD_BEGIN_ALLOW do {} while(0) #define TARGET_THREAD_END_ALLOW do {} while(0) #include #if HAVE_RUBY_IO_H #include /* Ruby 1.9 style */ #else #include #endif #if HAVE_RUBY_VERSION_H #include #endif #endif #if defined(SWIGPERL) #define TARGET_THREAD_BEGIN_BLOCK do {} while(0) #define TARGET_THREAD_END_BLOCK do {} while(0) #define TARGET_THREAD_BEGIN_ALLOW do {} while(0) #define TARGET_THREAD_END_ALLOW do {} while(0) SWIGINTERNINLINE SV *SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value); SWIGINTERNINLINE SV *SWIG_FromCharPtr(const char *cptr); SWIGINTERNINLINE SV *SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value); #define Target_Null_p(x) (x == NULL) #define Target_INCREF(x) #define Target_DECREF(x) #define Target_True (&PL_sv_yes) #define Target_False (&PL_sv_no) #define Target_Null NULL #define Target_Type SV * #define Target_Bool(x) (x)?Target_True:Target_False #define Target_Char16(x) SWIG_From_long(x) #define Target_Int(x) SWIG_From_long(x) #define Target_String(x) SWIG_FromCharPtr(x) #define Target_Real(x) SWIG_From_double(x) #define Target_Array() (SV *)newAV() #define Target_SizedArray(len) (SV *)newAV() #define Target_ListSet(x,n,y) av_store((AV *)(x),n,y) #define Target_Append(x,y) av_push(((AV *)(x)), y) #include #include #endif %} #if defined(SWIGRUBY) %module Openwsman %{ #include #if HAVE_RUBY_IO_H #include /* Ruby 1.9 style */ #else #include #endif #if HAVE_RUBY_THREAD_H /* New threading model */ #include #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 /* SWIGRUBY */ #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 /* SWIGJAVA */ #if defined(SWIGPYTHON) %module pywsman /* Wrap file operations, as Python's native ones are incompatible */ FILE *fopen(char *, char *); void fclose(FILE *f); #endif #if defined(SWIGPERL) %module openwsman //================================== // Typemap: Allow FILE* as PerlIO //---------------------------------- %typemap(in) FILE* { $1 = PerlIO_findFILE(IoIFP(sv_2io($input))); } #endif /* SWIGPERL */ %{ #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 /* SWIGPERL */ #include #include #include #include #include #include #include #include #include #include #include #include #if defined(SWIGRUBY) #include 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 #endif #if defined(SWIGJAVA) #include #endif #if defined(SWIGPERL) #include #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("", "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); } /*:nodoc:*/ static VALUE kv_list_to_hash(list_t *list) { VALUE v = Qnil; if (!list_isempty(list)) { v = rb_hash_new(); lnode_t *node = list_first(list); while (node) { key_value_t *kv = (key_value_t *)node->list_data; if (kv->type == 0) { rb_hash_aset( v, makestring(kv->key), makestring(kv->v.text)); } else { VALUE epr = SWIG_NewPointerObj((void*)kv->v.epr, SWIGTYPE_p_epr_t, 0); rb_hash_aset( v, makestring(kv->key), epr); } node = list_next(list, node); } } return v; } #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 "wsman-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);