ruby-libgtop2 0.1.0

data/ext/libgtop/rb_glibtop_mem.c

@@ -0,0 +1,39 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/mem.h>
+
+
+static VALUE rb_glibtop_mem(VALUE self)
+{ 
+    glibtop_mem buf;
+    VALUE hash;
+
+    glibtop_get_mem(&buf);
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("total"), rb_uint2inum(buf.total));
+    rb_hash_aset(hash, rb_str_new2("used"), rb_uint2inum(buf.used));
+    rb_hash_aset(hash, rb_str_new2("free"), rb_uint2inum(buf.free));
+    rb_hash_aset(hash, rb_str_new2("shared"), rb_uint2inum(buf.shared));
+    rb_hash_aset(hash, rb_str_new2("buffer"), rb_uint2inum(buf.buffer));
+    rb_hash_aset(hash, rb_str_new2("cached"), rb_uint2inum(buf.cached));
+    rb_hash_aset(hash, rb_str_new2("user"), rb_uint2inum(buf.user));
+    rb_hash_aset(hash, rb_str_new2("locked"), rb_uint2inum(buf.locked));
+
+    return hash;
+}
+
+
+void Init_glibtop_mem()
+{
+    rb_define_method(cLibGTop, "mem", rb_glibtop_mem, 0);
+}

data/ext/libgtop/rb_glibtop_mountlist.c

@@ -0,0 +1,53 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/mountlist.h>
+
+
+static VALUE rb_glibtop_mountlist(VALUE self, VALUE all_fs)
+{ 
+    glibtop_mountlist buf;
+    glibtop_mountentry* mount_entries_buf;
+    VALUE hash, mount_entries, mount;
+    int i;
+
+    Check_Type(all_fs, T_FIXNUM);
+    mount_entries_buf = glibtop_get_mountlist(&buf, FIX2INT(all_fs));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("number"), rb_uint2inum(buf.number));
+    rb_hash_aset(hash, rb_str_new2("total"), rb_uint2inum(buf.total));
+    rb_hash_aset(hash, rb_str_new2("size"), rb_uint2inum(buf.size));
+
+    mount_entries = rb_ary_new2(buf.number);
+    for (i = 0; i < buf.number; i++){
+        mount = rb_hash_new();
+
+        rb_hash_aset(mount, rb_str_new2("dev"), rb_uint2inum(mount_entries_buf[i].dev));
+        rb_hash_aset(mount, rb_str_new2("devname"), rb_str_new2(mount_entries_buf[i].devname));
+        rb_hash_aset(mount, rb_str_new2("mountdir"), rb_str_new2(mount_entries_buf[i].mountdir));
+        rb_hash_aset(mount, rb_str_new2("type"), rb_str_new2(mount_entries_buf[i].type));
+
+        rb_ary_push(mount_entries, mount);
+    }
+
+    rb_hash_aset(hash, rb_str_new2("mount_entries"), mount_entries);
+
+    g_free(mount_entries_buf);
+
+    return hash;
+}
+
+
+void Init_glibtop_mountlist()
+{
+    rb_define_method(cLibGTop, "mountlist", rb_glibtop_mountlist, 1);
+}

data/ext/libgtop/rb_glibtop_msg_limits.c

@@ -0,0 +1,37 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+
+
+static VALUE rb_glibtop_msg_limits(VALUE self)
+{ 
+    glibtop_msg_limits buf;
+    VALUE hash;
+
+    glibtop_get_msg_limits(&buf);
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("msgpool"), rb_uint2inum(buf.msgpool));
+    rb_hash_aset(hash, rb_str_new2("msgmap"), rb_uint2inum(buf.msgmap));
+    rb_hash_aset(hash, rb_str_new2("msgmax"), rb_uint2inum(buf.msgmax));
+    rb_hash_aset(hash, rb_str_new2("msgmnb"), rb_uint2inum(buf.msgmnb));
+    rb_hash_aset(hash, rb_str_new2("msgmni"), rb_uint2inum(buf.msgmni));
+    rb_hash_aset(hash, rb_str_new2("msgssz"), rb_uint2inum(buf.msgssz));
+    rb_hash_aset(hash, rb_str_new2("msgtql"), rb_uint2inum(buf.msgtql));
+
+    return hash;
+}
+
+
+void Init_glibtop_msg_limits()
+{
+    rb_define_method(cLibGTop, "msg_limits", rb_glibtop_msg_limits, 0);
+}

data/ext/libgtop/rb_glibtop_netlist.c

@@ -0,0 +1,36 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#if (LIBGTOP_CHECK_VERSION(2, 9, 0))
+#include <glibtop/netlist.h>
+
+static VALUE rb_glibtop_netlist(VALUE self)
+{ 
+    glibtop_netlist buf;
+    char** devices;
+    VALUE array;
+    guint32 i;
+
+    array = rb_ary_new();
+
+    devices = glibtop_get_netlist(&buf);
+    for ( i = 0; i < buf.number; ++i) {
+        rb_ary_push(array, rb_str_new2(devices[i]));
+    }
+
+    g_free(devices);
+
+    return array;
+}
+
+void Init_glibtop_netlist()
+{
+    rb_define_method(cLibGTop, "netlist", rb_glibtop_netlist, 0);
+}
+#endif

data/ext/libgtop/rb_glibtop_netload.c

@@ -0,0 +1,82 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/netload.h>
+
+
+static VALUE rb_glibtop_netload(VALUE self, VALUE interface)
+{ 
+    glibtop_netload buf;
+    pid_t _pid;
+    VALUE hash, ary;
+    int i;
+
+    glibtop_get_netload(&buf, StringValuePtr(interface));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("if_flags"), rb_uint2inum(buf.if_flags));
+    rb_hash_aset(hash, rb_str_new2("mtu"), rb_uint2inum(buf.mtu));
+    rb_hash_aset(hash, rb_str_new2("subnet"), rb_uint2inum(buf.subnet));
+    rb_hash_aset(hash, rb_str_new2("address"), rb_uint2inum(buf.address));
+    rb_hash_aset(hash, rb_str_new2("packets_in"), rb_uint2inum(buf.packets_in));
+    rb_hash_aset(hash, rb_str_new2("packets_out"), rb_uint2inum(buf.packets_out));
+    rb_hash_aset(hash, rb_str_new2("packets_total"), rb_uint2inum(buf.packets_total));
+    rb_hash_aset(hash, rb_str_new2("bytes_in"), rb_uint2inum(buf.bytes_in));
+    rb_hash_aset(hash, rb_str_new2("bytes_out"), rb_uint2inum(buf.bytes_out));
+    rb_hash_aset(hash, rb_str_new2("bytes_total"), rb_uint2inum(buf.bytes_total));
+    rb_hash_aset(hash, rb_str_new2("errors_in"), rb_uint2inum(buf.errors_in));
+    rb_hash_aset(hash, rb_str_new2("errors_out"), rb_uint2inum(buf.errors_out));
+    rb_hash_aset(hash, rb_str_new2("errors_total"), rb_uint2inum(buf.errors_total));
+    rb_hash_aset(hash, rb_str_new2("collisions"), rb_uint2inum(buf.collisions));
+#if (LIBGTOP_CHECK_VERSION(2, 7, 4))
+    ary = rb_ary_new();
+    for (i = 0; i < sizeof(buf.address6); i++) {
+        rb_ary_push(ary, INT2FIX(buf.address6[i]));
+    }
+    rb_hash_aset(hash, rb_str_new2("address6"), ary);
+    ary = rb_ary_new();
+    for (i = 0; i < sizeof(buf.prefix6); i++) {
+        rb_ary_push(ary, INT2FIX(buf.prefix6[i]));
+    }
+    rb_hash_aset(hash, rb_str_new2("prefix6"), ary);
+    rb_hash_aset(hash, rb_str_new2("scope6"), rb_uint2inum(buf.scope6));
+    ary = rb_ary_new();
+    for (i = 0; i < sizeof(buf.hwaddress); i++) {
+        rb_ary_push(ary, INT2FIX(buf.hwaddress[i]));
+    }
+    rb_hash_aset(hash, rb_str_new2("hwaddress"), ary);
+#endif
+
+    return hash;
+}
+
+
+void Init_glibtop_netload()
+{
+    rb_define_const(cLibGTop, "IF_FLAGS_UP", INT2FIX(GLIBTOP_IF_FLAGS_UP));
+    rb_define_const(cLibGTop, "IF_FLAGS_BROADCAS", INT2FIX(GLIBTOP_IF_FLAGS_BROADCAST));
+    rb_define_const(cLibGTop, "IF_FLAGS_DEBUG", INT2FIX(GLIBTOP_IF_FLAGS_DEBUG));
+    rb_define_const(cLibGTop, "IF_FLAGS_LOOPBACK", INT2FIX(GLIBTOP_IF_FLAGS_LOOPBACK));
+    rb_define_const(cLibGTop, "IF_FLAGS_POINTOPOINT", INT2FIX(GLIBTOP_IF_FLAGS_POINTOPOINT));
+    rb_define_const(cLibGTop, "IF_FLAGS_RUNNING", INT2FIX(GLIBTOP_IF_FLAGS_RUNNING));
+    rb_define_const(cLibGTop, "IF_FLAGS_NOARP", INT2FIX(GLIBTOP_IF_FLAGS_NOARP));
+    rb_define_const(cLibGTop, "IF_FLAGS_PROMISC", INT2FIX(GLIBTOP_IF_FLAGS_PROMISC));
+    rb_define_const(cLibGTop, "IF_FLAGS_ALLMULTI", INT2FIX(GLIBTOP_IF_FLAGS_ALLMULTI));
+    rb_define_const(cLibGTop, "IF_FLAGS_OACTIVE", INT2FIX(GLIBTOP_IF_FLAGS_OACTIVE));
+    rb_define_const(cLibGTop, "IF_FLAGS_SIMPLEX", INT2FIX(GLIBTOP_IF_FLAGS_SIMPLEX));
+    rb_define_const(cLibGTop, "IF_FLAGS_LINK0", INT2FIX(GLIBTOP_IF_FLAGS_LINK0));
+    rb_define_const(cLibGTop, "IF_FLAGS_LINK1", INT2FIX(GLIBTOP_IF_FLAGS_LINK1));
+    rb_define_const(cLibGTop, "IF_FLAGS_LINK2", INT2FIX(GLIBTOP_IF_FLAGS_LINK2));
+    rb_define_const(cLibGTop, "IF_FLAGS_ALTPHYS", INT2FIX(GLIBTOP_IF_FLAGS_ALTPHYS));
+    rb_define_const(cLibGTop, "IF_FLAGS_MULTICAST", INT2FIX(GLIBTOP_IF_FLAGS_MULTICAST));
+
+    rb_define_method(cLibGTop, "netload", rb_glibtop_netload, 1);
+}

data/ext/libgtop/rb_glibtop_ppp.c

@@ -0,0 +1,39 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/ppp.h>
+
+
+static VALUE rb_glibtop_ppp(VALUE self, VALUE device)
+{ 
+    glibtop_ppp buf;
+    VALUE hash;
+
+    Check_Type(device, T_FIXNUM);
+    glibtop_get_ppp(&buf, FIX2INT(device));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("state"), rb_uint2inum(buf.state));
+    rb_hash_aset(hash, rb_str_new2("bytes_in"), rb_uint2inum(buf.bytes_in));
+    rb_hash_aset(hash, rb_str_new2("bytes_out"), rb_uint2inum(buf.bytes_out));
+
+    return hash;
+}
+
+
+void Init_glibtop_ppp()
+{
+    rb_define_const(cLibGTop, "PPP_STATE_UNKNOWN", INT2FIX(GLIBTOP_PPP_STATE_UNKNOWN));
+    rb_define_const(cLibGTop, "PPP_STATE_HANGUP", INT2FIX(GLIBTOP_PPP_STATE_HANGUP));
+    rb_define_const(cLibGTop, "PPP_STATE_ONLINE", INT2FIX(GLIBTOP_PPP_STATE_ONLINE));
+
+    rb_define_method(cLibGTop, "ppp", rb_glibtop_ppp, 1);
+}

data/ext/libgtop/rb_glibtop_proc_args.c

@@ -0,0 +1,39 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/procargs.h>
+
+
+static VALUE rb_glibtop_proc_args(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_args buf;
+    VALUE hash, str;
+    char *args;
+    int size;
+
+    args = glibtop_get_proc_args(&buf, NUM2LONG(pid), 0);
+
+    hash = rb_hash_new();
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("size"), rb_uint2inum(buf.size));
+
+    size = buf.size;
+    str = rb_str_new(args, size);
+    rb_hash_aset(hash, rb_str_new2("args"), str); 
+
+    g_free(args);
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_args()
+{
+    rb_define_method(cLibGTop, "proc_args", rb_glibtop_proc_args, 1);
+}

data/ext/libgtop/rb_glibtop_proc_kernel.c

@@ -0,0 +1,50 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/prockernel.h>
+
+
+static VALUE rb_glibtop_proc_kernel(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_kernel buf;
+    VALUE hash;
+
+    glibtop_get_proc_kernel(&buf, NUM2LONG(pid));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("k_flags"), rb_uint2inum(buf.k_flags));
+    rb_hash_aset(hash, rb_str_new2("min_flt"), rb_uint2inum(buf.min_flt));
+    rb_hash_aset(hash, rb_str_new2("maj_flt"), rb_uint2inum(buf.maj_flt));
+    rb_hash_aset(hash, rb_str_new2("cmin_flt"), rb_uint2inum(buf.cmin_flt));
+    rb_hash_aset(hash, rb_str_new2("cmaj_flt"), rb_uint2inum(buf.cmaj_flt));
+    rb_hash_aset(hash, rb_str_new2("kstk_esp"), rb_uint2inum(buf.kstk_esp));
+    rb_hash_aset(hash, rb_str_new2("kstk_eip"), rb_uint2inum(buf.kstk_eip));
+    rb_hash_aset(hash, rb_str_new2("nwchan"), rb_uint2inum(buf.nwchan));
+    rb_hash_aset(hash, rb_str_new2("wchan"), rb_str_new2(buf.wchan));
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_kernel()
+{
+    /* mumumu, these constants were not found under the include/libgtop-2.0/ */
+    rb_define_const(cLibGTop, "KFLAGS_STARTING", INT2FIX(1));
+    rb_define_const(cLibGTop, "KFLAGS_EXITING", INT2FIX(2));
+    rb_define_const(cLibGTop, "KFLAGS_PTRACED", INT2FIX(4));
+    rb_define_const(cLibGTop, "KFLAGS_TRACESYS", INT2FIX(8));
+    rb_define_const(cLibGTop, "KFLAGS_FORKNOEXEC", INT2FIX(16));
+    rb_define_const(cLibGTop, "KFLAGS_SUPERPRIV", INT2FIX(32));
+    rb_define_const(cLibGTop, "KFLAGS_DUMPEDCORE", INT2FIX(64));
+    rb_define_const(cLibGTop, "KFLAGS_SIGNALED", INT2FIX(128));
+
+    rb_define_method(cLibGTop, "proc_kernel", rb_glibtop_proc_kernel, 1);
+}

data/ext/libgtop/rb_glibtop_proc_map.c

@@ -0,0 +1,69 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/procmap.h>
+
+
+static VALUE rb_glibtop_proc_map(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_map buf;
+    glibtop_map_entry* map_entries_buf;
+    VALUE hash, map_entries, map_entry;
+    int i;
+
+    map_entries_buf = glibtop_get_proc_map(&buf, NUM2LONG(pid));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("number"), rb_uint2inum(buf.number));
+    rb_hash_aset(hash, rb_str_new2("total"), rb_uint2inum(buf.total));
+    rb_hash_aset(hash, rb_str_new2("size"), rb_uint2inum(buf.size));
+
+    map_entries = rb_ary_new2(buf.number);
+    for (i = 0; i < buf.number; i++){
+        map_entry = rb_hash_new();
+
+        rb_hash_aset(map_entry, rb_str_new2("flags"), rb_uint2inum(map_entries_buf[i].flags));
+        rb_hash_aset(map_entry, rb_str_new2("start"), rb_uint2inum(map_entries_buf[i].start));
+        rb_hash_aset(map_entry, rb_str_new2("end"), rb_uint2inum(map_entries_buf[i].end));
+        rb_hash_aset(map_entry, rb_str_new2("offset"), rb_uint2inum(map_entries_buf[i].offset));
+        rb_hash_aset(map_entry, rb_str_new2("perm"), rb_uint2inum(map_entries_buf[i].perm));
+        rb_hash_aset(map_entry, rb_str_new2("inode"), rb_uint2inum(map_entries_buf[i].inode));
+        rb_hash_aset(map_entry, rb_str_new2("device"), rb_uint2inum(map_entries_buf[i].device));
+        rb_hash_aset(map_entry, rb_str_new2("filename"), rb_str_new2(map_entries_buf[i].filename));
+
+        rb_ary_push(map_entries, map_entry);
+    }
+    rb_hash_aset(hash, rb_str_new2("map_entries"), map_entries);
+
+    g_free(map_entries_buf);
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_map()
+{
+    rb_define_const(cLibGTop, "MAP_ENTRY_START", INT2FIX(GLIBTOP_MAP_ENTRY_START));
+    rb_define_const(cLibGTop, "MAP_ENTRY_END", INT2FIX(GLIBTOP_MAP_ENTRY_END));
+    rb_define_const(cLibGTop, "MAP_ENTRY_OFFSET", INT2FIX(GLIBTOP_MAP_ENTRY_OFFSET));
+    rb_define_const(cLibGTop, "MAP_ENTRY_PERM", INT2FIX(GLIBTOP_MAP_ENTRY_PERM));
+    rb_define_const(cLibGTop, "MAP_ENTRY_INODE", INT2FIX(GLIBTOP_MAP_ENTRY_INODE));
+    rb_define_const(cLibGTop, "MAP_ENTRY_DEVICE", INT2FIX(GLIBTOP_MAP_ENTRY_DEVICE));
+    rb_define_const(cLibGTop, "MAP_ENTRY_FILENAME", INT2FIX(GLIBTOP_MAP_ENTRY_FILENAME));
+
+    rb_define_const(cLibGTop, "MAP_PERM_READ", INT2FIX(GLIBTOP_MAP_PERM_READ));
+    rb_define_const(cLibGTop, "MAP_PERM_WRITE", INT2FIX(GLIBTOP_MAP_PERM_WRITE));
+    rb_define_const(cLibGTop, "MAP_PERM_EXECUTE", INT2FIX(GLIBTOP_MAP_PERM_EXECUTE));
+    rb_define_const(cLibGTop, "MAP_PERM_SHARED", INT2FIX(GLIBTOP_MAP_PERM_SHARED));
+    rb_define_const(cLibGTop, "MAP_PERM_PRIVATE", INT2FIX(GLIBTOP_MAP_PERM_PRIVATE));
+
+    rb_define_method(cLibGTop, "proc_map", rb_glibtop_proc_map, 1);
+}