rb-wartslib 0.9.10

data/ext/scext.c

@@ -0,0 +1,52 @@
+/*
+** Ruby bindings to the functions in libscamperfile.a that are needed to
+** sort scamper trace files (a la sc_sorter).
+**
+** --------------------------------------------------------------------------
+** Copyright (C) 2007 The Regents of the University of California.
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+** 
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+** 
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+**
+** $Id: scext.c,v 1.18 2007/11/29 01:51:54 youngh Exp $
+**/
+
+#include "ruby.h"
+
+#if defined(__HAVE_STDINT_H__)
+#include <stdint.h>
+#endif
+
+#include "scamper.h"
+
+#include "scaddr.h"
+#include "sclist.h"
+#include "sctrace.h"
+#include "scfile.h"
+
+VALUE mWarts;
+
+void Init_wartslibext(void)
+{
+  mWarts = rb_define_module("Warts");
+
+  rb_define_const(mWarts, "WARTS_LIB_VERSION", rb_str_new2("0.9.10"));
+  rb_define_const(mWarts, "SCAMPER_VERSION", rb_str_new2(SCAMPER_VERSION));
+
+  Init_scaddr();
+  Init_sclist();
+  Init_sccycle();
+  Init_sctrace();
+  Init_scfile();
+}

data/ext/scfile.c

@@ -0,0 +1,688 @@
+/*
+** Ruby bindings to scamper file operations in scamper_file.c.
+**
+** --------------------------------------------------------------------------
+** Copyright (C) 2007 The Regents of the University of California.
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+** 
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+** 
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+**
+** $Id: scfile.c,v 1.30 2007/11/29 01:42:07 youngh Exp $
+**/
+
+#include <unistd.h>
+#include <string.h>
+#include <strings.h>
+
+#include "ruby.h"
+
+#include "scfile.h"
+#include "scaddr.h"
+
+#if defined(__HAVE_STDINT_H__)
+#include <stdint.h>
+#endif
+
+#include "scamper_list.h"
+#include "scamper_addr.h"
+#include "scamper_trace.h"
+#include "scamper_file.h"
+
+extern VALUE mWarts;
+extern VALUE cTrace;
+extern VALUE cCycle;
+
+static VALUE cFile;
+static ID iv_readable, iv_filters, iv_filters_changed;
+static ID meth_write_to;
+static ID meth_kind_of;
+static ID meth_fileno;
+
+typedef struct {
+  scamper_file_t *file;
+  scamper_file_filter_t *filters;
+} file_data_t;
+
+typedef struct {
+  const char* name;
+  int    value;
+} sctype_info_t;
+
+sctype_info_t all_sctypes[] = {
+  { "LIST",        SCAMPER_FILE_OBJ_LIST },
+  { "CYCLE_START", SCAMPER_FILE_OBJ_CYCLE_START },
+  { "CYCLE_DEF",   SCAMPER_FILE_OBJ_CYCLE_DEF },
+  { "CYCLE_STOP",  SCAMPER_FILE_OBJ_CYCLE_STOP },
+  { "ADDR",        SCAMPER_FILE_OBJ_ADDR },
+  { "TRACE",       SCAMPER_FILE_OBJ_TRACE },
+  { "PING",        SCAMPER_FILE_OBJ_PING }
+};
+
+size_t num_sctypes = sizeof(all_sctypes) / sizeof(sctype_info_t);
+
+#define MIN_SCTYPE_VALUE SCAMPER_FILE_OBJ_LIST
+#define MAX_SCTYPE_VALUE SCAMPER_FILE_OBJ_PING
+
+#define CHECK_WRITABLE(self) \
+  if (RTEST(rb_ivar_get(self, iv_readable))) { \
+    rb_fatal("attempt to write to a file opened for reading"); \
+  }
+
+#define CHECK_READABLE(self) \
+  if (!RTEST(rb_ivar_get(self, iv_readable))) { \
+    rb_fatal("attempt to read from a file opened for writing"); \
+  }
+
+
+/***************************************************************************/
+
+static void sf_free(void *arg)
+{
+  file_data_t *data = (file_data_t *)arg;
+  if (data) {
+    if (data->file) {
+      scamper_file_close(data->file);
+      data->file = NULL;
+    }
+    if (data->filters) {
+      scamper_file_filter_free(data->filters);
+      data->filters = NULL;
+    }
+    free(data);
+  }
+}
+
+static VALUE scfile_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, 0, (RUBY_DATA_FUNC)sf_free, 0);
+}
+
+
+/*
+** Opens either a path or a fd, depending on the type of the first argument.
+** A file descriptor can be given as either a FIXNUM or as an instance of
+** IO.
+**
+** NOTE: It is the responsibility of the caller to (eventually) close any
+**       passed in file descriptor.  See comments below for the reason.
+*/
+static VALUE scfile_init(int argc, VALUE *argv, VALUE self)
+{
+  VALUE path_or_fd, mode, type;
+  VALUE path = Qnil;
+  int fd = -1, fd_dup = -1;
+  char mode_char = 'r';
+  char *type_str = NULL;
+  scamper_file_t *file = NULL;
+  file_data_t *data = NULL;
+
+  rb_scan_args(argc, argv, "12", &path_or_fd, &mode, &type);
+  if (NIL_P(path_or_fd)) {
+    rb_raise(rb_eArgError, "missing path or fd");
+  }
+
+  if (TYPE(path_or_fd) == T_FIXNUM || TYPE(path_or_fd) == T_BIGNUM) {
+    fd = NUM2INT(path_or_fd);
+  }
+  else if (RTEST(rb_funcall(path_or_fd, meth_kind_of, 1, rb_cIO))) {
+    VALUE fileno = rb_funcall(path_or_fd, meth_fileno, 0);
+    fd = FIX2INT(fileno);
+  }
+  else {
+    path = path_or_fd;
+    SafeStringValue(path);
+  }
+
+  if (NIL_P(mode)) {
+    mode_char = 'r';
+  }
+  else {
+    /* Since scamper_file_open() doesn't return any distinguishable error for
+       an invalid mode, we check for validity here. */
+    const char *mode_str;
+
+    StringValue(mode);
+    mode_str = RSTRING(mode)->ptr;
+    if (strlen(mode_str) != 1 || !index("rwa", mode_str[0])) {
+      rb_raise(rb_eArgError, "invalid open mode");
+    }
+    mode_char = mode_str[0];
+  }
+
+  rb_ivar_set(self, iv_readable, (mode_char == 'r' ? Qtrue : Qfalse));
+
+  if (NIL_P(type)) {
+    if (fd >= 0) {
+      type_str = "warts";
+    }
+    else {
+      if (mode_char == 'w' || mode_char == 'a') {
+	type_str = "warts";
+      }
+      /* else let scamper_file_open do file type detection */
+    }
+  }
+  else {
+    StringValue(type);
+    type_str = RSTRING(type)->ptr;
+
+    /* Since scamper_file_open() doesn't return any distinguishable error for
+       an invalid type, we check for validity here. */
+    if (strcmp(type_str, "warts") && strcmp(type_str, "arts")
+	&& strcmp(type_str, "traceroute")) {
+      rb_raise(rb_eArgError, "invalid file type");
+    }
+  }
+
+  if (type_str) {
+    if ((mode_char == 'w' || mode_char == 'a') && strcmp(type_str, "arts")==0){
+      rb_raise(rb_eArgError,"writing or appending to arts files not supported");
+    }
+
+    if (mode_char == 'r' && strcmp(type_str, "traceroute") == 0) {
+      rb_raise(rb_eArgError, "reading from traceroute files not supported");
+    }
+  }
+
+  data = ALLOC(file_data_t);
+  data->file = NULL;
+  data->filters = NULL;
+  DATA_PTR(self) = data;
+
+  /*
+  ** NOTE: We must be careful when calling scamper_file_openfd().  We
+  **       should NOT simply pass in the file descriptor supplied to
+  **       scfile_init because the policy of scamper_file_openfd is to
+  **       take ownership of the passed-in file descriptor.  This means
+  **       that, eventually, scamper_file_close closes the file
+  **       descriptor.  Normally, this "takes-ownership-of-argument"
+  **       policy is what you want, but when interfacing the scamper warts
+  **       library to Ruby, this policy can cause problems.
+  **
+  **       An open file in Ruby is more than simply a file
+  **       descriptor--there's an allocated object associated with the
+  **       file descriptor.  Hence, we need to free the object in addition
+  **       to closing the file descriptor when closing an open file in
+  **       Ruby.  So it causes problems when scamper_file_close does half
+  **       of this work (by closing the file descriptor) without getting
+  **       the Ruby object involved.  This results in close() being called
+  **       twice on the file descriptor.  The first time, the call closes
+  **       the actual file; the second time, it closes any unreleated open
+  **       file that happens to be re-using the same file descriptor
+  **       number (which can be particularly insidious if the extra
+  **       close() is delayed till the next garbage collection).
+  **
+  **       When piping in the output of 'gzip -dc' (in order to
+  **       transparently read a compressed warts file), simply closing the
+  **       file descriptor isn't sufficient to free up the resource.  At
+  **       some point after closing the file descriptor, we have to call
+  **       waitpid().  Thus, in this case, the takes-ownership policy of
+  **       scamper_file_openfd is problematic--the Ruby object needs to
+  **       do the resource deallocation itself.
+  **
+  **       Fortunately, there's an easy solution to the mismatch.  We
+  **       simply dup the file descriptor and pass the dup to
+  **       scamper_file_openfd (and let it take ownership and do what it
+  **       will of it).
+  */
+  if (NIL_P(path)) {
+    if ((fd_dup = dup(fd)) < 0) {
+      rb_raise(rb_eRuntimeError, "couldn't duplicate file descriptor");
+    }
+    file = scamper_file_openfd(fd_dup, NULL, mode_char, type_str);
+  }
+  else {
+    file = scamper_file_open(RSTRING(path)->ptr, mode_char, type_str);
+  }
+
+  if (file) {
+    data->file = file;
+    return self;
+  }
+  else {
+    if (fd_dup >= 0) {
+      close(fd_dup);
+    }
+    return Qnil;
+  }
+}
+
+
+static VALUE scfile_type(VALUE self)
+{
+  file_data_t *data = NULL;
+
+  Data_Get_Struct(self, file_data_t, data);
+  if (data->file) {
+    char buf [128];
+    return rb_str_new2(scamper_file_type_tostr(data->file, buf, 128));
+  }
+  return Qnil;
+}
+
+
+static VALUE scfile_path(VALUE self)
+{
+  file_data_t *data = NULL;
+
+  Data_Get_Struct(self, file_data_t, data);
+  if (data->file) {
+    return rb_str_new2(scamper_file_getfilename(data->file));
+  }
+  return Qnil;
+}
+
+
+static VALUE scfile_close(VALUE self)
+{
+  file_data_t *data = NULL;
+
+  Data_Get_Struct(self, file_data_t, data);
+
+  if (data->file) {
+    scamper_file_close(data->file);
+    data->file = NULL;
+  }
+
+  return self;
+}
+
+
+static VALUE scfile_closed(VALUE self)
+{
+  file_data_t *data = NULL;
+
+  Data_Get_Struct(self, file_data_t, data);
+
+  return (data->file ? Qfalse : Qtrue);
+}
+
+
+static VALUE scfile_s_open(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE obj = Data_Wrap_Struct(klass, 0, sf_free, 0);
+
+  if (NIL_P(scfile_init(argc, argv, obj))) {
+    return Qnil;
+  }
+
+  return (rb_block_given_p() ? rb_ensure(rb_yield, obj, scfile_close, obj)
+	  : obj);
+}
+
+
+static void update_filters(VALUE self)
+{
+  file_data_t *data = NULL;
+  VALUE filters;
+  int i;
+
+  if (RTEST(rb_ivar_get(self, iv_filters_changed))) {
+    uint16_t filter_values[MAX_SCTYPE_VALUE];
+    uint16_t num_values = 0;
+
+    rb_ivar_set(self, iv_filters_changed, Qnil);
+
+    Data_Get_Struct(self, file_data_t, data);
+    if (data->filters) {
+      scamper_file_filter_free(data->filters);
+      data->filters = NULL;
+    }
+
+    filters = rb_ivar_get(self, iv_filters);
+    if (!NIL_P(filters) && RARRAY(filters)->len > 0) {
+      for (i = 0; i < RARRAY(filters)->len; i++) {
+	if (RTEST(rb_ary_entry(filters, i))) {
+	  filter_values[num_values++] = i;
+	}
+      }
+
+      if (num_values > 0) {
+	data->filters = scamper_file_filter_alloc(filter_values, num_values);
+      }
+    }
+  }
+}
+
+
+#define RETURN(value) \
+  if (rb_block_given_p()) { \
+    rb_yield(value); \
+    goto loop;     \
+  } else return (value)
+
+static VALUE scfile_read(VALUE self)
+{
+  file_data_t *data = NULL;
+  uint16_t obj_type = 0;
+  void *obj_data = NULL;
+  VALUE obj;
+  int result;
+
+  Data_Get_Struct(self, file_data_t, data);
+  if (!data->file) {
+    return Qnil;
+  }
+  CHECK_READABLE(self)
+
+  update_filters(self);
+
+ loop:
+  result = scamper_file_read(data->file, data->filters, &obj_type, &obj_data);
+  if (result == -1) {
+    rb_raise(rb_eIOError, "couldn't read warts file data");
+  }
+  if (!obj_data) {
+    return Qnil;  /* EOF */
+  }
+
+  switch (obj_type) {
+  case SCAMPER_FILE_OBJ_LIST:
+    RETURN(sclist_create((scamper_list_t *)obj_data));
+
+  case SCAMPER_FILE_OBJ_CYCLE_START:
+  case SCAMPER_FILE_OBJ_CYCLE_DEF:
+  case SCAMPER_FILE_OBJ_CYCLE_STOP:
+    RETURN(sccycle_create((scamper_cycle_t *)obj_data, obj_type));
+
+  case SCAMPER_FILE_OBJ_ADDR:
+    RETURN(scaddr_create((scamper_addr_t *)obj_data));
+
+  case SCAMPER_FILE_OBJ_TRACE:
+    RETURN(sctrace_create((scamper_trace_t *)obj_data));
+
+  default:
+    rb_notimplement();
+  }
+}
+
+#undef RETURN
+
+
+/*
+** This method initiates multiple dispatch with obj.  Obj.write_to(file)
+** should turn around and invoke a suitable write_xxx method; e.g., a trace
+** object should call file.write_trace(self), and a ping object should call
+** file.write_ping(self).
+*/
+static VALUE scfile_write(VALUE self, VALUE obj)
+{
+  rb_funcall(obj, meth_write_to, 1, self);
+}
+
+
+/*
+** There's a bug in scamper_file_warts.c:warts_list_write
+** (scamper-cvs-20070523e & f):
+**
+** $ split-traces-by-type trmethod-20071106-list.one24.100000.warts
+** scamper_file_warts.c:1523: failed assertion `off == len'
+** Abort trap
+**
+** This bug is triggered when a list object is missing BOTH
+** a description and a monitor name.  As a workaround, we set the
+** description and monitor name to empty strings if they aren't
+** already set.
+*/
+static void warts_list_write_bug_workaround(scamper_list_t *list)
+{
+  if (!list) return;
+  if (!list->descr) list->descr = strdup("");
+  if (!list->monitor) list->monitor = strdup("");
+}
+
+
+static VALUE scfile_write_trace(VALUE self, VALUE obj)
+{
+  file_data_t *data = NULL;
+  scamper_trace_t *trace = NULL;
+  int result;
+
+  if (TYPE(obj) != T_DATA || !RTEST(rb_obj_is_instance_of(obj, cTrace))) {
+    rb_raise(rb_eArgError, "argument must be instance of Warts::Trace");
+  }
+
+  Data_Get_Struct(self, file_data_t, data);
+  if (!data->file) {
+    return Qnil;
+  }
+  CHECK_WRITABLE(self)
+
+  Data_Get_Struct(obj, scamper_trace_t, trace);
+  warts_list_write_bug_workaround(trace->list);
+  if (trace->cycle) {
+    warts_list_write_bug_workaround(trace->cycle->list);
+  }
+
+  result = scamper_file_write_trace(data->file, trace);
+  if (result == -1) {
+    rb_raise(rb_eIOError, "couldn't write warts file data");
+  }
+  return self;
+}
+
+
+/*
+** NOTE: We could have gone with a single scfile_write_cycle() function
+**       that determines what scamper function to call based on the type
+**       of the cycle object.  However, such a design might prove
+**       inconvenient for the user since cycle objects are immutable
+**       in this extension.  If there were only a single function, then
+**       users would have to be careful to hang onto the START/STOP
+**       cycle objects when sorting traces into files.
+*/
+static VALUE scfile_write_cycle_start(VALUE self, VALUE obj)
+{
+  file_data_t *data = NULL;
+  scamper_cycle_t *cycle = NULL;
+  int result;
+
+  if (TYPE(obj) != T_DATA || !RTEST(rb_obj_is_instance_of(obj, cCycle))) {
+    rb_raise(rb_eArgError, "argument must be instance of Warts::Cycle");
+  }
+
+  Data_Get_Struct(self, file_data_t, data);
+  if (!data->file) {
+    return Qnil;
+  }
+  CHECK_WRITABLE(self)
+
+  Data_Get_Struct(obj, scamper_cycle_t, cycle);
+  warts_list_write_bug_workaround(cycle->list);
+
+  result = scamper_file_write_cycle_start(data->file, cycle);
+  if (result == -1) {
+    rb_raise(rb_eIOError, "couldn't write warts file data");
+  }
+  return self;
+}
+
+
+static VALUE scfile_write_cycle_stop(VALUE self, VALUE obj)
+{
+  file_data_t *data = NULL;
+  scamper_cycle_t *cycle = NULL;
+  int result;
+
+  if (TYPE(obj) != T_DATA || !RTEST(rb_obj_is_instance_of(obj, cCycle))) {
+    rb_raise(rb_eArgError, "argument must be instance of Warts::Cycle");
+  }
+
+  Data_Get_Struct(self, file_data_t, data);
+  if (!data->file) {
+    return Qnil;
+  }
+  CHECK_WRITABLE(self)
+
+  Data_Get_Struct(obj, scamper_cycle_t, cycle);
+  warts_list_write_bug_workaround(cycle->list);
+
+  result = scamper_file_write_cycle_stop(data->file, cycle);
+  if (result == -1) {
+    rb_raise(rb_eIOError, "couldn't write warts file data");
+  }
+  return self;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static VALUE get_iv_filters(VALUE self)
+{
+  VALUE filters = rb_ivar_get(self, iv_filters);
+  if (NIL_P(filters)) {
+    filters = rb_ary_new();
+    rb_ivar_set(self, iv_filters, filters);
+  }
+  return filters;
+}
+
+
+/* NOTE: This is a helper function: don't directly invoke as a Ruby method. */
+static VALUE scfile_set_filters(int argc, VALUE *argv, VALUE self, VALUE value)
+{
+  VALUE filters, given_filters, filter;
+  int i, filter_value;
+
+  filters = get_iv_filters(self);
+
+  rb_scan_args(argc, argv, "*", &given_filters);
+  for (i = 0; i < RARRAY(given_filters)->len; i++) {
+    filter = rb_ary_entry(given_filters, i);
+    if (RTEST(filter)) {
+      filter_value = NUM2INT(filter);
+      if (filter_value < MIN_SCTYPE_VALUE || filter_value > MAX_SCTYPE_VALUE) {
+	rb_raise(rb_eArgError, "invalid filter value %d", filter_value);
+      }
+
+      rb_ary_store(filters, filter_value, value);
+    }
+  }
+
+  rb_ivar_set(self, iv_filters_changed, Qtrue);
+  return self;
+}
+
+
+static VALUE scfile_add_all_filters(VALUE self)
+{
+  VALUE filters;
+  int i;
+
+  filters = get_iv_filters(self);
+
+  for (i = 0; i < num_sctypes; i++) {
+    rb_ary_store(filters, all_sctypes[i].value, Qtrue);
+  }
+
+  rb_ivar_set(self, iv_filters_changed, Qtrue);
+  return self;
+}
+
+
+static VALUE scfile_add_filters(int argc, VALUE *argv, VALUE self)
+{
+  return scfile_set_filters(argc, argv, self, Qtrue);
+}
+
+
+static VALUE scfile_clear_all_filters(VALUE self)
+{
+  rb_ivar_set(self, iv_filters, Qnil);
+  rb_ivar_set(self, iv_filters_changed, Qtrue);
+  return self;
+}
+
+
+static VALUE scfile_clear_filters(int argc, VALUE *argv, VALUE self)
+{
+  return scfile_set_filters(argc, argv, self, Qnil);
+}
+
+
+static VALUE scfile_get_filters(VALUE self)
+{
+  VALUE retval, filters;
+  int i;
+
+  retval = rb_ary_new();
+
+  filters = rb_ivar_get(self, iv_filters);
+  if (!NIL_P(filters)) {
+    for (i = 0; i < RARRAY(filters)->len; i++) {
+      if (RTEST(rb_ary_entry(filters, i))) {
+	rb_ary_push(retval, INT2FIX(i));
+      }
+    }
+  }
+  return retval;
+}
+
+
+/***************************************************************************/
+/***************************************************************************/
+
+void Init_scfile(void)
+{
+  ID private_ID, dup_ID, clone_ID;
+  int i;
+
+  iv_readable = rb_intern("@readable");
+  iv_filters = rb_intern("@filters");
+  iv_filters_changed = rb_intern("@filters_changed");
+  meth_write_to = rb_intern("write_to");
+  meth_kind_of = rb_intern("kind_of?");
+  meth_fileno = rb_intern("fileno");
+
+  cFile = rb_define_class_under(mWarts, "File", rb_cObject);
+
+  for (i = 0; i < num_sctypes; i++) {
+    rb_define_const(cFile, all_sctypes[i].name,
+		    INT2FIX(all_sctypes[i].value));
+  }
+
+  rb_define_const(cFile, "TRACEROUTE", rb_str_new2("traceroute"));
+  rb_define_const(cFile, "ARTS", rb_str_new2("arts"));
+  rb_define_const(cFile, "WARTS", rb_str_new2("warts"));
+
+  rb_define_singleton_method(cFile, "open", scfile_s_open, -1);
+
+  rb_define_alloc_func(cFile, scfile_alloc);
+
+  rb_define_method(cFile, "initialize", scfile_init, -1);
+  rb_define_method(cFile, "type", scfile_type, 0);
+  rb_define_method(cFile, "path", scfile_path, 0);
+  rb_define_method(cFile, "close", scfile_close, 0);
+  rb_define_method(cFile, "closed?", scfile_closed, 0);
+  rb_define_method(cFile, "read", scfile_read, 0);
+  rb_define_method(cFile, "write", scfile_write, 1);
+  rb_define_method(cFile, "write_trace", scfile_write_trace, 1);
+  rb_define_method(cFile, "write_cycle_start", scfile_write_cycle_start, 1);
+  rb_define_method(cFile, "write_cycle_stop", scfile_write_cycle_stop, 1);
+
+  rb_define_alias(cFile, "each", "read");
+
+  rb_define_method(cFile, "add_all_filters", scfile_add_all_filters, 0);
+  rb_define_method(cFile, "add_filters", scfile_add_filters, -1);
+  rb_define_method(cFile, "clear_all_filters", scfile_clear_all_filters, 0);
+  rb_define_method(cFile, "clear_filters", scfile_clear_filters, -1);
+  rb_define_method(cFile, "filters", scfile_get_filters, 0);
+
+  private_ID = rb_intern("private");
+  dup_ID = rb_intern("dup");
+  clone_ID = rb_intern("clone");
+
+  rb_funcall(cFile, private_ID, 1, ID2SYM(dup_ID));
+  rb_funcall(cFile, private_ID, 1, ID2SYM(clone_ID));
+}