sys-proctable 0.7.6-i586-linux

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(boot_time() + (p->starttime / CLK_TCK)),
+      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,158 @@
+/************************************************************************
+ * 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
+#define BTIME_BUF 1024
+
+/**************************************************************************** 
+ * 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;
+}
+
+/* Helper function to get the boot time */
+unsigned long boot_time(){
+   FILE* fp;
+   char buf[BTIME_BUF];
+   unsigned long btime = 0;
+
+   if((fp = fopen( "/proc/stat", "r" )) != NULL){
+      while(!feof(fp)){
+         if(fscanf(fp,"btime %ld", &btime) == 1)
+            break;
+            if(fgets(buf, BTIME_BUF, fp) == NULL)
+               break;
+      }
+      fclose(fp);
+   }
+
+   return btime;
+}