ruby-libvirt 0.4.0 → 0.5.0

data/ext/libvirt/common.c

@@ -2,6 +2,7 @@
  * common.c: Common utilities for the ruby libvirt bindings
  *
  * Copyright (C) 2007,2010 Red Hat Inc.
+ * Copyright (C) 2013 Chris Lalancette <clalancette@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -26,68 +27,65 @@
 #include <libvirt/libvirt.h>
 #include <libvirt/virterror.h>
 #include "common.h"
+#include "connect.h"
 
 struct rb_exc_new2_arg {
     VALUE error;
     char *msg;
 };
 
-static VALUE rb_exc_new2_wrap(VALUE arg) {
+static VALUE ruby_libvirt_exc_new2_wrap(VALUE arg)
+{
     struct rb_exc_new2_arg *e = (struct rb_exc_new2_arg *)arg;
 
     return rb_exc_new2(e->error, e->msg);
 }
 
-VALUE rb_ary_new2_wrap(VALUE arg) {
+VALUE ruby_libvirt_ary_new2_wrap(VALUE arg)
+{
     return rb_ary_new2(*((int *)arg));
 }
 
-VALUE rb_ary_push_wrap(VALUE arg) {
-    struct rb_ary_push_arg *e = (struct rb_ary_push_arg *)arg;
+VALUE ruby_libvirt_ary_push_wrap(VALUE arg)
+{
+    struct ruby_libvirt_ary_push_arg *e = (struct ruby_libvirt_ary_push_arg *)arg;
 
     return rb_ary_push(e->arr, e->value);
 }
 
-VALUE rb_str_new2_wrap(VALUE arg) {
-    char **str = (char **)arg;
-
-    return rb_str_new2(*str);
-}
-
-VALUE rb_ary_entry_wrap(VALUE arg) {
-    struct rb_ary_entry_arg *e = (struct rb_ary_entry_arg *)arg;
+VALUE ruby_libvirt_ary_store_wrap(VALUE arg)
+{
+    struct ruby_libvirt_ary_store_arg *e = (struct ruby_libvirt_ary_store_arg *)arg;
 
-    return rb_ary_entry(e->arr, e->elem);
-}
+    rb_ary_store(e->arr, e->index, e->elem);
 
-VALUE rb_ary_new_wrap(VALUE arg) {
-    return rb_ary_new();
+    return Qnil;
 }
 
-VALUE rb_str_new_wrap(VALUE arg) {
-    struct rb_str_new_arg *e = (struct rb_str_new_arg *)arg;
+VALUE ruby_libvirt_str_new2_wrap(VALUE arg)
+{
+    char **str = (char **)arg;
 
-    return rb_str_new(e->val, e->size);
+    return rb_str_new2(*str);
 }
 
-VALUE rb_iv_set_wrap(VALUE arg) {
-    struct rb_iv_set_arg *e = (struct rb_iv_set_arg *)arg;
+VALUE ruby_libvirt_str_new_wrap(VALUE arg)
+{
+    struct ruby_libvirt_str_new_arg *e = (struct ruby_libvirt_str_new_arg *)arg;
 
-    return rb_iv_set(e->klass, e->member, e->value);
+    return rb_str_new(e->val, e->size);
 }
 
-VALUE rb_class_new_instance_wrap(VALUE arg) {
-    struct rb_class_new_instance_arg *e = (struct rb_class_new_instance_arg *)arg;
-
-    return rb_class_new_instance(e->argc, e->argv, e->klass);
-}
+VALUE ruby_libvirt_hash_aset_wrap(VALUE arg)
+{
+    struct ruby_libvirt_hash_aset_arg *e = (struct ruby_libvirt_hash_aset_arg *)arg;
 
-VALUE rb_string_value_cstr_wrap(VALUE arg) {
-    return (VALUE)rb_string_value_cstr((VALUE *)arg);
+    return rb_hash_aset(e->hash, rb_str_new2(e->name), e->val);
 }
 
-/* Error handling */
-VALUE create_error(VALUE error, const char* method, virConnectPtr conn) {
+void ruby_libvirt_raise_error_if(const int condition, VALUE error,
+                                 const char *method, virConnectPtr conn)
+{
     VALUE ruby_errinfo;
     virErrorPtr err;
     char *msg;
@@ -95,15 +93,23 @@ VALUE create_error(VALUE error, const char* method, virConnectPtr conn) {
     struct rb_exc_new2_arg arg;
     int exception = 0;
 
-    if (conn == NULL)
+    if (!condition) {
+        return;
+    }
+
+    if (conn == NULL) {
         err = virGetLastError();
-    else
+    }
+    else {
         err = virConnGetLastError(conn);
+    }
 
-    if (err != NULL && err->message != NULL)
+    if (err != NULL && err->message != NULL) {
         rc = asprintf(&msg, "Call to %s failed: %s", method, err->message);
-    else
+    }
+    else {
         rc = asprintf(&msg, "Call to %s failed", method);
+    }
 
     if (rc < 0) {
         /* there's not a whole lot we can do here; try to raise an
@@ -113,10 +119,12 @@ VALUE create_error(VALUE error, const char* method, virConnectPtr conn) {
 
     arg.error = error;
     arg.msg = msg;
-    ruby_errinfo = rb_protect(rb_exc_new2_wrap, (VALUE)&arg, &exception);
+    ruby_errinfo = rb_protect(ruby_libvirt_exc_new2_wrap, (VALUE)&arg,
+                              &exception);
     free(msg);
-    if (exception)
+    if (exception) {
         rb_jump_tag(exception);
+    }
 
     rb_iv_set(ruby_errinfo, "@libvirt_function_name", rb_str_new2(method));
 
@@ -124,80 +132,347 @@ VALUE create_error(VALUE error, const char* method, virConnectPtr conn) {
         rb_iv_set(ruby_errinfo, "@libvirt_code", INT2NUM(err->code));
         rb_iv_set(ruby_errinfo, "@libvirt_component", INT2NUM(err->domain));
         rb_iv_set(ruby_errinfo, "@libvirt_level", INT2NUM(err->level));
-        if (err->message != NULL)
+        if (err->message != NULL) {
             rb_iv_set(ruby_errinfo, "@libvirt_message",
                       rb_str_new2(err->message));
+        }
     }
 
-    return ruby_errinfo;
+    rb_exc_raise(ruby_errinfo);
 };
 
-char *get_string_or_nil(VALUE arg)
+char *ruby_libvirt_get_cstring_or_null(VALUE arg)
 {
-    if (TYPE(arg) == T_NIL)
+    if (TYPE(arg) == T_NIL) {
         return NULL;
-    else if (TYPE(arg) == T_STRING)
+    }
+    else if (TYPE(arg) == T_STRING) {
         return StringValueCStr(arg);
-    else
-        rb_raise(rb_eTypeError, "wrong argument type (expected String or nil)");    return NULL;
+    }
+    else {
+        rb_raise(rb_eTypeError, "wrong argument type (expected String or nil)");
+    }
+
+    return NULL;
 }
 
-VALUE generic_new(VALUE klass, void *ptr, VALUE conn,
-                  RUBY_DATA_FUNC free_func) {
+VALUE ruby_libvirt_new_class(VALUE klass, void *ptr, VALUE conn,
+                             RUBY_DATA_FUNC free_func)
+{
     VALUE result;
     result = Data_Wrap_Struct(klass, NULL, free_func, ptr);
     rb_iv_set(result, "@connection", conn);
     return result;
 }
 
-int is_symbol_or_proc(VALUE handle) {
+int ruby_libvirt_is_symbol_or_proc(VALUE handle)
+{
     return ((strcmp(rb_obj_classname(handle), "Symbol") == 0) ||
             (strcmp(rb_obj_classname(handle), "Proc") == 0));
 }
 
-/* this is an odd function, because it has massive side-effects.  The first
- * tip that something is weird here should be the triple-starred list.
+/* this is an odd function, because it has massive side-effects.
  * The intended usage of this function is after a list has been collected
  * from a libvirt list function, and now we want to make an array out of it.
  * However, it is possible that the act of creating an array causes an
  * exception, which would lead to a memory leak of the values we got from
  * libvirt.  Therefore, this function not only wraps all of the relevant
- * calls with rb_protect, it also frees every individual entry in list
- * along with list itself.
+ * calls with rb_protect, it also frees every individual entry in list after
+ * it is done with it.  Freeing list itself is left to the callers.
  */
-VALUE gen_list(int num, char ***list) {
+VALUE ruby_libvirt_generate_list(int num, char **list)
+{
     VALUE result;
     int exception = 0;
     int i, j;
-    struct rb_ary_push_arg arg;
+    struct ruby_libvirt_ary_store_arg arg;
 
-    result = rb_protect(rb_ary_new2_wrap, (VALUE)&num, &exception);
+    i = 0;
+
+    result = rb_protect(ruby_libvirt_ary_new2_wrap, (VALUE)&num, &exception);
     if (exception) {
-        for (i = 0; i < num; i++)
-            free((*list)[i]);
-        xfree(*list);
-        rb_jump_tag(exception);
+        goto exception;
     }
     for (i = 0; i < num; i++) {
         arg.arr = result;
-        arg.value = rb_protect(rb_str_new2_wrap, (VALUE)&((*list)[i]),
-                               &exception);
+        arg.index = i;
+        arg.elem = rb_protect(ruby_libvirt_str_new2_wrap, (VALUE)&(list[i]),
+                              &exception);
         if (exception) {
-            for (j = i; j < num; j++)
-                xfree((*list)[j]);
-            xfree(*list);
-            rb_jump_tag(exception);
+            goto exception;
         }
-        rb_protect(rb_ary_push_wrap, (VALUE)&arg, &exception);
+        rb_protect(ruby_libvirt_ary_store_wrap, (VALUE)&arg, &exception);
         if (exception) {
-            for (j = i; j < num; j++)
-                xfree((*list)[j]);
-            xfree(*list);
-            rb_jump_tag(exception);
+            goto exception;
         }
-        xfree((*list)[i]);
+        xfree(list[i]);
     }
-    xfree(*list);
 
     return result;
+
+exception:
+    for (j = i; j < num; j++) {
+        xfree(list[j]);
+    }
+    rb_jump_tag(exception);
+
+    /* not needed, but here to shut the compiler up */
+    return Qnil;
+}
+
+void ruby_libvirt_typed_params_to_hash(void *voidparams, int i, VALUE hash)
+{
+    virTypedParameterPtr params = (virTypedParameterPtr)voidparams;
+    VALUE val;
+
+    switch (params[i].type) {
+    case VIR_TYPED_PARAM_INT:
+        val = INT2NUM(params[i].value.i);
+        break;
+    case VIR_TYPED_PARAM_UINT:
+        val = UINT2NUM(params[i].value.ui);
+        break;
+    case VIR_TYPED_PARAM_LLONG:
+        val = LL2NUM(params[i].value.l);
+        break;
+    case VIR_TYPED_PARAM_ULLONG:
+        val = ULL2NUM(params[i].value.ul);
+        break;
+    case VIR_TYPED_PARAM_DOUBLE:
+        val = rb_float_new(params[i].value.d);
+        break;
+    case VIR_TYPED_PARAM_BOOLEAN:
+        val = (params[i].value.b == 0) ? Qfalse : Qtrue;
+        break;
+    case VIR_TYPED_PARAM_STRING:
+        val = rb_str_new2(params[i].value.s);
+        break;
+    default:
+        rb_raise(rb_eArgError, "Invalid parameter type");
+    }
+
+    rb_hash_aset(hash, rb_str_new2(params[i].field), val);
+}
+
+VALUE ruby_libvirt_get_parameters(VALUE d, unsigned int flags, void *opaque,
+                                  unsigned int typesize,
+                                  char *(*nparams_cb)(VALUE d,
+                                                      unsigned int flags,
+                                                      void *opaque,
+                                                      int *nparams),
+                                  char *(*get_cb)(VALUE d, unsigned int flags,
+                                                  void *voidparams,
+                                                  int *nparams, void *opaque),
+                                  void (*hash_set)(void *voidparams, int i,
+                                                   VALUE result))
+{
+    int nparams = 0;
+    void *params;
+    VALUE result;
+    char *errname;
+    int i;
+
+    errname = nparams_cb(d, flags, opaque, &nparams);
+    ruby_libvirt_raise_error_if(errname != NULL, e_RetrieveError, errname,
+                                ruby_libvirt_connect_get(d));
+
+    result = rb_hash_new();
+
+    if (nparams == 0) {
+        return result;
+    }
+
+    params = alloca(typesize * nparams);
+
+    errname = get_cb(d, flags, params, &nparams, opaque);
+    ruby_libvirt_raise_error_if(errname != NULL, e_RetrieveError, errname,
+                                ruby_libvirt_connect_get(d));
+
+    for (i = 0; i < nparams; i++) {
+        hash_set(params, i, result);
+    }
+
+    return result;
+}
+
+VALUE ruby_libvirt_get_typed_parameters(VALUE d, unsigned int flags,
+                                        void *opaque,
+                                        char *(*nparams_cb)(VALUE d,
+                                                            unsigned int flags,
+                                                            void *opaque,
+                                                            int *nparams),
+                                        char *(*get_cb)(VALUE d,
+                                                        unsigned int flags,
+                                                        void *params,
+                                                        int *nparams,
+                                                        void *opaque))
+{
+    return ruby_libvirt_get_parameters(d, flags, opaque,
+                                       sizeof(virTypedParameter), nparams_cb,
+                                       get_cb,
+                                       ruby_libvirt_typed_params_to_hash);
+}
+
+void ruby_libvirt_assign_hash_and_flags(VALUE in, VALUE *hash, VALUE *flags)
+{
+    if (TYPE(in) == T_HASH) {
+        *hash = in;
+        *flags = INT2NUM(0);
+    }
+    else if (TYPE(in) == T_ARRAY) {
+        if (RARRAY_LEN(in) != 2) {
+            rb_raise(rb_eArgError, "wrong number of arguments (%ld for 1 or 2)",
+                     RARRAY_LEN(in));
+        }
+        *hash = rb_ary_entry(in, 0);
+        *flags = rb_ary_entry(in, 1);
+    }
+    else {
+        rb_raise(rb_eTypeError, "wrong argument type (expected Hash or Array)");
+    }
+}
+
+int ruby_libvirt_typed_parameter_assign(VALUE key, VALUE val, VALUE in)
+{
+    struct ruby_libvirt_parameter_assign_args *args = (struct ruby_libvirt_parameter_assign_args *)in;
+    char *keyname;
+    unsigned int i;
+    int found;
+
+    keyname = StringValueCStr(key);
+
+    found = 0;
+    for (i = 0; i < args->num_allowed; i++) {
+        if (strcmp(args->allowed[i].name, keyname) == 0) {
+            args->params[args->i].type = args->allowed[i].type;
+            switch (args->params[args->i].type) {
+            case VIR_TYPED_PARAM_INT:
+                args->params[i].value.i = NUM2INT(val);
+                break;
+            case VIR_TYPED_PARAM_UINT:
+                args->params[i].value.ui = NUM2UINT(val);
+                break;
+            case VIR_TYPED_PARAM_LLONG:
+                args->params[i].value.l = NUM2LL(val);
+                break;
+            case VIR_TYPED_PARAM_ULLONG:
+                args->params[args->i].value.ul = NUM2ULL(val);
+                break;
+            case VIR_TYPED_PARAM_DOUBLE:
+                args->params[i].value.d = NUM2DBL(val);
+                break;
+            case VIR_TYPED_PARAM_BOOLEAN:
+                args->params[i].value.b = (val == Qtrue) ? 1 : 0;
+                break;
+            case VIR_TYPED_PARAM_STRING:
+                args->params[args->i].value.s = StringValueCStr(val);
+                break;
+            default:
+                rb_raise(rb_eArgError, "Invalid parameter type");
+            }
+            strncpy(args->params[args->i].field, keyname,
+                    VIR_TYPED_PARAM_FIELD_LENGTH);
+            (args->i)++;
+            found = 1;
+            break;
+        }
+    }
+
+    if (!found) {
+        rb_raise(rb_eArgError, "Unknown key %s", keyname);
+    }
+
+    return ST_CONTINUE;
+}
+
+VALUE ruby_libvirt_set_typed_parameters(VALUE d, VALUE input,
+                                        unsigned int flags, void *opaque,
+                                        struct ruby_libvirt_typed_param *allowed,
+                                        unsigned int num_allowed,
+                                        char *(*set_cb)(VALUE d,
+                                                        unsigned int flags,
+                                                        virTypedParameterPtr params,
+                                                        int nparams,
+                                                        void *opaque))
+{
+    char *errname;
+    struct ruby_libvirt_parameter_assign_args args;
+    unsigned long hashsize;
+
+    /* make sure input is a hash */
+    Check_Type(input, T_HASH);
+
+    hashsize = RHASH_SIZE(input);
+
+    if (hashsize == 0) {
+        return Qnil;
+    }
+
+    args.allowed = allowed;
+    args.num_allowed = num_allowed;
+    args.params = alloca(sizeof(virTypedParameter) * hashsize);
+    args.i = 0;
+
+    rb_hash_foreach(input, ruby_libvirt_typed_parameter_assign, (VALUE)&args);
+
+    errname = set_cb(d, flags, args.params, args.i, opaque);
+    ruby_libvirt_raise_error_if(errname != NULL, e_RetrieveError, errname,
+                                ruby_libvirt_connect_get(d));
+
+    return Qnil;
+}
+
+unsigned int ruby_libvirt_value_to_uint(VALUE in)
+{
+    if (NIL_P(in)) {
+        return 0;
+    }
+
+    return NUM2UINT(in);
+}
+
+int ruby_libvirt_value_to_int(VALUE in)
+{
+    if (NIL_P(in)) {
+        return 0;
+    }
+
+    return NUM2INT(in);
+}
+
+unsigned long ruby_libvirt_value_to_ulong(VALUE in)
+{
+    if (NIL_P(in)) {
+        return 0;
+    }
+
+    return NUM2ULONG(in);
+}
+
+unsigned long long ruby_libvirt_value_to_ulonglong(VALUE in)
+{
+    if (NIL_P(in)) {
+        return 0;
+    }
+
+    return NUM2ULL(in);
+}
+
+int ruby_libvirt_get_maxcpus(virConnectPtr conn)
+{
+    int maxcpu = -1;
+    virNodeInfo nodeinfo;
+
+#if HAVE_VIRNODEGETCPUMAP
+    maxcpu = virNodeGetCPUMap(conn, NULL, NULL, 0);
+#endif
+    if (maxcpu < 0) {
+        /* fall back to nodeinfo */
+        ruby_libvirt_raise_error_if(virNodeGetInfo(conn, &nodeinfo) < 0,
+                                    e_RetrieveError, "virNodeGetInfo", conn);
+
+        maxcpu = VIR_NODEINFO_MAXCPUS(nodeinfo);
+    }
+
+    return maxcpu;
 }