220 lines
6.1 KiB
C
220 lines
6.1 KiB
C
#ifndef RUBY_HELPERS_H
|
|
#define RUBY_HELPERS_H
|
|
|
|
/*
|
|
* openwsman-ruby.c
|
|
*
|
|
* helper functions to convert between ruby and openwsman values
|
|
*
|
|
* Author: Klaus Kaempf <kkaempf@suse.de>
|
|
*
|
|
*/
|
|
|
|
/*****************************************************************************
|
|
* Copyright (C) 2008 Novell Inc. All rights reserved.
|
|
* Copyright (C) 2008 SUSE Linux Products GmbH. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* - Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* - Neither the name of Novell Inc. nor of SUSE Linux Products GmbH nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL Novell Inc. OR SUSE Linux Products GmbH OR
|
|
* THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*****************************************************************************/
|
|
|
|
|
|
/*
|
|
* Get access to Ruby klass pointers
|
|
*
|
|
*/
|
|
|
|
#if SWIG_VERSION > 0x020004
|
|
#define KLASS_DECL(k,t) swig_class *k = (swig_class *)(t->clientdata)
|
|
#define KLASS_OF(x) x->klass
|
|
#else
|
|
#define KLASS_DECL(k,t) extern swig_class k
|
|
#define KLASS_OF(x) x.klass
|
|
#endif
|
|
|
|
/* convert char* to string VALUE */
|
|
static VALUE
|
|
makestring( const char *s )
|
|
{
|
|
if (s) return rb_str_new2( s );
|
|
return Qnil;
|
|
}
|
|
|
|
|
|
/* convert VALUE to char* */
|
|
static const char *
|
|
as_string( VALUE v )
|
|
{
|
|
const char *str;
|
|
if (SYMBOL_P(v)) {
|
|
str = rb_id2name(SYM2ID(v));
|
|
}
|
|
else if (TYPE(v) == T_STRING) {
|
|
str = StringValuePtr(v);
|
|
}
|
|
else if (v == Qnil) {
|
|
str = NULL;
|
|
}
|
|
else {
|
|
VALUE v_s = rb_funcall(v, rb_intern("to_s"), 0 );
|
|
str = StringValuePtr(v_s);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
/* convert openwsman hash_t* to hash VALUE (string pairs) */
|
|
static VALUE
|
|
hash2value( hash_t *hash )
|
|
{
|
|
VALUE v;
|
|
hnode_t *node;
|
|
hscan_t ptr;
|
|
|
|
if (!hash) return Qnil;
|
|
|
|
hash_scan_begin( &ptr, hash );
|
|
|
|
v = rb_hash_new();
|
|
while ((node = hash_scan_next( &ptr )) ) {
|
|
rb_hash_aset( v, makestring( hnode_getkey( node ) ), makestring( hnode_get( node ) ) );
|
|
}
|
|
return v;
|
|
}
|
|
|
|
|
|
/* add key,value VALUE pair to hash_t* as char*
|
|
* (used as callback for value2hash)
|
|
*/
|
|
static int
|
|
_add_str( VALUE key, VALUE value, VALUE opaque )
|
|
{
|
|
hash_t *h = (hash_t *)opaque;
|
|
if (key != Qundef) {
|
|
const char *k = strdup( as_string( key ) );
|
|
if (!hash_lookup( h, k ) ) {
|
|
const char *v = strdup( as_string( value ) );
|
|
if ( !hash_alloc_insert( h, k, v ) ) {
|
|
rb_raise( rb_eException, "hash_alloc_insert failed" );
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* add key,value VALUE pair to hash_t* as key_value_t*
|
|
* (used as callback for value2hash)
|
|
*/
|
|
static int
|
|
_add_kv( VALUE key, VALUE value, VALUE opaque )
|
|
{
|
|
hash_t *h = (hash_t *)opaque;
|
|
if (key != Qundef) {
|
|
const char *k = as_string( key );
|
|
if (!hash_lookup( h, k ) ) {
|
|
epr_t *epr;
|
|
const char *text;
|
|
key_value_t *entry;
|
|
KLASS_DECL(SwigClassEndPointReference,SWIGTYPE_p_epr_t);
|
|
if (CLASS_OF(value) == KLASS_OF(SwigClassEndPointReference)) {
|
|
SWIG_ConvertPtr(value, (void **)&epr, SWIGTYPE_p_epr_t, 0);
|
|
text = NULL;
|
|
}
|
|
else if (TYPE(value) == T_ARRAY) {
|
|
rb_raise( rb_eException, "Passing array parameter via invoke() still unsupported" );
|
|
}
|
|
else {
|
|
text = as_string(value);
|
|
epr = NULL;
|
|
}
|
|
entry = key_value_create(k, text, epr, NULL);
|
|
if ( !hash_alloc_insert( h, k, entry ) ) {
|
|
rb_raise( rb_eException, "hash_alloc_insert failed" );
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Convert Ruby Hash to hash_t
|
|
*
|
|
* create hash (h == NULL) or add to hash (h != NULL) from hash VALUE
|
|
*
|
|
* valuetype - type of hash values
|
|
* 0 - values are string (char *)
|
|
* 1 - values are key_value_t *
|
|
*
|
|
*/
|
|
static hash_t *
|
|
value2hash( hash_t *h, VALUE v, int valuetype )
|
|
{
|
|
if (NIL_P(v)) return NULL;
|
|
|
|
Check_Type( v, T_HASH );
|
|
|
|
if (!h) h = hash_create3(HASHCOUNT_T_MAX, 0, 0);
|
|
|
|
rb_hash_foreach( v, (valuetype==0)?_add_str:_add_kv, (unsigned long)h );
|
|
|
|
return h;
|
|
}
|
|
|
|
|
|
/*
|
|
* callback function if client authentication fails
|
|
*
|
|
*/
|
|
static void
|
|
auth_request_callback( WsManClient *client, wsman_auth_type_t t, char **username, char **password )
|
|
{
|
|
KLASS_DECL(SwigClassTransport,SWIGTYPE_p__WsManTransport);
|
|
|
|
VALUE c = SWIG_NewPointerObj((void*) client, SWIGTYPE_p__WsManClient, 0);
|
|
|
|
/* ruby callback */
|
|
VALUE result = rb_funcall( KLASS_OF(SwigClassTransport), rb_intern( "auth_request_callback" ), 2, c, INT2NUM( t ) );
|
|
|
|
if (CLASS_OF( result ) == rb_cArray) {
|
|
if (RARRAY_LEN(result) == 2 ) {
|
|
*username = strdup(as_string( rb_ary_entry( result, 0 ) ));
|
|
*password= strdup(as_string( rb_ary_entry( result, 1 ) ));
|
|
return;
|
|
}
|
|
}
|
|
|
|
*username = NULL; /* abort authentication */
|
|
return;
|
|
}
|
|
|
|
static int associators_references( void *filter, int type, VALUE epr_v,
|
|
VALUE assocClass_v, VALUE resultClass_v, VALUE role_v, VALUE resultRole_v,
|
|
VALUE resultProp_v, VALUE propNum_v);
|
|
|
|
#endif /* RUBY_HELPERS_H */
|