pauldix-typhoeus 0.0.8

data/ext/typhoeus/Makefile

@@ -0,0 +1,157 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/local/lib/ruby/1.8/i686-darwin9.6.0
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+exec_prefix = $(prefix)
+prefix = $(DESTDIR)/usr/local
+sharedstatedir = $(prefix)/com
+mandir = $(datarootdir)/man
+psdir = $(docdir)
+oldincludedir = $(DESTDIR)/usr/include
+localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(exec_prefix)/libexec
+sitedir = $(libdir)/ruby/site_ruby
+htmldir = $(docdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+includedir = $(prefix)/include
+infodir = $(datarootdir)/info
+vendorlibdir = $(vendordir)/$(ruby_version)
+sysconfdir = $(prefix)/etc
+libdir = $(exec_prefix)/lib
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(libdir)/ruby/vendor_ruby
+datarootdir = $(prefix)/share
+pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
+sitearchdir = $(sitelibdir)/$(sitearch)
+datadir = $(datarootdir)
+localstatedir = $(prefix)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_A)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = 
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fno-common -g -O2 -pipe -fno-common $(cflags)  -g -DXP_UNIX -O3 -Wall -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline 
+INCFLAGS = -I. -I. -I/usr/local/lib/ruby/1.8/i686-darwin9.6.0 -I.
+DEFS     = 
+CPPFLAGS =   -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE  
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L. 
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = i686-darwin9.6.0
+sitearch = i686-darwin9.6.0
+ruby_version = 1.8
+ruby = /usr/local/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir) /opt/local/lib
+LIBPATH =  -L. -L$(libdir) -L/opt/local/lib
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = /typhoeus
+LOCAL_LIBS = 
+LIBS =  -lcurl  -ldl -lobjc  
+SRCS = native.c typhoeus_easy.c typhoeus_multi.c
+OBJS = native.o typhoeus_easy.o typhoeus_multi.o
+TARGET = native
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/typhoeus/extconf.rb

@@ -0,0 +1,57 @@
+ENV["ARCHFLAGS"] = "-arch #{`uname -p` =~ /powerpc/ ? 'ppc' : 'i386'}"
+
+require 'mkmf'
+
+ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+LIBDIR = Config::CONFIG['libdir']
+INCLUDEDIR = Config::CONFIG['includedir']
+
+  use_macports = !(defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby')
+
+$CFLAGS << " #{ENV["CFLAGS"]}"
+if Config::CONFIG['target_os'] == 'mingw32'
+  $CFLAGS << " -DXP_WIN -DXP_WIN32"
+else
+  $CFLAGS << " -g -DXP_UNIX"
+end
+
+$LIBPATH << "/opt/local/lib" if use_macports
+
+$CFLAGS << " -O3 -Wall -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline"
+
+if Config::CONFIG['target_os'] == 'mingw32'
+  header = File.join(ROOT, 'cross', 'curl-7.19.4.win32', 'include')
+  unless find_header('curl/curl.h', header)
+    abort "need libcurl"
+  end
+else
+  HEADER_DIRS = [
+    File.join(INCLUDEDIR, "curl"),
+    INCLUDEDIR,
+    '/usr/include/curl',
+    '/usr/local/include/curl'
+  ]
+
+  [
+    '/opt/local/include/curl',
+    '/opt/local/include',
+  ].each { |x| HEADER_DIRS.unshift(x) } if use_macports
+
+  unless find_header('curl/curl.h', *HEADER_DIRS)
+    abort "need libcurl"
+  end
+end
+
+if Config::CONFIG['target_os'] == 'mingw32'
+  find_library('curl', 'curl_easy_init',
+               File.join(ROOT, 'cross', 'curl-7.19.4.win32', 'bin'))
+else
+  find_library('curl', 'curl_easy_init',
+               LIBDIR,
+               '/opt/local/lib',
+               '/usr/local/lib',
+               '/usr/lib'
+    )
+end
+
+create_makefile("typhoeus/native")

data/ext/typhoeus/native.c

@@ -0,0 +1,11 @@
+#include <native.h>
+
+VALUE mTyphoeus;
+
+void Init_native()
+{
+	mTyphoeus = rb_const_get(rb_cObject, rb_intern("Typhoeus"));
+	
+	init_typhoeus_easy();
+	init_typhoeus_multi();
+}

data/ext/typhoeus/native.h

@@ -0,0 +1,11 @@
+#ifndef TYPHOEUS_NATIVE
+#define TYPHOEUS_NATIVE
+
+#include <ruby.h>
+#include <curl/curl.h>
+#include <curl/easy.h>
+#include <curl/multi.h>
+
+extern VALUE mTyphoeus;
+
+#endif

data/ext/typhoeus/typhoeus_easy.c

@@ -0,0 +1,206 @@
+#include <typhoeus_easy.h>
+	
+static VALUE idAppend;
+VALUE cTyphoeusEasy;
+
+static void dealloc(CurlEasy *curl_easy) {
+	if (curl_easy->request_chunk != NULL) {
+		free(curl_easy->request_chunk);
+	}
+	
+	if (curl_easy->headers != NULL) {
+		curl_slist_free_all(curl_easy->headers);
+	}
+	
+	curl_easy_cleanup(curl_easy->curl);
+	
+	free(curl_easy);
+}
+
+static VALUE easy_setopt_string(VALUE self, VALUE opt_name, VALUE parameter) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(opt_name);
+	curl_easy_setopt(curl_easy->curl, opt, StringValuePtr(parameter));
+	return opt_name;
+}
+
+static VALUE easy_setopt_long(VALUE self, VALUE opt_name, VALUE parameter) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(opt_name);
+	curl_easy_setopt(curl_easy->curl, opt, NUM2LONG(parameter));
+	return opt_name;	
+}
+
+static VALUE easy_getinfo_string(VALUE self, VALUE info) {
+	char *info_string;
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(info);
+	curl_easy_getinfo(curl_easy->curl, opt, &info_string);
+	
+	return rb_str_new2(info_string);
+}
+
+static VALUE easy_getinfo_long(VALUE self, VALUE info) {
+	long info_long;
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(info);
+	curl_easy_getinfo(curl_easy->curl, opt, &info_long);
+	
+	return LONG2NUM(info_long);
+}
+
+static VALUE easy_getinfo_double(VALUE self, VALUE info) {
+	double info_double = 0;
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	long opt = NUM2LONG(info);
+	curl_easy_getinfo(curl_easy->curl, opt, &info_double);
+
+	return rb_float_new(info_double);
+}
+
+static VALUE easy_perform(VALUE self) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+	curl_easy_perform(curl_easy->curl);
+
+	return Qnil;
+}
+
+static size_t write_data_handler(char *stream, size_t size, size_t nmemb, VALUE val) {
+	rb_funcall(val, idAppend, 1, rb_str_new(stream, size * nmemb));
+	return size * nmemb;
+}
+
+static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *data) {
+	int realsize = size * nmemb;
+	RequestChunk *mem = (RequestChunk *)data;
+
+	if (realsize > mem->size - mem->read) {
+		realsize = mem->size - mem->read;
+	}
+	
+	if (realsize != 0) {
+		memcpy(ptr, &(mem->memory[mem->read]), realsize);
+		mem->read += realsize;
+	}
+	
+	return realsize; 
+}
+
+static void set_response_handlers(VALUE easy, CURL *curl) {
+	rb_iv_set(easy, "@response_body", rb_str_new2(""));
+	rb_iv_set(easy, "@response_header", rb_str_new2(""));
+	
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&write_data_handler);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, rb_iv_get(easy, "@response_body"));	
+  curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&write_data_handler);
+  curl_easy_setopt(curl, CURLOPT_HEADERDATA, rb_iv_get(easy, "@response_header"));
+	
+	return NULL;
+}
+
+static VALUE easy_reset(VALUE self) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	curl_easy_reset(curl_easy->curl);
+
+	if (curl_easy->request_chunk != NULL) {
+		free(curl_easy->request_chunk);
+	}
+	
+	if (curl_easy->headers != NULL) {
+		curl_slist_free_all(curl_easy->headers);
+	}
+
+	set_response_handlers(self, curl_easy->curl);
+
+	return Qnil;	
+}
+
+static VALUE easy_add_header(VALUE self, VALUE header) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	curl_easy->headers = curl_slist_append(curl_easy->headers, StringValuePtr(header));
+	return header;
+}
+
+static VALUE easy_set_headers(VALUE self) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	curl_easy_setopt(curl_easy->curl, CURLOPT_HTTPHEADER, curl_easy->headers);
+	
+	return Qnil;
+}
+
+static VALUE easy_set_request_body(VALUE self, VALUE data, VALUE content_length_header) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	curl_easy->request_chunk = ALLOC(RequestChunk);
+	curl_easy->request_chunk->size = RSTRING_LEN(data);
+	curl_easy->request_chunk->memory = StringValuePtr(data);
+	curl_easy->request_chunk->read = 0;
+
+  curl_easy_setopt(curl_easy->curl, CURLOPT_READFUNCTION, (curl_read_callback)read_callback);
+  curl_easy_setopt(curl_easy->curl, CURLOPT_READDATA, curl_easy->request_chunk);
+	curl_easy_setopt(curl_easy->curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
+
+	return Qnil;
+}
+
+static VALUE easy_escape(VALUE self, VALUE data, VALUE length) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(self, CurlEasy, curl_easy);
+
+	return rb_str_new2(curl_easy_escape(curl_easy->curl, StringValuePtr(data), NUM2INT(length)));
+}
+
+static VALUE version(VALUE self) {
+	return rb_str_new2(curl_version());
+}
+
+static VALUE new(int argc, VALUE *argv, VALUE klass) {
+	CURL *curl = curl_easy_init();
+	CurlEasy *curl_easy = ALLOC(CurlEasy);
+	curl_easy->curl = curl;
+	curl_easy->headers = NULL;
+	curl_easy->request_chunk = NULL;
+	VALUE easy = Data_Wrap_Struct(cTyphoeusEasy, 0, dealloc, curl_easy);
+
+	set_response_handlers(easy, curl);
+
+	rb_obj_call_init(easy, argc, argv);
+
+	return easy;
+}
+
+void init_typhoeus_easy() {
+	VALUE klass = cTyphoeusEasy = rb_define_class_under(mTyphoeus, "Easy", rb_cObject);
+	idAppend = rb_intern("<<");
+	rb_define_singleton_method(klass, "new", new, -1);
+	rb_define_private_method(klass, "easy_setopt_string", easy_setopt_string, 2);
+	rb_define_private_method(klass, "easy_setopt_long", easy_setopt_long, 2);
+	rb_define_private_method(klass, "easy_getinfo_string", easy_getinfo_string, 1);
+	rb_define_private_method(klass, "easy_getinfo_long", easy_getinfo_long, 1);
+	rb_define_private_method(klass, "easy_getinfo_double", easy_getinfo_double, 1);
+	rb_define_private_method(klass, "easy_perform", easy_perform, 0);
+	rb_define_private_method(klass, "easy_reset", easy_reset, 0);
+	rb_define_private_method(klass, "easy_set_request_body", easy_set_request_body, 1);
+	rb_define_private_method(klass, "easy_set_headers", easy_set_headers, 0);
+	rb_define_private_method(klass, "easy_add_header", easy_add_header, 1);
+	rb_define_private_method(klass, "easy_escape", easy_escape, 2);
+	rb_define_private_method(klass, "version", version, 0);
+}

data/ext/typhoeus/typhoeus_easy.h

@@ -0,0 +1,19 @@
+#ifndef TYPHOEUS_EASY
+#define TYPHOEUS_EASY
+
+#include <native.h>
+
+void init_typhoeus_easy();
+typedef struct {
+	const char *memory;
+	int size;
+	int read;
+} RequestChunk;
+
+typedef struct {
+	RequestChunk *request_chunk;
+	CURL *curl;
+	struct curl_slist *headers;
+} CurlEasy;
+
+#endif

data/ext/typhoeus/typhoeus_multi.c

@@ -0,0 +1,213 @@
+#include <typhoeus_multi.h>
+
+static void multi_read_info(VALUE self, CURLM *multi_handle);
+
+static void dealloc(CurlMulti *curl_multi) {
+	curl_multi_cleanup(curl_multi->multi);
+	free(curl_multi);
+}
+
+static VALUE multi_add_handle(VALUE self, VALUE easy) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(easy, CurlEasy, curl_easy);
+	CurlMulti *curl_multi;
+	Data_Get_Struct(self, CurlMulti, curl_multi);
+  CURLMcode mcode;
+
+  mcode = curl_multi_add_handle(curl_multi->multi, curl_easy->curl);
+  if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
+    rb_raise(mcode, "An error occured adding the handle");
+  }
+
+	curl_easy_setopt(curl_easy->curl, CURLOPT_PRIVATE, easy);
+  curl_multi->active++;
+
+  if (mcode == CURLM_CALL_MULTI_PERFORM) {
+    curl_multi_perform(curl_multi->multi, &(curl_multi->running));
+  }
+  // 
+  // if (curl_multi->running) {
+  // 		printf("call read_info on add<br/>");
+  //   multi_read_info(self, curl_multi->multi);
+  // }
+	
+	return easy;	
+}
+
+static VALUE multi_remove_handle(VALUE self, VALUE easy) {
+	CurlEasy *curl_easy;
+	Data_Get_Struct(easy, CurlEasy, curl_easy);
+	CurlMulti *curl_multi;
+	Data_Get_Struct(self, CurlMulti, curl_multi);
+	
+	curl_multi->active--;
+	curl_multi_remove_handle(curl_multi->multi, curl_easy->curl);
+	
+	return easy;
+}
+
+static void multi_read_info(VALUE self, CURLM *multi_handle) {
+  int msgs_left, result;
+  CURLMsg *msg;
+  CURLcode ecode;
+  CURL *easy_handle;
+	VALUE easy;
+
+  /* check for finished easy handles and remove from the multi handle */
+  while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
+
+    if (msg->msg != CURLMSG_DONE) {
+      continue;
+    }
+
+    easy_handle = msg->easy_handle;
+    result = msg->data.result;
+    if (easy_handle) {
+      ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, &easy);
+      if (ecode != 0) {
+        rb_raise(ecode, "error getting easy object");
+      }
+
+      long response_code = -1;
+      curl_easy_getinfo(easy_handle, CURLINFO_RESPONSE_CODE, &response_code);
+ 
+			// TODO: find out what the real problem is here and fix it.
+			// this next bit is a horrible hack. For some reason my tests against a local server on my laptop
+			// fail intermittently and return this result number. However, it will succeed if you try it a few
+			// more times. Also noteworthy is that this doens't happen when hitting an external server. WTF?!
+			if (result == 7) {
+				VALUE max_retries = rb_funcall(easy, rb_intern("max_retries?"), 0);
+				if (max_retries != Qtrue) {
+					multi_remove_handle(self, easy);
+					multi_add_handle(self, easy);
+					CurlMulti *curl_multi;
+					Data_Get_Struct(self, CurlMulti, curl_multi);
+			    curl_multi_perform(curl_multi->multi, &(curl_multi->running));
+
+					rb_funcall(easy, rb_intern("increment_retries"), 0);
+				
+					continue;
+				}
+			}
+			multi_remove_handle(self, easy);
+
+      if (result != 0) {
+				rb_funcall(easy, rb_intern("failure"), 0);
+      }
+      else if ((response_code >= 200 && response_code < 300) || response_code == 0) {
+        rb_funcall(easy, rb_intern("success"), 0);
+      }
+      else if (response_code >= 300 && response_code < 600) {
+        rb_funcall(easy, rb_intern("failure"), 0);
+      }
+    }
+  }
+}
+
+/* called within ruby_curl_multi_perform */
+static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_running) {
+  CURLMcode mcode;
+
+  do {
+    mcode = curl_multi_perform(multi_handle, still_running);
+  } while (mcode == CURLM_CALL_MULTI_PERFORM);
+
+  if (mcode != CURLM_OK) {
+    rb_raise(mcode, "an error occured while running perform");
+  }
+
+  multi_read_info( self, multi_handle );
+}
+
+static VALUE multi_perform(VALUE self) {
+  CURLMcode mcode;
+	CurlMulti *curl_multi;
+  int maxfd, rc;
+  fd_set fdread, fdwrite, fdexcep;
+
+  long timeout;
+  struct timeval tv = {0, 0};
+
+  Data_Get_Struct(self, CurlMulti, curl_multi);
+
+  rb_curl_multi_run( self, curl_multi->multi, &(curl_multi->running) );
+  while(curl_multi->running) { 
+    FD_ZERO(&fdread);
+    FD_ZERO(&fdwrite);
+    FD_ZERO(&fdexcep);
+
+    /* get the curl suggested time out */
+    mcode = curl_multi_timeout(curl_multi->multi, &timeout);
+    if (mcode != CURLM_OK) {
+			rb_raise(mcode, "an error occured getting the timeout");
+			    }
+			
+    if (timeout == 0) { /* no delay */
+      rb_curl_multi_run( self, curl_multi->multi, &(curl_multi->running) );
+      continue;
+    }
+    else if (timeout == -1) {
+      timeout = 1;
+    }
+
+    tv.tv_sec = timeout / 1000;
+		tv.tv_usec = (timeout * 1000) % 1000000;
+
+    /* load the fd sets from the multi handle */
+    mcode = curl_multi_fdset(curl_multi->multi, &fdread, &fdwrite, &fdexcep, &maxfd);
+    if (mcode != CURLM_OK) {
+      rb_raise(mcode, "an error occured getting the fdset");
+    }
+
+    rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
+    if (rc < 0) {
+      rb_raise(rb_eRuntimeError, "error on thread select");
+    }
+    rb_curl_multi_run( self, curl_multi->multi, &(curl_multi->running) );
+
+  }
+
+  return Qnil;
+}
+
+static VALUE active_handle_count(VALUE self) {
+	CurlMulti *curl_multi;
+	Data_Get_Struct(self, CurlMulti, curl_multi);
+
+	return INT2NUM(curl_multi->active);
+}
+
+static VALUE multi_cleanup(VALUE self) {
+	CurlMulti *curl_multi;
+	Data_Get_Struct(self, CurlMulti, curl_multi);
+	
+	curl_multi_cleanup(curl_multi->multi);
+	curl_multi->active = 0;
+	curl_multi->running = 0;
+	
+	return Qnil;
+}
+
+static VALUE new(int argc, VALUE *argv, VALUE klass) {
+	CurlMulti *curl_multi = ALLOC(CurlMulti);
+	curl_multi->multi = curl_multi_init();
+	curl_multi->active = 0;
+	curl_multi->running = 0;
+
+	VALUE multi = Data_Wrap_Struct(cTyphoeusMulti, 0, dealloc, curl_multi);
+
+	rb_obj_call_init(multi, argc, argv);
+
+	return multi;
+}
+
+void init_typhoeus_multi() {
+	VALUE klass = cTyphoeusMulti = rb_define_class_under(mTyphoeus, "Multi", rb_cObject);
+
+	rb_define_singleton_method(klass, "new", new, -1);
+	rb_define_private_method(klass, "multi_add_handle", multi_add_handle, 1);
+	rb_define_private_method(klass, "multi_remove_handle", multi_remove_handle, 1);
+	rb_define_private_method(klass, "multi_perform", multi_perform, 0);
+	rb_define_private_method(klass, "multi_cleanup", multi_cleanup, 0);
+	rb_define_private_method(klass, "active_handle_count", active_handle_count, 0);
+}

data/ext/typhoeus/typhoeus_multi.h

@@ -0,0 +1,16 @@
+#ifndef TYPHOEUS_MULTI
+#define TYPHOEUS_MULTI
+
+#include <native.h>
+#include <typhoeus_easy.h>
+
+VALUE cTyphoeusMulti;
+typedef struct {
+	int running;
+	int active;
+	CURLM *multi;
+} CurlMulti;
+
+void init_typhoeus_multi();
+
+#endif