static VALUE
fc_path(struct fc_result *fc, ID name)
{
VALUE path, tmp;
path = rb_str_dup(rb_id2str(name));
while (fc) {
if (fc->track == rb_cObject) break;
if ((tmp = rb_attr_get(fc->track, id_classpath)) != Qnil) {
tmp = rb_str_dup(tmp);
rb_str_cat2(tmp, "::");
rb_str_append(tmp, path);
path = tmp;
break;
}
tmp = rb_str_dup(rb_id2str(fc->name));
rb_str_cat2(tmp, "::");
rb_str_append(tmp, path);
path = tmp;
fc = fc->prev;
}
OBJ_FREEZE(path);
return path;
}
/*
* call-seq:
* pl = Xmms::Playlist.new(xc, [name])
*
* Initializes a new Xmms::Playlist using the playlist named _name_ and the
* Xmms::Client instance _xc_. Xmms::Client#playlist(name) is a useful
* shortcut. _name_ is is the name of the playlist and the active playlist will
* be used if it is not specified. Raises PlaylistError if the playlist name is
* invalid.
*/
static VALUE
c_init (int argc, VALUE *argv, VALUE self)
{
RbPlaylist *pl = NULL;
VALUE name, xmms = Qnil;
Data_Get_Struct (self, RbPlaylist, pl);
rb_scan_args (argc, argv, "11", &xmms, &name);
/* FIXME: Check type! */
pl->xmms = xmms;
if (NIL_P (name))
pl->name_value = rb_str_new2 (XMMS_ACTIVE_PLAYLIST);
else
pl->name_value = rb_str_dup (name);
OBJ_FREEZE (pl->name_value);
pl->name = StringValuePtr (pl->name_value);
return self;
}
VALUE
rb_struct_define_without_accessor(const char *class_name, VALUE super, rb_alloc_func_t alloc, ...)
{
VALUE klass;
va_list ar;
VALUE members;
long i;
char *name;
members = rb_ary_new2(0);
va_start(ar, alloc);
i = 0;
while ((name = va_arg(ar, char*)) != NULL) {
rb_ary_push(members, ID2SYM(rb_intern(name)));
}
va_end(ar);
OBJ_FREEZE(members);
if (class_name) {
klass = rb_define_class(class_name, super);
}
else {
klass = rb_class_new(super);
rb_make_metaclass(klass, RBASIC(super)->klass);
rb_class_inherited(super, klass);
}
rb_iv_set(klass, "__members__", members);
if (alloc)
rb_define_alloc_func(klass, alloc);
else
rb_define_alloc_func(klass, struct_alloc);
return klass;
}
VALUE wkhtml_topdf_converter_convert(VALUE self) {
wkhtmltopdf_converter* converter;
//TODO QApplication is initialized on whatever thread `wkhtmltopdf_init` is called, otherwise events are
//not sent properly
if(rb_thread_main() != rb_thread_current()) {
rb_raise(rb_eRuntimeError, "Yuck! You must be on the main thread for wkhtmltopdf to work");
}
//Checks
if(rb_ivar_get(self, idReady) != Qtrue) rb_raise(rb_eRuntimeError, "Object must be added first");
rb_check_frozen(self);
Data_Get_Struct(self, wkhtmltopdf_converter, converter);
if(wkhtmltopdf_convert(converter)) {
OBJ_FREEZE(self);
return Qtrue;
}
else {
return Qfalse;
}
}
/*
* 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 pt_ps(int argc, VALUE* argv, VALUE klass){
int err;
char state[8];
struct kinfo_proc* procs;
VALUE v_pid, v_tty_num, v_tty_dev, v_start_time;
VALUE v_pstruct = Qnil;
VALUE v_array = rb_ary_new();
size_t length, count;
size_t i = 0;
char args[ARGS_MAX_LEN+1];
// Passed into sysctl call
static const int name_mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0};
rb_scan_args(argc, argv, "01", &v_pid);
// Get size of proc kproc buffer
err = sysctl( (int *) name_mib, PROC_MIB_LEN, NULL, &length, NULL, 0);
if(err == -1)
rb_raise(cProcTableError, "sysctl: %s", strerror(errno));
// Populate the kproc buffer
procs = malloc(length);
if(procs == NULL)
rb_raise(cProcTableError, "malloc: %s", strerror(errno));
err = sysctl( (int *) name_mib, PROC_MIB_LEN, procs, &length, NULL, 0);
if(err == -1)
rb_raise(cProcTableError, "sysctl: %s", strerror(errno));
// If we're here, we got our list
count = length / sizeof(struct kinfo_proc);
for(i = 0; i < count; i++) {
v_tty_num = Qnil;
v_tty_dev = Qnil;
v_start_time = Qnil;
// If a PID is provided, skip unless the PID matches
if( (!NIL_P(v_pid)) && (procs[i].kp_proc.p_pid != NUM2INT(v_pid)) )
continue;
*args = '\0';
/* Query the command line args */
/* TODO: Cmd line not working for now - fix */
/*args_mib[ARGS_MIB_LEN - 1] = procs[i].kp_proc.p_pid;
args_err = sysctl( (int *) args_mib, ARGS_MIB_LEN, args, &args_size, NULL, 0);
if(args_err >= 0) {
fprintf(stderr, "Ret: %d LEN: %d\n", err, args_size);
char *c;
for(c = args; c < args+args_size; c++)
if(*c == '\0') *c = ' ';
args[args_size] = '\0';
} else {
fprintf(stderr, "err: %s LEN: %d\n", strerror(errno), args_size);
}*/
char cmdline[ARGS_MAX_LEN+1];
argv_of_pid(procs[i].kp_proc.p_pid, &cmdline);
/* free(cmdline); */
// Get the start time of the process
v_start_time = rb_time_new(
procs[i].kp_proc.p_un.__p_starttime.tv_sec,
procs[i].kp_proc.p_un.__p_starttime.tv_usec
);
// Get the state of the process
switch(procs[i].kp_proc.p_stat)
{
case SIDL:
strcpy(state, "idle");
break;
case SRUN:
strcpy(state, "run");
break;
case SSLEEP:
strcpy(state, "sleep");
break;
case SSTOP:
strcpy(state, "stop");
break;
case SZOMB:
strcpy(state, "zombie");
break;
default:
strcpy(state, "unknown");
break;
}
// Get ttynum and ttydev. If ttynum is -1, there is no tty.
if(procs[i].kp_eproc.e_tdev != -1){
v_tty_num = INT2FIX(procs[i].kp_eproc.e_tdev),
v_tty_dev = rb_str_new2(devname(procs[i].kp_eproc.e_tdev, S_IFCHR));
}
v_pstruct = rb_struct_new(
sProcStruct,
INT2FIX(procs[i].kp_proc.p_pid),
INT2FIX(procs[i].kp_eproc.e_ppid),
INT2FIX(procs[i].kp_eproc.e_pgid),
INT2FIX(procs[i].kp_eproc.e_pcred.p_ruid),
INT2FIX(procs[i].kp_eproc.e_pcred.p_rgid),
rb_str_new2(procs[i].kp_proc.p_comm),
rb_str_new2(state),
rb_float_new(procs[i].kp_proc.p_pctcpu),
Qnil,
v_tty_num,
v_tty_dev,
rb_str_new2(procs[i].kp_eproc.e_wmesg),
INT2FIX(procs[i].kp_proc.p_rtime.tv_sec),
INT2FIX(procs[i].kp_proc.p_priority),
INT2FIX(procs[i].kp_proc.p_usrpri),
INT2FIX(procs[i].kp_proc.p_nice),
rb_str_new2(cmdline),
v_start_time,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_maxrss) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_ixrss) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_idrss) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_isrss) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_minflt) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_majflt) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nswap) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_inblock) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_oublock) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgsnd) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgrcv) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nsignals) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nvcsw) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nivcsw) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_utime.tv_sec) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_stime.tv_sec) : Qnil
);
OBJ_FREEZE(v_pstruct); // This is read-only data
if(rb_block_given_p())
rb_yield(v_pstruct);
else
rb_ary_push(v_array, v_pstruct);
}
if(procs) free(procs);
if(!rb_block_given_p()){
if(NIL_P(v_pid))
return v_array;
else
return v_pstruct;
}
return Qnil;
}
static int
search_required(VALUE fname, volatile VALUE *path, int safe_level)
{
VALUE tmp;
char *ext, *ftptr;
int type, ft = 0;
const char *loading;
*path = 0;
ext = strrchr(ftptr = RSTRING_PTR(fname), '.');
if (ext && !strchr(ext, '/')) {
if (IS_RBEXT(ext)) {
if (rb_feature_p(ftptr, ext, TRUE, FALSE, &loading)) {
if (loading) *path = rb_filesystem_str_new_cstr(loading);
return 'r';
}
if ((tmp = rb_find_file_safe(fname, safe_level)) != 0) {
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
if (!rb_feature_p(ftptr, ext, TRUE, TRUE, &loading) || loading)
*path = tmp;
return 'r';
}
return 0;
}
else if (IS_SOEXT(ext)) {
if (rb_feature_p(ftptr, ext, FALSE, FALSE, &loading)) {
if (loading) *path = rb_filesystem_str_new_cstr(loading);
return 's';
}
tmp = rb_str_subseq(fname, 0, ext - RSTRING_PTR(fname));
#ifdef DLEXT2
OBJ_FREEZE(tmp);
if (rb_find_file_ext_safe(&tmp, loadable_ext + 1, safe_level)) {
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
if (!rb_feature_p(ftptr, ext, FALSE, TRUE, &loading) || loading)
*path = tmp;
return 's';
}
#else
rb_str_cat2(tmp, DLEXT);
OBJ_FREEZE(tmp);
if ((tmp = rb_find_file_safe(tmp, safe_level)) != 0) {
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
if (!rb_feature_p(ftptr, ext, FALSE, TRUE, &loading) || loading)
*path = tmp;
return 's';
}
#endif
}
else if (IS_DLEXT(ext)) {
if (rb_feature_p(ftptr, ext, FALSE, FALSE, &loading)) {
if (loading) *path = rb_filesystem_str_new_cstr(loading);
return 's';
}
if ((tmp = rb_find_file_safe(fname, safe_level)) != 0) {
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
if (!rb_feature_p(ftptr, ext, FALSE, TRUE, &loading) || loading)
*path = tmp;
return 's';
}
}
}
else if ((ft = rb_feature_p(ftptr, 0, FALSE, FALSE, &loading)) == 'r') {
if (loading) *path = rb_filesystem_str_new_cstr(loading);
return 'r';
}
tmp = fname;
type = rb_find_file_ext_safe(&tmp, loadable_ext, safe_level);
switch (type) {
case 0:
if (ft)
goto statically_linked;
ftptr = RSTRING_PTR(tmp);
return rb_feature_p(ftptr, 0, FALSE, TRUE, 0);
default:
if (ft) {
statically_linked:
if (loading) *path = rb_filesystem_str_new_cstr(loading);
return ft;
}
case 1:
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
if (rb_feature_p(ftptr, ext, !--type, TRUE, &loading) && !loading)
break;
*path = tmp;
}
return type ? 's' : 'r';
}
/*
* Private method that converts a psinfo struct into a Ruby struct.
*/
static VALUE proctable_getprocstruct(struct pst_status *p)
{
char state[10];
char flag[12];
char ttydev[MAXPATHLEN+1];
VALUE v_tty, v_struct;
switch( p->pst_stat )
{
case PS_SLEEP:
strcpy(state,SLEEP);
break;
case PS_RUN:
strcpy(state,RUN);
break;
case PS_STOP:
strcpy(state,STOP);
break;
case PS_ZOMBIE:
strcpy(state,ZOMBIE);
break;
case PS_IDLE:
strcpy(state,IDLE);
break;
case PS_OTHER:
strcpy(state,OTHER);
break;
default:
strcpy(state,"unknown");
}
/* If the major number is -1, there is no associated tty */
if(p->pst_term.psd_major != -1) {
devnm(
S_IFCHR,
(dev_t)((p->pst_term.psd_major << 24) | p->pst_term.psd_minor),
ttydev,
sizeof(ttydev),
1
);
v_tty = rb_str_new2(ttydev);
}
else {
v_tty = rb_str_new2("");
}
v_struct = rb_struct_new(sProcStruct,
rb_str_new2(p->pst_ucomm),
INT2NUM(p->pst_uid),
INT2NUM(p->pst_pid),
INT2NUM(p->pst_ppid),
INT2NUM(p->pst_dsize),
INT2NUM(p->pst_tsize),
INT2NUM(p->pst_ssize),
INT2NUM(p->pst_nice),
v_tty,
INT2NUM(p->pst_pgrp),
INT2NUM(p->pst_pri),
INT2NUM(p->pst_addr),
INT2NUM(p->pst_cpu),
INT2NUM(p->pst_utime),
INT2NUM(p->pst_stime),
rb_time_new(p->pst_start,0),
INT2NUM(p->pst_flag),
rb_str_new2(state),
INT2NUM(p->pst_wchan),
INT2NUM(p->pst_procnum),
rb_str_new2(p->pst_cmd),
rb_str_new2(p->pst_cmd),
INT2NUM(p->pst_time),
INT2NUM(p->pst_cpticks),
INT2NUM(p->pst_cptickstotal),
INT2NUM(p->pst_fss),
rb_float_new(p->pst_pctcpu),
INT2NUM(p->pst_rssize),
INT2NUM(p->pst_suid),
INT2NUM(p->pst_shmsize),
INT2NUM(p->pst_mmsize),
INT2NUM(p->pst_usize),
INT2NUM(p->pst_iosize),
INT2NUM(p->pst_vtsize),
INT2NUM(p->pst_vdsize),
INT2NUM(p->pst_vssize),
INT2NUM(p->pst_vshmsize),
INT2NUM(p->pst_vmmsize),
INT2NUM(p->pst_vusize),
INT2NUM(p->pst_viosize),
UINT2NUM(p->pst_minorfaults),
UINT2NUM(p->pst_majorfaults),
UINT2NUM(p->pst_nswap),
UINT2NUM(p->pst_nsignals),
UINT2NUM(p->pst_msgrcv),
UINT2NUM(p->pst_msgsnd),
INT2NUM(p->pst_maxrss),
INT2NUM(p->pst_sid),
INT2NUM(p->pst_schedpolicy),
INT2NUM(p->pst_ticksleft),
INT2NUM(p->pst_euid),
INT2NUM(p->pst_egid),
INT2NUM(p->pst_gid),
INT2NUM(p->pst_sgid)
);
OBJ_FREEZE(v_struct);
return v_struct;
}
/*
* 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 pt_ps(int argc, VALUE* argv, VALUE klass){
int err;
char state[8];
struct kinfo_proc* procs;
VALUE v_pid, v_tty_num, v_tty_dev, v_start_time;
VALUE v_pstruct = Qnil;
VALUE v_array = rb_ary_new();
size_t length, count;
size_t i = 0;
int g;
VALUE v_cmdline, v_exe, v_environ, v_groups;
// Passed into sysctl call
static const int name_mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0};
rb_scan_args(argc, argv, "01", &v_pid);
// Get size of proc kproc buffer
err = sysctl( (int *) name_mib, PROC_MIB_LEN, NULL, &length, NULL, 0);
if(err == -1)
rb_raise(cProcTableError, "sysctl: %s", strerror(errno));
// Populate the kproc buffer
procs = ruby_xmalloc(length);
err = sysctl( (int *) name_mib, PROC_MIB_LEN, procs, &length, NULL, 0);
if(err == -1)
rb_raise(cProcTableError, "sysctl: %s", strerror(errno));
// If we're here, we got our list
count = length / sizeof(struct kinfo_proc);
for(i = 0; i < count; i++) {
v_tty_num = Qnil;
v_tty_dev = Qnil;
v_start_time = Qnil;
// If a PID is provided, skip unless the PID matches
if( (!NIL_P(v_pid)) && (procs[i].kp_proc.p_pid != NUM2INT(v_pid)) )
continue;
// cmdline will be set only if process exists and belongs to current user or
// current user is root
v_cmdline = Qnil;
v_exe = Qnil;
v_environ = Qnil;
argv_of_pid(procs[i].kp_proc.p_pid, &v_cmdline, &v_exe, &v_environ);
// Get the start time of the process
v_start_time = rb_time_new(
procs[i].kp_proc.p_un.__p_starttime.tv_sec,
procs[i].kp_proc.p_un.__p_starttime.tv_usec
);
// Get the state of the process
switch(procs[i].kp_proc.p_stat)
{
case SIDL:
strcpy(state, "idle");
break;
case SRUN:
strcpy(state, "run");
break;
case SSLEEP:
strcpy(state, "sleep");
break;
case SSTOP:
strcpy(state, "stop");
break;
case SZOMB:
strcpy(state, "zombie");
break;
default:
strcpy(state, "unknown");
break;
}
// Get ttynum and ttydev. If ttynum is -1, there is no tty.
if(procs[i].kp_eproc.e_tdev != -1){
v_tty_num = INT2FIX(procs[i].kp_eproc.e_tdev),
v_tty_dev = rb_str_new2(devname(procs[i].kp_eproc.e_tdev, S_IFCHR));
}
v_groups = rb_ary_new();
for (g = 0; g < procs[i].kp_eproc.e_ucred.cr_ngroups; ++g)
rb_ary_push(v_groups, INT2FIX(procs[i].kp_eproc.e_ucred.cr_groups[g]));
v_pstruct = rb_struct_new(
sProcStruct,
INT2FIX(procs[i].kp_proc.p_pid),
INT2FIX(procs[i].kp_eproc.e_ppid),
INT2FIX(procs[i].kp_eproc.e_pgid),
INT2FIX(procs[i].kp_eproc.e_pcred.p_ruid),
INT2FIX(procs[i].kp_eproc.e_pcred.p_rgid),
INT2FIX(procs[i].kp_eproc.e_ucred.cr_uid),
rb_ary_entry(v_groups, 0),
v_groups,
INT2FIX(procs[i].kp_eproc.e_pcred.p_svuid),
INT2FIX(procs[i].kp_eproc.e_pcred.p_svgid),
rb_str_new2(procs[i].kp_proc.p_comm),
rb_str_new2(state),
rb_float_new(procs[i].kp_proc.p_pctcpu),
Qnil,
v_tty_num,
v_tty_dev,
rb_str_new2(procs[i].kp_eproc.e_wmesg),
INT2FIX(procs[i].kp_proc.p_rtime.tv_sec),
INT2FIX(procs[i].kp_proc.p_priority),
INT2FIX(procs[i].kp_proc.p_usrpri),
INT2FIX(procs[i].kp_proc.p_nice),
v_cmdline,
v_exe,
v_environ,
v_start_time,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_maxrss) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_ixrss) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_idrss) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_isrss) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_minflt) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_majflt) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nswap) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_inblock) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_oublock) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgsnd) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgrcv) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nsignals) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nvcsw) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nivcsw) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_utime.tv_sec) : Qnil,
(procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_stime.tv_sec) : Qnil
);
OBJ_FREEZE(v_pstruct); // This is read-only data
if(rb_block_given_p())
rb_yield(v_pstruct);
else
rb_ary_push(v_array, v_pstruct);
}
if(procs)
free(procs);
if(!rb_block_given_p()){
if(NIL_P(v_pid))
return v_array;
else
return v_pstruct;
}
return Qnil;
}
void
Init_Proc(void)
{
/* Proc */
rb_cProc = rb_define_class("Proc", rb_cObject);
rb_undef_alloc_func(rb_cProc);
rb_define_singleton_method(rb_cProc, "new", rb_proc_s_new, -1);
rb_define_method(rb_cProc, "call", proc_call, -1);
rb_define_method(rb_cProc, "[]", proc_call, -1);
rb_define_method(rb_cProc, "===", proc_call, -1);
rb_define_method(rb_cProc, "yield", proc_call, -1);
rb_define_method(rb_cProc, "to_proc", proc_to_proc, 0);
rb_define_method(rb_cProc, "arity", proc_arity, 0);
rb_define_method(rb_cProc, "clone", proc_clone, 0);
rb_define_method(rb_cProc, "dup", proc_dup, 0);
rb_define_method(rb_cProc, "==", proc_eq, 1);
rb_define_method(rb_cProc, "eql?", proc_eq, 1);
rb_define_method(rb_cProc, "hash", proc_hash, 0);
rb_define_method(rb_cProc, "to_s", proc_to_s, 0);
rb_define_method(rb_cProc, "lambda?", proc_lambda_p, 0);
rb_define_method(rb_cProc, "binding", proc_binding, 0);
rb_define_method(rb_cProc, "curry", proc_curry, -1);
rb_define_method(rb_cProc, "source_location", rb_proc_location, 0);
/* Exceptions */
rb_eLocalJumpError = rb_define_class("LocalJumpError", rb_eStandardError);
rb_define_method(rb_eLocalJumpError, "exit_value", localjump_xvalue, 0);
rb_define_method(rb_eLocalJumpError, "reason", localjump_reason, 0);
rb_eSysStackError = rb_define_class("SystemStackError", rb_eException);
sysstack_error = rb_exc_new3(rb_eSysStackError,
rb_obj_freeze(rb_str_new2("stack level too deep")));
OBJ_TAINT(sysstack_error);
OBJ_FREEZE(sysstack_error);
/* utility functions */
rb_define_global_function("proc", rb_block_proc, 0);
rb_define_global_function("lambda", proc_lambda, 0);
/* Method */
rb_cMethod = rb_define_class("Method", rb_cObject);
rb_undef_alloc_func(rb_cMethod);
rb_undef_method(CLASS_OF(rb_cMethod), "new");
rb_define_method(rb_cMethod, "==", method_eq, 1);
rb_define_method(rb_cMethod, "eql?", method_eq, 1);
rb_define_method(rb_cMethod, "hash", method_hash, 0);
rb_define_method(rb_cMethod, "clone", method_clone, 0);
rb_define_method(rb_cMethod, "call", rb_method_call, -1);
rb_define_method(rb_cMethod, "[]", rb_method_call, -1);
rb_define_method(rb_cMethod, "arity", method_arity_m, 0);
rb_define_method(rb_cMethod, "inspect", method_inspect, 0);
rb_define_method(rb_cMethod, "to_s", method_inspect, 0);
rb_define_method(rb_cMethod, "to_proc", method_proc, 0);
rb_define_method(rb_cMethod, "receiver", method_receiver, 0);
rb_define_method(rb_cMethod, "name", method_name, 0);
rb_define_method(rb_cMethod, "owner", method_owner, 0);
rb_define_method(rb_cMethod, "unbind", method_unbind, 0);
rb_define_method(rb_cMethod, "source_location", rb_method_location, 0);
rb_define_method(rb_mKernel, "method", rb_obj_method, 1);
rb_define_method(rb_mKernel, "public_method", rb_obj_public_method, 1);
/* UnboundMethod */
rb_cUnboundMethod = rb_define_class("UnboundMethod", rb_cObject);
rb_undef_alloc_func(rb_cUnboundMethod);
rb_undef_method(CLASS_OF(rb_cUnboundMethod), "new");
rb_define_method(rb_cUnboundMethod, "==", method_eq, 1);
rb_define_method(rb_cUnboundMethod, "eql?", method_eq, 1);
rb_define_method(rb_cUnboundMethod, "hash", method_hash, 0);
rb_define_method(rb_cUnboundMethod, "clone", method_clone, 0);
rb_define_method(rb_cUnboundMethod, "arity", method_arity_m, 0);
rb_define_method(rb_cUnboundMethod, "inspect", method_inspect, 0);
rb_define_method(rb_cUnboundMethod, "to_s", method_inspect, 0);
rb_define_method(rb_cUnboundMethod, "name", method_name, 0);
rb_define_method(rb_cUnboundMethod, "owner", method_owner, 0);
rb_define_method(rb_cUnboundMethod, "bind", umethod_bind, 1);
rb_define_method(rb_cUnboundMethod, "source_location", rb_method_location, 0);
/* Module#*_method */
rb_define_method(rb_cModule, "instance_method", rb_mod_instance_method, 1);
rb_define_method(rb_cModule, "public_instance_method", rb_mod_public_instance_method, 1);
rb_define_private_method(rb_cModule, "define_method", rb_mod_define_method, -1);
/* Kernel */
rb_define_method(rb_mKernel, "define_singleton_method", rb_obj_define_method, -1);
}
/*
Foo = NArray::Struct.new {
int8 :byte
float64 :float, [2,2]
dcomplex :compl
}
*/
static VALUE
nst_s_new(int argc, VALUE *argv, VALUE klass)
{
VALUE name=Qnil, rest, size;
VALUE st, members;
ID id;
rb_scan_args(argc, argv, "0*", &rest);
if (RARRAY_LEN(rest)>0) {
name = RARRAY_PTR(rest)[0];
if (!NIL_P(name)) {
VALUE tmp = rb_check_string_type(name);
if (!NIL_P(tmp)) {
rb_ary_shift(rest);
} else {
name = Qnil;
}
}
}
if (NIL_P(name)) {
st = rb_class_new(klass);
rb_make_metaclass(st, RBASIC(klass)->klass);
rb_class_inherited(klass, st);
}
else {
char *cname = StringValuePtr(name);
id = rb_intern(cname);
if (!rb_is_const_id(id)) {
rb_name_error(id, "identifier %s needs to be constant", cname);
}
if (rb_const_defined_at(klass, id)) {
rb_warn("redefining constant Struct::%s", cname);
rb_mod_remove_const(klass, ID2SYM(id));
}
st = rb_define_class_under(klass, rb_id2name(id), klass);
}
rb_iv_set(st, "__members__", rb_ary_new());
rb_iv_set(st, "__offset__", INT2FIX(0));
if (rb_block_given_p()) {
rb_mod_module_eval(0, 0, st);
}
size = rb_iv_get(st, "__offset__");
members = rb_iv_get(st, "__members__");
//printf("size=%d\n",NUM2INT(size));
rb_define_const(st, CONTIGUOUS_STRIDE, size);
rb_define_const(st, ELEMENT_BYTE_SIZE, size);
rb_define_const(st, ELEMENT_BIT_SIZE, rb_funcall(size,'*',1,INT2FIX(8)));
OBJ_FREEZE(members);
rb_define_const(st, "DEFINITIONS", members);
rb_define_singleton_method(st, "new", rb_class_new_instance, -1);
//rb_define_singleton_method(st, "[]", rb_class_new_instance, -1);
rb_define_method(st, "allocate", nst_allocate, 0);
return st;
}
/*
* 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 pt_ps(int argc, VALUE* argv, VALUE klass){
kvm_t *kd;
char errbuf[_POSIX2_LINE_MAX];
char cmdline[_POSIX_ARG_MAX+1];
char state[8];
char** args = malloc(sizeof(char*));
struct kinfo_proc* procs;
int count; /* Holds total number of processes */
int i = 0;
VALUE v_pid, v_tty_num, v_tty_dev, v_start_time;
VALUE v_pstruct = Qnil;
VALUE v_array = Qnil;
rb_scan_args(argc, argv, "01", &v_pid);
if(!rb_block_given_p())
v_array = rb_ary_new();
// Open the kvm interface, get a descriptor
if ((kd = kvm_open(NULL, NULL, NULL, 0, errbuf)) == NULL)
rb_raise(cProcTableError, errbuf);
// Get the list of processes
if ((procs = kvm_getprocs(kd, KERN_PROC_ALL, 0, &count)) == NULL) {
strcpy(errbuf,kvm_geterr(kd));
kvm_close(kd);
rb_raise(cProcTableError, errbuf);
}
for(i=0; i<count; i++){
// Reset some variables
v_tty_num = Qnil;
v_tty_dev = Qnil;
v_start_time = Qnil;
// If a PID is provided, skip unless the PID matches
if(!NIL_P(v_pid)){
#ifdef HAVE_ST_KP_PROC
if(procs[i].kp_proc.p_pid != NUM2INT(v_pid))
continue;
#else
if(procs[i].ki_pid != NUM2INT(v_pid))
continue;
#endif
}
// Get the command line arguments for the process
cmdline[0] = '\0';
args = kvm_getargv(kd, (const struct kinfo_proc *)&procs[i], 0);
if(args){
int j = 0;
while (args[j] && strlen(cmdline) <= _POSIX_ARG_MAX) {
strcat(cmdline, args[j]);
strcat(cmdline, " ");
j++;
}
}
// Get the start time of the process
v_start_time = rb_time_new(
#ifdef HAVE_ST_E_STATS
procs[i].kp_eproc.e_stats.p_start.tv_sec,
procs[i].kp_eproc.e_stats.p_start.tv_usec
#else
0,0
#endif
);
// Get the state of the process
#ifdef HAVE_ST_KP_PROC
switch(procs[i].kp_proc.p_stat)
#else
switch(procs[i].ki_stat)
#endif
{
case SIDL:
strcpy(state, "idle");
break;
case SRUN:
strcpy(state, "run");
break;
case SSLEEP:
strcpy(state, "sleep");
break;
case SSTOP:
strcpy(state, "stop");
break;
case SZOMB:
strcpy(state, "zombie");
break;
default:
strcpy(state, "unknown");
break;
}
// Get ttynum and ttydev. If ttynum is -1, there is no tty
#ifdef HAVE_ST_KP_EPROC
v_tty_num = INT2FIX(procs[i].kp_eproc.e_tdev),
v_tty_dev = rb_str_new2(devname(procs[i].kp_eproc.e_tdev, S_IFCHR));
#elif HAVE_ST_U_KPROC
v_tty_num = INT2FIX(procs[i].u_kproc.ki_tdev),
v_tty_dev = rb_str_new2(devname(procs[i].u_kproc.ki_tdev, S_IFCHR));
#else
v_tty_num = INT2FIX(procs[i].ki_tdev),
v_tty_dev = rb_str_new2(devname(procs[i].ki_tdev, S_IFCHR));
#endif
#ifdef HAVE_ST_KP_PROC
v_pstruct = rb_struct_new(
sProcStruct,
INT2FIX(procs[i].kp_proc.p_pid),
INT2FIX(procs[i].kp_eproc.e_ppid),
INT2FIX(procs[i].kp_eproc.e_pgid),
INT2FIX(procs[i].kp_eproc.e_pcred.p_ruid),
INT2FIX(procs[i].kp_eproc.e_pcred.p_rgid),
rb_str_new2(procs[i].kp_proc.p_comm),
rb_str_new2(state),
rb_float_new(procs[i].kp_proc.p_pctcpu),
#ifdef HAVE_ST_P_ONCPU
INT2FIX(procs[i].kp_proc.p_oncpu),
#else
Qnil,
#endif
v_tty_num,
v_tty_dev,
rb_str_new2(procs[i].kp_eproc.e_wmesg),
#ifdef HAVE_ST_P_RUNTIME
INT2FIX(procs[i].kp_proc.p_runtime/1000000),
#else
Qnil,
#endif
INT2FIX(procs[i].kp_proc.p_priority),
INT2FIX(procs[i].kp_proc.p_usrpri),
INT2FIX(procs[i].kp_proc.p_nice),
rb_str_new2(cmdline),
v_start_time,
#ifdef HAVE_ST_E_STATS
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_maxrss),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_ixrss),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_idrss),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_isrss),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_minflt),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_majflt),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nswap),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_inblock),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_oublock),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_msgsnd),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_msgrcv),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nsignals),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nvcsw),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_nivcsw),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_utime.tv_sec),
LONG2NUM(procs[i].kp_eproc.e_stats.p_ru.ru_stime.tv_sec)
#else
Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil,
Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil
#endif
);
#else
v_pstruct = rb_struct_new(
sProcStruct,
INT2FIX(procs[i].ki_pid),
INT2FIX(procs[i].ki_ppid),
INT2FIX(procs[i].ki_pgid),
INT2FIX(procs[i].ki_ruid),
INT2FIX(procs[i].ki_rgid),
rb_str_new2(procs[i].ki_ocomm),
rb_str_new2(state),
rb_float_new(procs[i].ki_pctcpu),
INT2FIX(procs[i].ki_oncpu),
v_tty_num,
v_tty_dev,
rb_str_new2(procs[i].ki_wmesg),
INT2FIX(procs[i].ki_runtime/1000000),
INT2FIX(procs[i].ki_pri.pri_level),
INT2FIX(procs[i].ki_pri.pri_user),
INT2FIX(procs[i].ki_nice),
rb_str_new2(cmdline),
v_start_time,
Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil,
Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil
);
#endif
OBJ_FREEZE(v_pstruct); /* Read-only data */
if(rb_block_given_p())
rb_yield(v_pstruct);
else
rb_ary_push(v_array, v_pstruct);
}
free(args);
if(kd)
kvm_close(kd);
if(!NIL_P(v_pid))
return v_pstruct;
return v_array; // Nil if block given
}
/* :call-seq:
* Sys::Host.info
*
* Returns an array of HostInfo structs containing various bits of
* information about the local machine for each entry in the hosts
* table.
*
* The Struct::HostInfo struct contains 5 fields:
*
* * name (String)
* * aliases (Array)
* * addr_type (Integer) => Typically 2 (AF_INET) or 28 (AF_INET6)
* * length (Integer) => Typically 4 (IPv4) or 16 (IPv6)
* * addr_list (Array)
*/
static VALUE host_info(VALUE klass){
char ibuf[INET6_ADDRSTRLEN];
struct hostent* host;
VALUE v_hostinfo, v_aliases, v_addr;
VALUE v_array = rb_ary_new();
sethostent(0);
#ifdef HAVE_GETHOSTENT_R
struct hostent temp;
char sbuf[HOSTENT_BUF];
int err;
#endif
#ifdef HAVE_GETHOSTENT_R
while(!gethostent_r(&temp, sbuf, HOSTENT_BUF, &host, &err)){
#else
while((host = gethostent())){
#endif
char **aliases = host->h_aliases;
char **addrs = host->h_addr_list;
v_aliases = rb_ary_new();
v_addr = rb_ary_new();
while(*aliases){
rb_ary_push(v_aliases, rb_str_new2(*aliases));
*aliases++;
}
while(*addrs){
if(!inet_ntop(host->h_addrtype, addrs, ibuf, sizeof(ibuf)))
rb_raise(cHostError, "inet_ntop() failed: %s", strerror(errno));
rb_ary_push(v_addr, rb_str_new2(ibuf));
*addrs++;
}
v_hostinfo = rb_struct_new(sHostInfo,
rb_str_new2(host->h_name),
v_aliases,
INT2FIX(host->h_addrtype),
INT2FIX(host->h_length),
v_addr
);
OBJ_FREEZE(v_hostinfo);
rb_ary_push(v_array, v_hostinfo);
}
endhostent();
return v_array;
}
#ifdef HAVE_GETHOSTID
/*
* Sys::Host.host_id
*
* Returns the host id of the current machine.
*/
static VALUE host_host_id(){
return ULL2NUM(gethostid());
}
#endif
void Init_host()
{
VALUE sys_mSys, cHost;
/* The Sys module serves as a toplevel namespace, nothing more. */
sys_mSys = rb_define_module("Sys");
/* The Host class encapsulates information about your machine, such as
* the host name and IP address.
*/
cHost = rb_define_class_under(sys_mSys, "Host", rb_cObject);
/* This error is raised if any of the Host methods fail. */
cHostError = rb_define_class_under(cHost, "Error", rb_eStandardError);
/* 0.6.3: The version of this library. This is a string, not a number. */
rb_define_const(cHost, "VERSION", rb_str_new2(SYS_HOST_VERSION));
/* Structs */
sHostInfo = rb_struct_define("HostInfo", "name", "aliases", "addr_type",
"length", "addr_list", NULL
);
/* Class Methods */
rb_define_singleton_method(cHost, "hostname", host_hostname, 0);
rb_define_singleton_method(cHost, "ip_addr", host_ip_addr, 0);
rb_define_singleton_method(cHost, "info", host_info, 0);
#ifdef HAVE_GETHOSTID
rb_define_singleton_method(cHost, "host_id", host_host_id, 0);
#endif
}
