637 lines
14 KiB
OpenEdge ABL
637 lines
14 KiB
OpenEdge ABL
/*
|
|
* 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);
|
|
}
|
|
|
|
|
|
}
|