bindings/wsman-transport.i

/*
 * wsman-transport.i
 * client transport declarations for openwsman swig bindings
 *
 */

%rename(Transport) _WsManTransport;
%nodefault _WsManTransport;
typedef struct _WsManTransport {} WsManTransport;

/*
 * Document-class: Transport
 *
 * Transport reflects details of the http(s) transport layer between
 * client and server.
 *
 */

/* rename those as <foo>_STR below */
%ignore _WS_NO_AUTH;
%ignore _WS_BASIC_AUTH;
%ignore _WS_DIGEST_AUTH;
%ignore _WS_PASS_AUTH;
%ignore _WS_NTLM_AUTH;
%ignore _WS_GSSNEGOTIATE_AUTH;

%include "u/libu.h"
%include "wsman-client-transport.h"

%extend _WsManTransport {

 /* No authentication */
 %constant int NO_AUTH           = WS_NO_AUTH;
 /* HTTP basic auth */
 %constant int BASIC_AUTH        = WS_BASIC_AUTH;
 /* HTTP digest auth */
 %constant int DIGEST_AUTH       = WS_DIGEST_AUTH;
 /* Windows Passport auth */
 %constant int PASS_AUTH         = WS_PASS_AUTH;
 /* Windows NT Lan manager auth */
 %constant int NTLM_AUTH         = WS_NTLM_AUTH;
 /* GSSAPI auth */
 %constant int GSSNEGOTIATE_AUTH = WS_GSSNEGOTIATE_AUTH;

 /* No authentication */
 %constant char *NO_AUTH_STR           = _WS_NO_AUTH;
 /* HTTP basic auth */
 %constant char *BASIC_AUTH_STR        = _WS_BASIC_AUTH;
 /* HTTP digest auth */
 %constant char *DIGEST_AUTH_STR       = _WS_DIGEST_AUTH;
 /* Windows Passport auth */
 %constant char *PASS_AUTH_STR         = _WS_PASS_AUTH;
 /* Windows NT Lan manager auth */
 %constant char *NTLM_AUTH_STR         = _WS_NTLM_AUTH;
 /* GSSAPI auth */
 %constant char *GSSNEGOTIATE_AUTH_STR = _WS_GSSNEGOTIATE_AUTH;

#if defined(SWIGRUBY)
  %rename("auth_method?") is_auth_method(int method);
  %typemap(out) int is_auth_method
    "$result = ($1 != 0) ? Qtrue : Qfalse;";
#endif
  /*
   * Check if the passed method id is valid for authentication
   * call-seq:
   *   transport.auth_method?(Integer) -> Boolean
   */
  int is_auth_method(int method) {
    return wsman_is_auth_method((WsManClient *)$self, method);
  }

  /*
   * Close the transport. No further communication possible.
   */
  void close() {
    wsman_transport_close_transport((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("agent=") set_agent(const char *agent);
#endif
  /*
   * Set the HTTP agent identifier (User-agent:) string
   *
   * This is how the client will show up in the servers http log.
   * Defaults to "Openwsman"
   * call-seq:
   *   transport.agent = "Client identifier"
   */
  void set_agent(const char *agent) {
    wsman_transport_set_agent((WsManClient *)$self, agent);
  }
  %newobject agent;
  /*
   * Get the HTTP agent identifier string
   * call-seq:
   *   transport.agent -> String
   */
  char *agent() {
    return wsman_transport_get_agent ((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("username") get_username();
#endif
  %newobject get_username;
  /*
   * Server credentials
   * Get the username part of the http transport credentials
   * call-seq:
   *   transport.username -> String
   */
  char *get_username() {
    return wsman_transport_get_userName((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("username=") set_username(char *user_name);
#endif
  /*
   * Server credentials
   * Set the username part of the http transport credentials
   * call-seq:
   *   transport.username = "Username"
   */
  void set_username(char *user_name) {
    wsman_transport_set_userName((WsManClient *)$self, user_name);
  }

#if defined(SWIGRUBY)
  %rename("password") get_password();
#endif
  %newobject get_password;
  /*
   * Server credentials
   * Get the password part of the http transport credentials
   * call-seq:
   *   transport.password -> String
   */
  char *get_password() {
    return wsman_transport_get_password((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("password=") set_password(char *password);
#endif
  /*
   * Server credentials
   * Set the password part of the http transport credentials
   * call-seq:
   *   transport.password = "Password"
   */
  void set_password(char *password) {
    wsman_transport_set_password((WsManClient *)$self, password);
  }

#if defined(SWIGRUBY)
  %rename("proxy_username") get_proxy_username();
#endif
  %newobject get_proxy_username;
  /*
   * Windows clients: HTTP proxy credentials
   *
   * Get the username part of the http proxy credentials
   * call-seq:
   *   transport.proxy_username -> String
   */
  char *get_proxy_username() {
    return wsman_transport_get_proxy_username((WsManClient *)$self );
  }

#if defined(SWIGRUBY)
  %rename("proxy_username=") set_proxy_username(char *proxy_username);
#endif
  /*
   * Windows clients: HTTP proxy credentials
   *
   * Set the username part of the http proxy credentials
   * call-seq:
   *   transport.proxy_username = "proxy_username"
   */
  void set_proxy_username(char *proxy_username) {
    wsman_transport_set_proxy_username((WsManClient *)$self, proxy_username );
  }

#if defined(SWIGRUBY)
  %rename("proxy_password") get_proxy_password();
#endif
  %newobject get_proxy_password;
  /*
   * Windows clients: HTTP proxy credentials
   *
   * Get the password part of the http proxy credentials
   * call-seq:
   *   transport.proxy_password -> String
   */
  char *get_proxy_password() {
    return wsman_transport_get_proxy_password((WsManClient *)$self );
  }

#if defined(SWIGRUBY)
  %rename("proxy_password=") set_proxy_password(char *proxy_password);
#endif
  /*
   * Windows clients: HTTP proxy credentials
   *
   * Set the password part of the http proxy credentials
   * call-seq:
   *   transport.proxy_password = "proxy_password"
   */
  void set_proxy_password(char *proxy_password) {
    wsman_transport_set_proxy_password((WsManClient *)$self, proxy_password );
  }

#if defined(SWIGRUBY)
  %rename("auth_method=") set_auth_method( const char *am);
#endif
  /*
   * Set the authentication method
   * Value must be one of:
   *   +Openwsman::NO_AUTH_STR+
   *   +Openwsman::BASIC_AUTH_STR+
   *   +Openwsman::DIGEST_AUTH_STR+
   *   +Openwsman::PASS_AUTH_STR+
   *   +Openwsman::NTLM_AUTH_STR+
   *   +Openwsman::GSSNEGOTIATE_AUTH_STR+
   */
  void set_auth_method(const char *am) {
    wsman_transport_set_auth_method((WsManClient *)$self, am);
  }
  %newobject auth_method;
  /*
   * Set the authentication method
   * call-seq:
   *   transport.auth_method -> String
   */
  char *auth_method() {
    return wsman_transport_get_auth_method ((WsManClient *)$self);
  }

  /*
   * Set the authentication method string corresponding to the given
   * auth method id
   *
   * Value must be one of:
   *   +Openwsman::NO_AUTH+
   *   +Openwsman::BASIC_AUTH+
   *   +Openwsman::DIGEST_AUTH+
   *   +Openwsman::PASS_AUTH+
   *   +Openwsman::NTLM_AUTH+
   *   +Openwsman::GSSNEGOTIATE_AUTH+   
   *
   * call-seq:
   *   transport.auth_name(Integer) -> String
   */
  static const char *auth_name(int auth) {
    return wsmc_transport_get_auth_name(auth);
  }
  /*
   * Get the authentication method integer id
   */
  int auth_value() {
    return wsmc_transport_get_auth_value((WsManClient *)$self);
  }
  /*
   * Get string corresponding to given error code
   * call-seq:
   *   transport.error_string(Integer) -> String
   */
  static char *error_string(int err) {
    return wsman_transport_get_last_error_string(err);
  }

#if defined(SWIGRUBY)
  %rename("timeout=") set_timeout(unsigned long timeout);
#endif
  /*
   * Set the transport timeout in seconds
   *
   * ==== Note
   * This is the http layer timeout. Not to be confused with the
   * WS-Management operation timeout set via Openwsman::ClientOptions.timeout
   */
  void set_timeout(unsigned long timeout) {
    wsman_transport_set_timeout((WsManClient *)$self, timeout);
  }
  /*
   * Get the transport timeout in seconds
   * call-seq:
   *   transport.timeout -> Integer
   */
  unsigned long timeout() {
    return wsman_transport_get_timeout((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("verify_peer=") set_verify_peer( VALUE rvalue );
 /*
  * verify the peer in SSL communication ?
  *
  * If passed +false+, +nil+, or 0: disable peer verification
  * else: enable peer verification
  */
  void set_verify_peer( VALUE rvalue ) {
    unsigned int value;
    if ((rvalue == Qfalse) || (rvalue == Qnil)) {
      value = 0;
    }
    else if ((TYPE(rvalue) == T_FIXNUM) && (FIX2INT(rvalue) == 0)) {
      value = 0;
    }
    else {
      value = 1;
    }
#else
 /*
  * verify the peer in SSL communication ?
  * no: == 0
  * yes: != 0
  */
  void set_verify_peer( unsigned int value ) {
#endif
    wsman_transport_set_verify_peer((WsManClient *)$self, value);
  }
#if defined(SWIGRUBY)
  %rename("verify_peer?") verify_peer();
  %typemap(out) unsigned int verify_peer
    "$result = ($1 != 0) ? Qtrue : Qfalse;";
#endif
  /*
   * Peer to be verified ?
   * call-seq:
   *   transport.verify_peer? -> Boolean
   */
  unsigned int verify_peer() {
    return wsman_transport_get_verify_peer((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("verify_host=") set_verify_host(VALUE rvalue);
  /*
  * verify the host in SSL communication ?
  *
  * If passed +false+, +nil+, or 0: disable peer verification
  * else: enable peer verification
  */
  void set_verify_host( VALUE rvalue ) {
    unsigned int value;
    if ((rvalue == Qfalse) || (rvalue == Qnil)) {
      value = 0;
    }
    else if ((TYPE(rvalue) == T_FIXNUM) && (FIX2INT(rvalue) == 0)) {
      value = 0;
    }
    else {
      value = 1;
    }
#else
  /*
  * verify the host in SSL communication ?
  * no: == 0
  * yes: != 0
  */
  void set_verify_host(unsigned int value) {
#endif
    wsman_transport_set_verify_host((WsManClient *)$self, value);
  }
#if defined(SWIGRUBY)
  %rename("verify_host?") verify_host();
  %typemap(out) unsigned int verify_host
    "$result = ($1 != 0) ? Qtrue : Qfalse;";
#endif
  /*
   * Host to be verified ?
   * call-seq:
   *   transport.verify_host? -> Boolean
   */
  unsigned int verify_host() {
    return wsman_transport_get_verify_host((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("proxy=") set_proxy(const char *proxy);
#endif
  /*
   * Set http proxy URL
   *
   * Pass nil to disable proxy communication
   * ==== Example
   *   transport.proxy = "http://your.proxy.com:80"
   */
  void set_proxy(const char *proxy) {
    wsman_transport_set_proxy((WsManClient *)$self, proxy);
  }
  %newobject proxy;
  /*
   * Get http proxy URL
   */
  char *proxy() {
    return wsman_transport_get_proxy((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("proxyauth=") set_proxyauth(const char *pauth);
#endif
  /*
   * Linux clients: HTTP proxy credentials
   *
   * Set the proxy username and password
   * ==== Example
   *   transport.proxyauth = "username:password"
   */
  void set_proxyauth(const char *pauth) {
    wsman_transport_set_proxyauth((WsManClient *)$self, pauth);
  }
  %newobject proxyauth;
  /*
   * Linux clients: HTTP proxy credentials
   *
   * Get the proxy username and password as "username:password"
   * call-seq:
   *   transport.proxyauth -> String
   */
  char *proxyauth(){
    return wsman_transport_get_proxyauth((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("cainfo=") set_cainfo(const char *cainfo);
#endif
  /*
   * Set the certification authority (CAINFO)
   */
  void set_cainfo(const char *cainfo) {
    wsman_transport_set_cainfo((WsManClient *)$self, cainfo);
  }
  %newobject cainfo;
  /*
   * Get the certification authority (CAINFO)
   * call-seq:
   *   transport.cainfo -> String
   */
  char *cainfo() {
    return wsman_transport_get_cainfo((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("certhumbprint=") set_certhumbprint(const char *arg);
#endif
  /*
   * Set the certification thumbprint
   */
  void set_certhumbprint(const char *arg) {
    wsman_transport_set_certhumbprint((WsManClient *)$self, arg);
  }
  %newobject certhumbprint;
  /*
   * Set the certification thumbprint
   * call-seq:
   *   transport.certhumbprint -> String
   */
  char *certhumbprint() {
    return wsman_transport_get_certhumbprint((WsManClient *)$self);
  }
  
#if defined(SWIGRUBY)
  %rename("capath=") set_capath(const char *capath);
#endif
  /*
   * Set the path to the certification authority (CAINFO) store
   */
  void set_capath(const char *capath) {
    wsman_transport_set_capath((WsManClient *)$self, capath);
  }
  %newobject capath;
  /*
   * Get the path to the certification authority (CAINFO) store
   */
  char *capath() {
    return wsman_transport_get_capath((WsManClient *)$self);
  }

#if defined(SWIGRUBY)
  %rename("caoid=") set_caoid(const char *oid);
#endif
  /*
   * Windows client
   *
   * Set the CA OID
   *
   * ==== Reference
   * http://support.microsoft.com/kb/287547
   */
  void set_caoid(const char *oid) {
    wsman_transport_set_caoid((WsManClient *)$self, oid);
  }
  %newobject caoid;
  /*
   * Windows client
   *
   * Get the CA OID
   */
  char *caoid() {
    return wsman_transport_get_caoid((WsManClient *)$self);
  }

#ifdef _WIN32
#if defined(SWIGRUBY)
  %rename("calocal=") set_calocal(BOOL local);
#endif
  /*
   * Windows client
   *
   * Use local CA ?
   */
  void set_calocal(BOOL local) {
    wsman_transport_set_calocal((WsManClient *)$self, local);
  }
  /*
   * Windows client
   *
   * Use local CA ?
   * call-seq:
   *   transport.calocal -> Boolean
   */
  BOOL calocal() {
    return wsman_transport_get_calocal((WsManClient *)$self);
  }
#endif

#if defined(SWIGRUBY)
  %rename("cert=") set_cert(const char *cert);
#endif
  /*
   * Set the certificate
   */
  void set_cert(const char *cert) {
    wsman_transport_set_cert((WsManClient *)$self, cert);
  }
  %newobject cert;
  /*
   * Get the certificate
   */
  char *cert() {
    return wsman_transport_get_cert((WsManClient *)$self);
  }
  
#if defined(SWIGRUBY)
  %rename("key=") set_key(const char *key);
#endif
  /*
   * Set the key
   */
  void set_key(const char *key) {
    wsman_transport_set_key((WsManClient *)$self, key);
  }
  %newobject key;
  /*
   * Get the key
   */
  char *key() {
    return wsman_transport_get_key((WsManClient *)$self);
  }


}