sys-proctable 0.7.4 → 0.7.5

data/CHANGES

@@ -1,3 +1,7 @@
+== 0.7.5 - 23-Nov-2006
+* Fixed int/long issues for Linux.  Thanks go to Matt Lightner for the spot.
+* Minor documentation fixes and changes to the extconf.rb file.
+
 == 0.7.4 - 20-Nov-2006
 * Added a patch that deals with the large file compilation issue on Solaris.
   You no longer need to build Ruby with --disable-largefile, or build a
@@ -20,7 +24,7 @@
 * Include bsd.c in tarball (oops).
 * Minor test updates for FreeBSD.
 * The 'pct_cpu' member for the BSD/kvm version has been changed to 'pctcpu'
-  consistency with other platforms.
+  for consistency with other platforms.
 
 == 0.7.1 - 8-May-2005
 * Bug fixed for the cmdline info on Linux.  Thanks go to Arash Abedinzadeh

data/doc/freebsd.txt

@@ -38,7 +38,7 @@ VERSION
 
 = Class Methods
 ProcTable.fields
-   Returns a list of fields available on the current OS. Also takes a block.
+   Returns an array of fields available on the current OS.
 
 ProcTable.ps(pid = nil)
 ProcTable.ps{ |s| ... }

data/doc/hpux.txt

@@ -30,8 +30,7 @@ VERSION
 
 = Class Methods
 ProcTable.fields
-   Returns a list of fields available on the current OS.  May also take
-   a block.
+   Returns an array of fields available on the current OS.
 
 ProcTable.ps(pid=nil)
 ProcTable.ps{ |s| ... }

data/doc/linux.txt

@@ -38,8 +38,7 @@ VERSION
 
 = Class Methods
 ProcTable.fields
-   Returns a list of fields available on the current OS.  May also take a
-   block.
+   Returns an array of fields available on the current OS.
 
 ProcTable.ps(pid=nil)
 ProcTable.ps{ |s| ... }

data/doc/solaris.txt

@@ -36,8 +36,7 @@ VERSION
     
 = Class Methods
 ProcTable.fields
-   Returns a list of fields available on the current OS.  May also take
-   a block.
+   Returns an array of fields available on the current OS.
     
 ProcTable.ps(pid=nil)
 ProcTable.ps{ |s| ... }

data/ext/extconf.rb

@@ -84,7 +84,6 @@ File.open(test_file, 'w'){ |fh|
    fh.puts '$LOAD_PATH.unshift Dir.pwd'
    fh.puts '$LOAD_PATH.unshift Dir.pwd + "/lib"'
    fh.puts '$LOAD_PATH.unshift Dir.pwd + "/ext"'
-   fh.puts "require 'tc_all'"
    fh.puts "require '#{tc_file}'"
    fh.puts "require 'tc_top'"
 }
@@ -95,7 +94,7 @@ File.open(test_file, 'w'){ |fh|
 File.delete('proctable.c') rescue nil
 File.delete(File.basename(h_file)) rescue nil
 
-File.symlink(c_file, 'proctable.c')
-File.symlink(h_file, File.basename(h_file)) if h_file
+FileUtils.cp(c_file, 'proctable.c')
+FileUtils.cp(h_file, File.basename(h_file)) if h_file
 
 create_makefile('sys/proctable')

data/ext/linux/linux.c

@@ -0,0 +1,320 @@
+/***************************************************************
+ * linux.c (proctable.c)
+ *
+ * Linux specific code for the Ruby ps extension.  Some code
+ * has been copied directly from Dan Urist's Proc::ProcessTable
+ * Perl module.
+ *
+ * Author: Daniel J. Berger
+ **************************************************************/
+#include "ruby.h"
+#include "linux.h"
+#include "version.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+VALUE sProc, cProcError;
+
+/* 
+ * Converts a proc_info struct into a Ruby struct.
+ */
+static VALUE proctable_get_process(struct proc_info *p, VALUE env_hash) {
+   return rb_struct_new(sProc,
+      rb_str_new2(p->cmdline),
+      rb_str_new2(p->cwd),
+      rb_str_new2(p->exe),
+      INT2FIX(p->pid),
+      rb_str_new2(p->name),
+      INT2FIX(p->uid),
+      INT2FIX(p->euid),
+      INT2FIX(p->gid),
+      INT2FIX(p->egid),
+      rb_str_new2(p->comm),
+      rb_str_new(p->state,1),
+      INT2FIX(p->ppid),
+      INT2FIX(p->pgrp),
+      INT2FIX(p->session),
+      INT2FIX(p->tty_num),
+      INT2FIX(p->tpgid),
+      ULONG2NUM(p->flags),
+      ULONG2NUM(p->minflt),
+      ULONG2NUM(p->cminflt),
+      ULONG2NUM(p->majflt),
+      ULONG2NUM(p->cmajflt),
+      ULONG2NUM(p->utime),
+      ULONG2NUM(p->stime),
+      LONG2FIX(p->cutime),
+      LONG2FIX(p->cstime),
+      LONG2FIX(p->priority),
+      LONG2FIX(p->nice),
+      LONG2FIX(p->itrealvalue),
+      ULONG2NUM(p->starttime),
+      ULONG2NUM(p->vsize),
+      LONG2FIX(p->rss),
+      ULONG2NUM(p->rlim),
+      ULONG2NUM(p->startcode),
+      ULONG2NUM(p->endcode),
+      ULONG2NUM(p->startstack),
+      ULONG2NUM(p->kstkesp),
+      ULONG2NUM(p->kstkeip),
+      ULONG2NUM(p->signal),
+      ULONG2NUM(p->blocked),
+      ULONG2NUM(p->sigignore),
+      ULONG2NUM(p->sigcatch),
+      ULONG2NUM(p->wchan),
+      ULONG2NUM(p->nswap),
+      ULONG2NUM(p->cnswap),
+      INT2FIX(p->exit_signal),
+      INT2FIX(p->processor),
+      env_hash
+   );
+}
+
+/*
+ * call-seq:
+ *    ProcTable.ps(pid=nil)
+ *    ProcTable.ps(pid=nil){ |ps| ... }
+ *
+ * In block form, yields a ProcTableStruct for each process entry that you
+ * have rights to.  This method returns an array of ProcTableStruct's in
+ * non-block form.
+ *
+ * If a +pid+ is provided, then only a single ProcTableStruct is yielded or
+ * returned, or nil if no process information is found for that +pid+.
+ */
+static VALUE proctable_ps(int argc, VALUE *argv, VALUE klass){
+   DIR* dir_ptr;
+   FILE* file_ptr;
+   struct dirent* dirent_ptr;
+   struct proc_info p;
+   char pathbuf[NAME_MAX];
+   int temp, num_scanned;
+   int pid = -1;
+
+   VALUE v_pid     = Qnil;
+   VALUE v_array   = Qnil;
+   VALUE v_pstruct = Qnil;
+   VALUE v_env     = rb_hash_new();
+
+   rb_scan_args(argc, argv, "01", &v_pid);
+
+   if((dir_ptr = opendir("/proc")) == NULL)
+      rb_raise(cProcError, "/proc filesystem unreadable");
+   
+   if(!NIL_P(v_pid))
+      pid = NUM2INT(v_pid);
+      
+   if(!rb_block_given_p())
+      v_array = rb_ary_new();
+
+   /* Iterate through all the (numeric) process entries uner /proc */
+   while((dirent_ptr = readdir(dir_ptr)) != NULL){
+
+      /* Only look at this file if it's a proc id; that is, all numbers */
+      if( strtok(dirent_ptr->d_name, "0123456789") != NULL )
+         continue;
+
+      if(!NIL_P(v_pid)){
+         if(atoi(dirent_ptr->d_name) != pid){
+            continue;
+         }
+      }
+
+      /* Get the /proc/PID/cmdline info */
+      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/cmdline");
+      if( (file_ptr = fopen(pathbuf, "r")) != NULL ){
+         size_t got;
+         if((got = fread(p.cmdline, sizeof(char), ARG_MAX, file_ptr)) > 0 ){
+            size_t i;
+            
+            /* Replace \0 characters with spaces */
+            for(i = 0; i < got; i++){
+               if(p.cmdline[i] == '\0'){
+                  p.cmdline[i] = ' ';
+               }
+            }
+            
+            p.cmdline[got] = '\0';
+            trimr(p.cmdline);       /* Trim trailing whitespace */
+         }
+         fclose(file_ptr);
+      }
+
+      /* Get the /proc/PID/exe info (which is a link) */
+      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/exe");
+      memset(p.exe, 0, sizeof(p.exe));
+
+      if(readlink(pathbuf, p.exe, sizeof(p.exe)) == -1){ /* Ignore */ }
+
+      /* Get the /proc/PID/cwd info (which is a link) */
+      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/cwd");
+      memset(p.cwd, 0, sizeof(p.cwd));
+
+      if(readlink(pathbuf, p.cwd, sizeof(p.cwd)) == -1){ /* Ignore */ }
+
+      /* Get name, uid, euid, gid and gid info out of /proc/PID/status */
+      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/status");
+
+      if((file_ptr = fopen(pathbuf,"r")) != NULL ){
+         char line[ARG_MAX];
+         char dummy[ARG_MAX];
+
+         while(fgets(line, ARG_MAX - 1, file_ptr) != NULL){ 
+            if(!strncmp("Name", line, strlen("Name"))) { 
+               sscanf(line, "%s %s", dummy, p.name);
+            }
+            else if(!strncmp("Uid", line, strlen("Uid"))){ 
+               sscanf(line, "%s %d %d", dummy, &p.uid, &p.euid);
+            }
+            else if (!strncmp("Gid", line, strlen("Gid"))) { 
+               sscanf(line, "%s %d %d", dummy, &p.gid, &p.egid);
+            }
+         }
+         fclose(file_ptr);
+      }
+
+      /* Get the /proc/PID/stat info */
+      sprintf(pathbuf,"%s%s%s","/proc/",dirent_ptr->d_name,"/stat");
+      if((file_ptr = fopen(pathbuf,"r")) != NULL){
+         num_scanned = fscanf(file_ptr,
+            "%d %s %s %d %d\
+            %d %d %d %lu %lu\
+            %lu %lu %lu %lu %lu\
+            %ld %ld %ld %ld %d\
+            %ld %lu %lu %ld %lu\
+            %lu %lu %lu %lu %lu\
+            %lu %lu %lu %lu %lu\
+            %lu %lu %d %d",
+            &p.pid,        p.comm,       p.state,       &p.ppid,     &p.pgrp,
+            &p.session,    &p.tty_num,   &p.tpgid,      &p.flags,    &p.minflt,
+            &p.cminflt,    &p.majflt,    &p.cmajflt,    &p.utime,    &p.stime,
+            &p.cutime,     &p.cstime,    &p.priority,   &p.nice,     &temp,
+            &p.itrealvalue,&p.starttime, &p.vsize,      &p.rss,      &p.rlim,
+            &p.startcode,  &p.endcode,   &p.startstack, &p.kstkesp,  &p.kstkeip,
+            &p.signal,     &p.blocked,   &p.sigignore,  &p.sigcatch, &p.wchan,
+            &p.nswap,      &p.cnswap,    &p.exit_signal,&p.processor
+         );
+
+         fclose(file_ptr);
+
+         if(num_scanned < 39)
+            rb_sys_fail("fscanf");
+      }
+
+      /* Get rid of the parens in the comm field */
+      strcpy(p.comm, strtok(p.comm,"()"));
+
+      /**********************************************************************
+       * Get the environ string out or /proc/PID/environ and make a hash
+       *  out of it
+       **********************************************************************/
+      sprintf(pathbuf, "%s%s%s", "/proc/", dirent_ptr->d_name, "/environ");
+      if((file_ptr = fopen( pathbuf, "r" )) != NULL){
+
+         int count;
+         char env_buf[ARG_MAX];
+         char key[MAX_ENV_NAME];
+         char *next_var, *value;
+
+         /* Get char count */
+         count = fread(env_buf, sizeof(char), ARG_MAX, file_ptr); 
+         next_var = env_buf;
+
+         while(next_var < env_buf + count){
+            value = strchr(next_var,'=');
+            /***************************************************************
+             * It's possible some environ files contain data that's not in
+             * the KEY=value format.  For such cases, we'll just set the
+             * string as the key, and set the corresponding value to nil.
+             ***************************************************************/
+            if(NULL == value){
+               rb_hash_aset(v_env, rb_str_new2(next_var), Qnil);
+               break;
+            }
+            strncpy(key, next_var, value - next_var);
+            key[value-next_var] = '\0';
+
+            ++value;
+            rb_hash_aset(v_env, rb_str_new2(key), rb_str_new2(value));
+            next_var += strlen(next_var) + 1;
+         }
+
+         fclose(file_ptr);
+      }
+
+      /* If cmdline is empty, use comm instead */
+      if(0 == strlen(p.cmdline))
+         strcpy(p.cmdline, p.comm);
+      
+      v_pstruct = proctable_get_process(&p, v_env);
+
+      if(rb_block_given_p())
+         rb_yield(v_pstruct);
+      else
+         rb_ary_push(v_array, v_pstruct);
+   }
+
+   closedir(dir_ptr);
+
+   /* If a process ID was provided and found, return a single struct */
+   if(!NIL_P(v_pid))
+      return v_pstruct;
+   
+   return v_array; /* nil if block was provided */
+}
+
+/*
+ * call-seq:
+ *    ProcTable.fields
+ *
+ * Returns an array of fields that each ProcTableStruct will contain.  This
+ * may be useful if you want to know in advance what fields are available
+ * without having to perform at least one read of the /proc table.
+ */
+static VALUE proctable_fields(VALUE klass){
+   unsigned int i;
+   VALUE rbFarray = rb_ary_new();
+   
+   for(i = 0; i < sizeof(fields)/sizeof(fields[0]); i++)
+      rb_ary_push(rbFarray,rb_str_new2(fields[i]));
+
+   return rbFarray;
+}
+
+/*
+ * A Ruby interface for gathering process table information.
+ */
+void Init_proctable()
+{
+   VALUE mSys, cProcTable;
+
+   /* Modules and Classes */
+   mSys = rb_define_module("Sys");
+   cProcTable = rb_define_class_under(mSys, "ProcTable", rb_cObject);
+   cProcError = rb_define_class_under(mSys, "ProcTableError",rb_eStandardError);
+   
+   /* Class Methods */
+   rb_define_singleton_method(cProcTable, "fields", proctable_fields, 0);
+   rb_define_singleton_method(cProcTable, "ps", proctable_ps, -1);
+
+   /* Constants */
+   rb_define_const(cProcTable,"VERSION",rb_str_new2(SYS_PROCTABLE_VERSION));
+
+   /* Structs */
+   sProc = rb_struct_define("ProcTableStruct","cmdline","cwd","exe","pid",
+      "name", "uid", "euid", "gid", "egid", "comm","state","ppid",
+      "pgrp","session","tty_num","tpgid","flags","minflt","cminflt","majflt",
+      "cmajflt","utime","stime","cutime","cstime","priority","nice",
+      "itrealvalue","starttime","vsize","rss","rlim","startcode","endcode",
+      "startstack","kstkesp","kstkeip","signal","blocked","sigignore",
+      "sigcatch","wchan","nswap","cnswap","exit_signal","processor","environ",
+      NULL
+   );
+}
+
+#ifdef __cplusplus
+}
+#endif

data/ext/linux/linux.h

@@ -0,0 +1,138 @@
+/************************************************************************
+ * linux.h
+ *
+ * Linux specific information, including struct layout.
+ ************************************************************************/
+#include <dirent.h>
+#include <linux/limits.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifndef CLK_TCK
+#define CLK_TCK sysconf(_SC_CLK_TCK)
+#endif
+
+#define MAX_ENV_NAME 128
+
+/**************************************************************************** 
+ * Note that the 20th field (between nice and itrealvalue) is not included
+ * in our struct.  It is a simple placeholder that was hardcoded for a
+ * removed field.  See the proc man page for more details.
+ *
+ * Also note that the environ attribute is not part of this struct, mostly
+ * because I wouldn't know what type to set it to.  It *is* part of the ruby
+ * struct, however.
+ ****************************************************************************/
+struct proc_info{
+   char cmdline[ARG_MAX];
+   char cwd[ARG_MAX];
+   char exe[ARG_MAX];
+   int pid;
+   char name[ARG_MAX];
+   int uid;
+   int euid;
+   int gid;
+   int egid;
+   char comm[ARG_MAX];
+   char state[1];
+   int ppid;
+   int pgrp;
+   int session;
+   int tty_num;
+   int tpgid;
+   unsigned long flags;
+   unsigned long minflt;
+   unsigned long cminflt;
+   unsigned long majflt;
+   unsigned long cmajflt;
+   unsigned long utime;
+   unsigned long stime;
+   long cutime;
+   long cstime;
+   long priority;
+   long nice;
+   long itrealvalue;
+   unsigned long starttime;
+   unsigned long vsize;
+   long rss;
+   unsigned long rlim;
+   unsigned long startcode;
+   unsigned long endcode;
+   unsigned long startstack;
+   unsigned long kstkesp;
+   unsigned long kstkeip;
+   unsigned long signal;
+   unsigned long blocked;
+   unsigned long sigignore;
+   unsigned long sigcatch;
+   unsigned long wchan;
+   unsigned long nswap;
+   unsigned long cnswap;
+   int exit_signal;
+   int processor;
+};
+
+/*****************************************************************************
+ * This array's only purpose is for the 'fields()' class method.  If there's
+ * a way to report fields out of our defined struct (sProc), please tell me
+ * how!
+ *****************************************************************************/
+char *fields[] = {
+   "cmdline",
+   "cwd",
+   "exe",
+   "pid",
+   "name",
+   "uid",
+   "euid",
+   "gid",
+   "egid",
+   "comm",
+   "state",
+   "ppid",
+   "pgrp",
+   "session",
+   "tty_num",
+   "tpgid",
+   "flags",
+   "minflt",
+   "cminflt",
+   "majflt",
+   "cmajflt",
+   "utime",
+   "stime",
+   "cutime",
+   "cstime",
+   "priority",
+   "nice",
+   "itrealvalue",
+   "starttime",
+   "vsize",
+   "rss",
+   "rlim",
+   "startcode",
+   "endcode",
+   "startstack",
+   "kstkesp",
+   "kstkeip",
+   "signal",
+   "blocked",
+   "sigignore",
+   "sigcatch",
+   "wchan",
+   "nswap",
+   "cnswap",
+   "exit_signal",
+   "processor",
+   "environ"
+};
+
+/* Helper function to remove trailing whitespace.  Use for cmdline info */
+void trimr(char* s){
+   char* p = s + strlen(s);
+   while(--p >= s && isspace(*p))
+      ;
+
+   *++p = 0;
+}

data/ext/version.h

@@ -1,2 +1,2 @@
 /* version.h - stores the version number for all platforms (that use C) */
-#define SYS_PROCTABLE_VERSION "0.7.4"
+#define SYS_PROCTABLE_VERSION "0.7.5"

data/test/tc_all.rb

@@ -22,14 +22,14 @@ if base == 'test' || base =~ /sys-proctable.*/
    $LOAD_PATH.unshift(Dir.pwd + '/lib')
 end
 
-require 'sys/proctable'
 require 'test/unit'
+require 'sys/proctable'
 include Sys
 
 class TC_ProcTable_All < Test::Unit::TestCase
 
    def test_version
-      assert_equal('0.7.4', ProcTable::VERSION)
+      assert_equal('0.7.5', ProcTable::VERSION)
    end
 
    def test_fields

data/test/tc_linux.rb

@@ -9,7 +9,7 @@ if base == 'test' || base =~ /sys-proctable.*/
    require 'fileutils'
    require 'rbconfig'
 
-   Dir.chdir '..' if base == 'test'
+   Dir.chdir('..') if base == 'test'
    file = 'ext/proctable.' + Config::CONFIG['DLEXT']
    Dir.mkdir('sys') unless File.exists?('sys')
    FileUtils.cp(file, 'sys')
@@ -17,10 +17,7 @@ if base == 'test' || base =~ /sys-proctable.*/
    $LOAD_PATH.unshift(Dir.pwd)
 end
 
-require "sys/proctable"
-require "test/unit"
 require "test/tc_all"
-include Sys
 
 class TC_ProcTable_Linux < Test::Unit::TestCase
 

data/test/tc_top.rb

@@ -6,15 +6,13 @@
 base = File.basename(Dir.pwd)
 
 if base == 'test' || base =~ /sys-proctable.*/
-   require 'fileutils'
    Dir.chdir('..') if base == 'test'
-   Dir.mkdir('sys') unless File.exists?('sys')
-   FileUtils.cp('lib/top.rb', 'sys')
-   $LOAD_PATH.unshift Dir.pwd
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + '/lib')
 end
 
-require 'sys/top'
 require 'test/unit'
+require 'sys/top'
 include Sys
 
 class TC_Top < Test::Unit::TestCase

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: sys-proctable
 version: !ruby/object:Gem::Version 
-  version: 0.7.4
-date: 2006-11-21 00:00:00 -07:00
+  version: 0.7.5
+date: 2006-11-23 00:00:00 -07:00
 summary: An interface for providing process table information
 require_paths: 
 - lib
@@ -30,30 +30,30 @@ authors:
 - Daniel J. Berger
 files: 
 - doc/freebsd.txt
-- doc/hpux.txt
-- doc/linux.txt
-- doc/solaris.txt
 - doc/top.txt
+- doc/solaris.txt
 - doc/windows.txt
-- test/tc_all.rb
-- test/tc_freebsd.rb
-- test/tc_hpux.rb
-- test/tc_kvm_bsd.rb
+- doc/hpux.txt
+- doc/linux.txt
 - test/tc_linux.rb
 - test/tc_sunos.rb
-- test/tc_top.rb
+- test/tc_kvm_bsd.rb
+- test/tc_hpux.rb
 - test/tc_windows.rb
 - test/test_memleak.rb
+- test/tc_all.rb
+- test/tc_freebsd.rb
+- test/tc_top.rb
 - lib/sys/top.rb
 - CHANGES
 - README
 - MANIFEST
-- ext/sunos/sunos.c
+- ext/linux/linux.c
 - ext/extconf.rb
 - ext/version.h
-- ext/sunos/sunos.h
+- ext/linux/linux.h
 test_files: 
-- test/tc_sunos.rb
+- test/tc_linux.rb
 rdoc_options: []
 
 extra_rdoc_files: 
@@ -61,8 +61,8 @@ extra_rdoc_files:
 - README
 - MANIFEST
 - doc/top.txt
-- doc/solaris.txt
-- ext/sunos/sunos.c
+- doc/linux.txt
+- ext/linux/linux.c
 executables: []
 
 extensions: 

data/ext/sunos/sunos.c

@@ -1,374 +0,0 @@
-/**************************************************************************
- * sunos.c (proctable.c)
- *
- * Solaris specific code for the Ruby ps extension.  Some code
- * has been copied directly from Dan Urist's Proc::ProcessTable
- * Perl module.
- *
- * The portion of code that grabs data out of /proc/xxx/as is based
- * on a post by Roger Faulkner on comp.unix.questions.
- **************************************************************************/
-#include "ruby.h"
-#include "sunos.h"
-#include "version.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-VALUE sProcStruct, cProcError;
-
-/*
- * Private method that converts a psinfo struct into a Ruby struct.
- */
-#ifdef HAVE_PROCFS_H
-static VALUE proctable_getprocstruct(struct psinfo *p, VALUE v_cmd_array)
-#else
-static VALUE proctable_getprocstruct(struct prpsinfo *p, VALUE v_cmd_array)
-#endif
-{
-   char state[STATE_MAX];
-   char comm[COMM_MAX];
-   prusage_t pbuf;
-   VALUE cmdline;
-   VALUE rbTTY = Qnil;
-
-   /*
-    * If we were unable to get the full command line, resort to the limited
-    * pr_psargs struct member.
-    */
-   if(RARRAY(v_cmd_array)->len == 0)
-      cmdline = rb_str_new2(p->pr_psargs);
-   else
-      cmdline = rb_ary_join(v_cmd_array,rb_str_new2(" "));
-
-   if(PRNODEV != p->pr_ttydev)
-      rbTTY = UINT2NUM(p->pr_ttydev);
-   else
-      rbTTY = INT2NUM(-1);
-
-#ifndef HAVE_PROCFS_H
-   char wchan[WCHAN_MAX];
-   sprintf(wchan, "%x", (unsigned int)p->pr_wchan);
-#endif
-
-#ifdef HAVE_PROCFS_H
-   switch(p->pr_lwp.pr_state)
-#else
-   switch(p->pr_state)
-#endif
-   {
-      case SSLEEP: 
-         strcpy(state, SLEEP);
-         break;
-      case SRUN:
-         strcpy(state, RUN);
-         break;
-      case SZOMB:
-         strcpy(state, ZOMBIE);
-         break;
-      case SSTOP:
-         strcpy(state, STOP);
-         break;
-      case SIDL:
-         strcpy(state, IDLE);
-         break;
-      case SONPROC:
-         strcpy(state, ONPROC);
-         break;
-   }
-
-   strcpy(comm, p->pr_fname);
-
-   getprusage(p->pr_pid,&pbuf); /* Get the process usage info */
-
-   return rb_struct_new(sProcStruct,
-      INT2FIX(p->pr_flag),
-#ifdef HAVE_PROCFS_H
-      INT2FIX(p->pr_nlwp),
-#endif
-      UINT2NUM(p->pr_pid),
-      UINT2NUM(p->pr_ppid),
-#ifdef HAVE_PROCFS_H
-      UINT2NUM(p->pr_pgid),
-#else
-      UINT2NUM(p->pr_pgrp),
-#endif
-      UINT2NUM(p->pr_sid),
-      UINT2NUM(p->pr_uid),
-      UINT2NUM(p->pr_euid),
-      UINT2NUM(p->pr_gid),
-      UINT2NUM(p->pr_egid),
-#ifdef HAVE_PROCFS_H
-      INT2FIX(p->pr_lwp.pr_pri),
-      INT2FIX(p->pr_lwp.pr_nice),
-#else
-      INT2FIX(p->pr_pri),
-      INT2FIX(p->pr_nice),
-#endif
-      rbTTY,
-      INT2FIX(p->pr_time.tv_sec),
-      INT2FIX(p->pr_ctime.tv_sec),
-#ifdef HAVE_PROCFS_H
-      INT2FIX(p->pr_size * 1024),
-      INT2FIX(p->pr_rssize * 1024),
-      UINT2NUM(p->pr_lwp.pr_wchan),
-#else
-      INT2FIX(p->pr_bysize),
-      INT2FIX(p->pr_rssize),
-      rb_str_new2(wchan),
-#endif
-      rb_float_new(((double)p->pr_pctcpu)/0x8000*100),
-      rb_float_new(((double)p->pr_pctmem)/0x8000*100),
-      rb_str_new2(state),
-      rb_str_new2(p->pr_fname),
-      cmdline,
-      rb_time_new(p->pr_start.tv_sec,0),
-#ifdef HAVE_PROCFS_H
-      INT2NUM(p->pr_lwp.pr_onpro),
-#endif
-      rb_str_new2(comm),
-      INT2FIX(p->pr_argc),
-      v_cmd_array,
-      LONG2FIX(pbuf.pr_lwpid),
-      INT2FIX(pbuf.pr_count),
-      LONG2FIX(pbuf.pr_tstamp.tv_sec),
-      LONG2FIX(pbuf.pr_create.tv_sec),
-      LONG2FIX(pbuf.pr_term.tv_sec),
-      LONG2FIX(pbuf.pr_rtime.tv_sec),
-      LONG2FIX(pbuf.pr_utime.tv_sec),
-      LONG2FIX(pbuf.pr_stime.tv_sec),
-      LONG2FIX(pbuf.pr_ttime.tv_sec),
-      LONG2FIX(pbuf.pr_tftime.tv_sec),
-      LONG2FIX(pbuf.pr_dftime.tv_sec),
-      LONG2FIX(pbuf.pr_kftime.tv_sec),
-      LONG2FIX(pbuf.pr_ltime.tv_sec),
-      LONG2FIX(pbuf.pr_slptime.tv_sec),
-      LONG2FIX(pbuf.pr_wtime.tv_sec),
-      LONG2FIX(pbuf.pr_stoptime.tv_sec),
-      ULONG2NUM(pbuf.pr_minf),
-      ULONG2NUM(pbuf.pr_majf),
-      ULONG2NUM(pbuf.pr_nswap),
-      ULONG2NUM(pbuf.pr_inblk),
-      ULONG2NUM(pbuf.pr_oublk),
-      ULONG2NUM(pbuf.pr_msnd),
-      ULONG2NUM(pbuf.pr_mrcv),
-      ULONG2NUM(pbuf.pr_sigs),
-      ULONG2NUM(pbuf.pr_vctx),
-      ULONG2NUM(pbuf.pr_ictx),
-      ULONG2NUM(pbuf.pr_sysc),
-      ULONG2NUM(pbuf.pr_ioch)
-   );
-}
-
-/*
- * call-seq:
- *    ProcTable.ps(pid=nil)
- *    ProcTable.ps(pid=nil){ |ps| ... }
- *
- * In block form, yields a ProcTableStruct for each process entry that you
- * have rights to.  This method returns an array of ProcTableStruct's in
- * non-block form.
- *
- * If a +pid+ is provided, then only a single ProcTableStruct is yielded or
- * returned, or nil if no process information is found for that +pid+.
- */
-static VALUE proctable_ps(int argc, VALUE *argv, VALUE klass)
-{
-   DIR *procdir;
-   struct dirent *procdirp;
-   int psdata;
-   char pathbuf[PATH_MAX];
-
-   char* arg;
-   uintptr_t addr_args;
-   uintptr_t* arg_vec;
-   size_t arg_len;
-   int fd, arg_count, i, pid;
-
-   VALUE v_pid;
-   VALUE v_ps_struct = Qnil;
-   VALUE v_array = Qnil;
-   VALUE v_cmd_array = rb_ary_new();
-
-#ifdef HAVE_PROCFS_H
-   struct psinfo p;
-   char as_file[MAXPATHLEN];
-#else
-   struct prpsinfo p;
-#endif
-
-   rb_scan_args(argc, argv, "01", &v_pid);
-
-   if(!rb_block_given_p())
-      v_array = rb_ary_new();
-
-   if( (procdir = opendir( "/proc" )) == NULL )
-      rb_raise(cProcError,"/proc filesystem unreadable");
-
-   while( (procdirp = readdir(procdir)) != NULL )
-   {
-      /* Only look at this file if it's a proc id; that is, all numbers */
-      if(strtok(procdirp->d_name, "0123456789") != NULL ){ continue; }
-
-      /* If a pid is provided, only return info on that pid */
-      if(!NIL_P(v_pid)){
-         pid = NUM2INT(v_pid);
-         if(atoi(procdirp->d_name) != pid)
-            continue;
-      }
-    
-      /* Construct path of the form /proc/proc_number */
-      strcpy(pathbuf, "/proc/"); 
-      strcpy(as_file, "/proc/");
-      strcat(pathbuf, procdirp->d_name);
-      strcat(as_file, procdirp->d_name);
-    
-#ifdef HAVE_PROCFS_H
-      strcat(pathbuf, "/psinfo"); /* Solaris 2.6+ has process info here */
-      strcat(as_file, "/as");
-#endif
-
-      if( (psdata = open( pathbuf, O_RDONLY )) == -1 )
-         continue;
-
-#ifdef HAVE_PROCFS_H
-      read(psdata, (void *) &p, sizeof(struct psinfo));
-#else
-      if(ioctl(psdata, PIOCPSINFO, &p) == -1)
-         continue;
-#endif
-
-#ifdef HAVE_PROCFS_H
-      /*
-       * For those processes where it is possible to read /proc/xxx/as
-       * get the entire command line string.
-       */
-      addr_args = p.pr_argv;
-      arg_count = p.pr_argc;
-
-      if((fd = open(as_file, O_RDONLY)) < 0){
-         /* Do nothing - you can only get info on processes you rights to */
-      }
-      else
-      {
-         arg_vec = malloc(arg_count * sizeof(uintptr_t));
-         
-         /* We need this here to pick up args properly on 2.8+ */
-#ifdef PR_MODEL_NATIVE         
-         if(p.pr_dmodel == PR_MODEL_NATIVE){
-            (void)pread(fd, arg_vec, arg_count * sizeof (uintptr_t), addr_args);
-         }
-         else{
-            caddr32_t *arg_vec32 = (caddr32_t *)arg_vec;
-            (void)pread(fd, arg_vec32, arg_count * sizeof (caddr32_t), addr_args);
-            for (i = arg_count - 1; i >= 0; --i)
-            {
-               arg_vec[i] = arg_vec32[i];
-            }
-         }
-#else
-         /* Need a better patch for 2.6 here */
-         (void)pread(fd, arg_vec, arg_count * sizeof (uintptr_t), addr_args);
-#endif
-
-         arg_len = 16;
-         arg = malloc(arg_len+1);
-         for(i = 0; i < arg_count; i++) {
-
-            if(pread(fd, arg, arg_len, arg_vec[i]) < 0)
-               continue;
-
-            arg[arg_len] = '\0';
-            if(strlen(arg) == arg_len){
-               arg_len *= 2;
-               arg = realloc(arg, arg_len + 1);
-               i--;
-               continue;
-            }
-            rb_ary_push(v_cmd_array, rb_str_new2(arg));
-         }
-         free(arg);
-         free(arg_vec);
-      }
-      close(fd);
-#endif
-
-      close(psdata);
-      v_ps_struct = proctable_getprocstruct(&p, v_cmd_array);
-
-      if(rb_block_given_p()){
-         rb_yield(v_ps_struct);
-      }
-      else{
-         rb_ary_push(v_array, v_ps_struct);
-      }
-      rb_ary_clear(v_cmd_array);
-   }
-   closedir(procdir);
-
-   /* If a process ID was provided and found, return a single struct */
-   if(!NIL_P(v_pid))
-      return v_ps_struct;
-   
-   return v_array; /* nil if block was provided */
-}
-
-/*
- * call-seq:
- *    ProcTable.fields
- *
- * Returns an array of fields that each ProcTableStruct will contain.  This
- * may be useful if you want to know in advance what fields are available
- * without having to perform at least one read of the /proc table.
- */
-static VALUE proctable_fields(VALUE klass){
-   uint_t i;
-   VALUE rbFarray = rb_ary_new();
-
-   for(i = 0; i < (sizeof(fields) / sizeof(fields[0])); i++)
-      rb_ary_push(rbFarray, rb_str_new2(fields[i]));
-
-   return rbFarray;
-}
-
-/*
- * A Ruby interface for gathering process table information.
- */
-void Init_proctable(){
-   VALUE mSys, cProcTable;
-
-   /* Modules and Classes */
-   mSys = rb_define_module("Sys");
-   cProcTable = rb_define_class_under(mSys, "ProcTable", rb_cObject);
-   cProcError = rb_define_class_under(mSys, "ProcTableError", rb_eStandardError);
-   
-   /* Class methods */
-   rb_define_singleton_method(cProcTable, "fields", proctable_fields, 0);
-   rb_define_singleton_method(cProcTable, "ps", proctable_ps, -1);
-
-   /* Constants */
-   rb_define_const(cProcTable, "VERSION", rb_str_new2(SYS_PROCTABLE_VERSION));
-
-   /* Structs */
-   sProcStruct = rb_struct_define("ProcTableStruct","flag",
-#ifdef HAVE_PROCFS_H
-"nlwp",
-#endif
-      "pid","ppid","pgid","sid","uid","euid","gid","egid","priority","nice",
-      "ttydev","time","ctime","size","rss","wchan","pctcpu","pctmem","state",
-      "fname","cmdline","start",
-#ifdef HAVE_PROCFS_H
-"processor",
-#endif
-      "comm","num_args","cmd_args","lwpid","count","tstamp","create","term",
-      "rtime","utime","stime","ttime","tftime","dftime","kftime","ltime",
-      "slptime","wtime","stoptime","minf","majf","nswap","inblk","oublk",
-      "msnd","mrcv","sigs","vctx","ictx","sysc","ioch",NULL
-      ); 
-}
-
-#ifdef __cplusplus
-}
-#endif

data/ext/sunos/sunos.h

@@ -1,177 +0,0 @@
-/*****************************************************************************
- * solaris.h
- *
- * Solaris specific header file.  Some things copy/pasted straight out
- * of Dan Urist's Proc::ProcessTable Perl module.
- *****************************************************************************/
-#include <stdio.h>
-#include <stdlib.h>
-#include <dirent.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/proc.h>
-#include <fcntl.h>
-#include <string.h>
-#include <unistd.h>
-#include <utmpx.h>
-
-/* This bit of magic was taken from a post by Stefan Teleman on the KDE
- * mailing list.  It allows us to build without having to disable largefile
- * support or explicitly build a 64 bit Ruby.
- */
-#if (!defined(_LP64)) && (_FILE_OFFSET_BITS - 0 == 64)
-#define PROCFS_FILE_OFFSET_BITS_HACK 1
-#undef _FILE_OFFSET_BITS
-#else
-#define PROCFS_FILE_OFFSET_BITS_HACK 0
-#endif
-
-#if defined(HAVE_PROCFS_H)
-#include <procfs.h>
-#else
-#include <sys/procfs.h>
-#endif
-
-#if (PROCFS_FILE_OFFSET_BITS_HACK - 0 == 1)
-#define _FILE_OFFSET_BITS 64
-#endif
-
-#ifndef CLK_TCK
-#define CLK_TCK sysconf(_SC_CLK_TCK)
-#endif
-
-#ifndef NAME_MAX
-#define NAME_MAX 255
-#endif
-
-/* Ruby 1.8.3 or later */
-#ifdef HAVE_TYPE_RB_PID_T
-#define pid_t rb_pid_t
-#endif
-
-#define COMM_MAX 64
-#define STATE_MAX 20
-#define WCHAN_MAX 64
-
-/* Function prototypes */
-static void getprusage(pid_t pid, prusage_t* pr_usage);
-
-/* Process state strings that we return */
-#define SLEEP  "sleep"
-#define WAIT   "wait"       
-#define RUN    "run"
-#define IDLE   "idle"
-#define ZOMBIE "zombie"
-#define STOP   "stop"
-#define ONPROC "onprocessor"
-
-/*
- * A simple static structure, mainly for use with the 'fields()' class method.
- * The fields here *should* be identical to the fields listed in the ps_struct.
- * The exception is the 'comm' field, which I added to give it a bit of
- * (foolish?) consistency with the other platforms.  I will try to make sure
- * that field is common to all platforms.
- */
-static char* fields[] = {
-   "flag",
-#ifdef HAVE_PROCFS_H
-   "nlwp",
-#endif
-   "pid",
-   "ppid",
-   "pgid",
-   "sid",
-   "uid",
-   "euid",
-   "gid",
-   "egid",
-   "priority",
-   "nice",
-   "ttydev",
-   "time",
-   "ctime",
-   "size",
-   "rss",
-   "wchan",
-   "pctcpu",
-   "pctmem",
-   "state",
-   "fname",
-   "cmdline",
-   "start",
-#ifdef HAVE_PROCFS_H
-   "processor",
-#endif
-   "comm",
-   "num_args",
-   "cmd_args",
-   "lwpid",
-   "count",
-   "tstamp",
-   "create",
-   "term",
-   "rtime",
-   "utime",
-   "stime",
-   "ttime",
-   "tftime",
-   "dftime",
-   "kftime",
-   "ltime",
-   "slptime",
-   "wtime",
-   "stoptime",
-   "minf",
-   "majf",
-   "nswap",
-   "inblk",
-   "oublk",
-   "msnd",
-   "mrcv",
-   "sigs",
-   "vctx",
-   "ictx",
-   "sysc",
-   "ioch"
-};
-
-/*
- * Private function for getting data out of the /proc/self/usage directory.
- * Based on Rich Teer's function in "Solaris Systems Programming", p.329
- * and p.332. 
- */
-#if defined(HAVE_PROCFS_H)
-static void getprusage(pid_t pid, prusage_t* pr_usage){
-   int fd;
-   char name[PATH_MAX];
-
-   snprintf(name, PATH_MAX, "/proc/%ld/usage", (long)pid);
-
-   if((fd = open(name, O_RDONLY)) == -1)
-      rb_sys_fail(0);
-
-   if(read(fd,pr_usage,sizeof(prusage_t)) == -1){
-      close(fd);
-      rb_sys_fail(0);
-   }
-
-   close(fd);
-}
-#else
-static void getprusage(pid_t pid, prusage_t* pr_usage){
-   int fd;
-   char name[PATH_MAX];
-
-   snprintf(name, PATH_MAX, "/proc/%ld", (long)pid);
-
-   if((fd = open(name, O_RDONLY)) == -1)
-      rb_sys_fail(0);
-
-   if(ioctl(fd,PIOCUSAGE,pr_usage) == -1){
-      close(fd);
-      rb_sys_fail(0);
-   }
-
-   close(fd);
-}
-#endif