eventmachine 1.0.3-x86-mingw32 → 1.2.0.dev.2-x86-mingw32

data/ext/em.h

@@ -22,13 +22,22 @@ See the file COPYING for complete licensing information.
 
 #ifdef BUILD_FOR_RUBY
   #include <ruby.h>
-  #define EmSelect rb_thread_select
+  #ifdef HAVE_RB_THREAD_FD_SELECT
+    #define EmSelect rb_thread_fd_select
+  #else
+    // ruby 1.9.1 and below
+    #define EmSelect rb_thread_select
+  #endif
+
+  #ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+   #include <ruby/thread.h>
+  #endif
 
   #ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
     #include <ruby/io.h>
   #endif
 
-  #if defined(HAVE_RBTRAP)
+  #if defined(HAVE_RB_TRAP_IMMEDIATE)
     #include <rubysig.h>
   #elif defined(HAVE_RB_ENABLE_INTERRUPT)
     extern "C" {
@@ -60,8 +69,55 @@ See the file COPYING for complete licensing information.
   #define EmSelect select
 #endif
 
+#if !defined(HAVE_TYPE_RB_FDSET_T)
+#define fd_check(n) (((n) < FD_SETSIZE) ? 1 : 0*fprintf(stderr, "fd %d too large for select\n", (n)))
+// These definitions are cribbed from include/ruby/intern.h in Ruby 1.9.3,
+// with this change: any macros that read or write the nth element of an
+// fdset first call fd_check to make sure n is in bounds.
+typedef fd_set rb_fdset_t;
+#define rb_fd_zero(f) FD_ZERO(f)
+#define rb_fd_set(n, f) do { if (fd_check(n)) FD_SET((n), (f)); } while(0)
+#define rb_fd_clr(n, f) do { if (fd_check(n)) FD_CLR((n), (f)); } while(0)
+#define rb_fd_isset(n, f) (fd_check(n) ? FD_ISSET((n), (f)) : 0)
+#define rb_fd_copy(d, s, n) (*(d) = *(s))
+#define rb_fd_dup(d, s) (*(d) = *(s))
+#define rb_fd_resize(n, f)  ((void)(f))
+#define rb_fd_ptr(f)  (f)
+#define rb_fd_init(f) FD_ZERO(f)
+#define rb_fd_init_copy(d, s) (*(d) = *(s))
+#define rb_fd_term(f) ((void)(f))
+#define rb_fd_max(f)  FD_SETSIZE
+#define rb_fd_select(n, rfds, wfds, efds, timeout)  \
+  select(fd_check((n)-1) ? (n) : FD_SETSIZE, (rfds), (wfds), (efds), (timeout))
+#define rb_thread_fd_select(n, rfds, wfds, efds, timeout)  \
+  rb_thread_select(fd_check((n)-1) ? (n) : FD_SETSIZE, (rfds), (wfds), (efds), (timeout))
+#endif
+
+
+// This Solaris fix is adapted from eval_intern.h in Ruby 1.9.3:
+// Solaris sys/select.h switches select to select_large_fdset to support larger
+// file descriptors if FD_SETSIZE is larger than 1024 on 32bit environment.
+// But Ruby doesn't change FD_SETSIZE because fd_set is allocated dynamically.
+// So following definition is required to use select_large_fdset.
+#ifdef HAVE_SELECT_LARGE_FDSET
+#define select(n, r, w, e, t) select_large_fdset((n), (r), (w), (e), (t))
+extern "C" {
+  int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval *);
+}
+#endif
+
 class EventableDescriptor;
 class InotifyDescriptor;
+struct SelectData_t;
+
+/*************
+enum Poller_t
+*************/
+enum Poller_t {
+	Poller_Default, // typically Select
+	Poller_Epoll,
+	Poller_Kqueue
+};
 
 
 /********************
@@ -74,29 +130,35 @@ class EventMachine_t
 		static int GetMaxTimerCount();
 		static void SetMaxTimerCount (int);
 
+		static int GetSimultaneousAcceptCount();
+		static void SetSimultaneousAcceptCount (int);
+
 	public:
-		EventMachine_t (EMCallback);
+		EventMachine_t (EMCallback, Poller_t);
 		virtual ~EventMachine_t();
 
+		bool RunOnce();
 		void Run();
 		void ScheduleHalt();
+		bool Stopping();
 		void SignalLoopBreaker();
-		const unsigned long InstallOneshotTimer (int);
-		const unsigned long ConnectToServer (const char *, int, const char *, int);
-		const unsigned long ConnectToUnixServer (const char *);
-
-		const unsigned long CreateTcpServer (const char *, int);
-		const unsigned long OpenDatagramSocket (const char *, int);
-		const unsigned long CreateUnixDomainServer (const char*);
-		const unsigned long OpenKeyboard();
+		const uintptr_t InstallOneshotTimer (int);
+		const uintptr_t ConnectToServer (const char *, int, const char *, int);
+		const uintptr_t ConnectToUnixServer (const char *);
+
+		const uintptr_t CreateTcpServer (const char *, int);
+		const uintptr_t OpenDatagramSocket (const char *, int);
+		const uintptr_t CreateUnixDomainServer (const char*);
+		const uintptr_t AttachSD (SOCKET);
+		const uintptr_t OpenKeyboard();
 		//const char *Popen (const char*, const char*);
-		const unsigned long Socketpair (char* const*);
+		const uintptr_t Socketpair (char* const*);
 
 		void Add (EventableDescriptor*);
 		void Modify (EventableDescriptor*);
 		void Deregister (EventableDescriptor*);
 
-		const unsigned long AttachFD (int, bool);
+		const uintptr_t AttachFD (SOCKET, bool);
 		int DetachFD (EventableDescriptor*);
 
 		void ArmKqueueWriter (EventableDescriptor*);
@@ -113,18 +175,18 @@ class EventMachine_t
 		float GetHeartbeatInterval();
 		int SetHeartbeatInterval(float);
 
-		const unsigned long WatchFile (const char*);
+		const uintptr_t WatchFile (const char*);
 		void UnwatchFile (int);
-		void UnwatchFile (const unsigned long);
+		void UnwatchFile (const uintptr_t);
 
 		#ifdef HAVE_KQUEUE
 		void _HandleKqueueFileEvent (struct kevent*);
 		void _RegisterKqueueFileEvent(int);
 		#endif
 
-		const unsigned long WatchPid (int);
+		const uintptr_t WatchPid (int);
 		void UnwatchPid (int);
-		void UnwatchPid (const unsigned long);
+		void UnwatchPid (const uintptr_t);
 
 		#ifdef HAVE_KQUEUE
 		void _HandleKqueuePidEvent (struct kevent*);
@@ -132,20 +194,16 @@ class EventMachine_t
 
 		uint64_t GetCurrentLoopTime() { return MyCurrentLoopTime; }
 
-		// Temporary:
-		void _UseEpoll();
-		void _UseKqueue();
-
-		bool UsingKqueue() { return bKqueue; }
-		bool UsingEpoll() { return bEpoll; }
-
 		void QueueHeartbeat(EventableDescriptor*);
 		void ClearHeartbeat(uint64_t, EventableDescriptor*);
 
 		uint64_t GetRealTime();
 
+		Poller_t GetPoller() { return Poller; }
+
+		static bool name2address (const char *server, int port, struct sockaddr *addr, size_t *addr_len);
+
 	private:
-		void _RunOnce();
 		void _RunTimers();
 		void _UpdateTime();
 		void _AddNewDescriptors();
@@ -165,7 +223,7 @@ class EventMachine_t
 	public:
 		void _ReadLoopBreaker();
 		void _ReadInotifyEvents();
-        int NumCloseScheduled;
+		int NumCloseScheduled;
 
 	private:
 		enum {
@@ -186,10 +244,8 @@ class EventMachine_t
 		vector<EventableDescriptor*> NewDescriptors;
 		set<EventableDescriptor*> ModifiedDescriptors;
 
-		uint64_t NextHeartbeatTime;
-
-		int LoopBreakerReader;
-		int LoopBreakerWriter;
+		SOCKET LoopBreakerReader;
+		SOCKET LoopBreakerWriter;
 		#ifdef OS_WIN32
 		struct sockaddr_in LoopBreakerTarget;
 		#endif
@@ -203,22 +259,29 @@ class EventMachine_t
 		unsigned LastTickCount;
 		#endif
 
+		#ifdef OS_DARWIN
+		mach_timebase_info_data_t mach_timebase;
+		#endif
+
 	private:
 		bool bTerminateSignalReceived;
+		SelectData_t *SelectData;
+
+		Poller_t Poller;
 
-		bool bEpoll;
 		int epfd; // Epoll file-descriptor
 		#ifdef HAVE_EPOLL
 		struct epoll_event epoll_events [MaxEvents];
 		#endif
 
-		bool bKqueue;
 		int kqfd; // Kqueue file-descriptor
 		#ifdef HAVE_KQUEUE
 		struct kevent Karray [MaxEvents];
 		#endif
 
+		#ifdef HAVE_INOTIFY
 		InotifyDescriptor *inotify; // pollable descriptor for our inotify instance
+		#endif
 };
 
 
@@ -229,13 +292,15 @@ struct SelectData_t
 struct SelectData_t
 {
 	SelectData_t();
+	~SelectData_t();
 
 	int _Select();
+	void _Clear();
 
-	int maxsocket;
-	fd_set fdreads;
-	fd_set fdwrites;
-	fd_set fderrors;
+	SOCKET maxsocket;
+	rb_fdset_t fdreads;
+	rb_fdset_t fdwrites;
+	rb_fdset_t fderrors;
 	timeval tv;
 	int nSockets;
 };

data/ext/eventmachine.h

@@ -37,80 +37,96 @@ extern "C" {
 		EM_SSL_VERIFY = 109,
 		EM_PROXY_TARGET_UNBOUND = 110,
 		EM_PROXY_COMPLETED = 111
+	};
 
+	enum { // SSL/TLS Protocols
+		EM_PROTO_SSLv2 = 2,
+		EM_PROTO_SSLv3 = 4,
+		EM_PROTO_TLSv1 = 8,
+		EM_PROTO_TLSv1_1 = 16,
+		EM_PROTO_TLSv1_2 = 32
 	};
 
 	void evma_initialize_library (EMCallback);
+	bool evma_run_machine_once();
 	void evma_run_machine();
 	void evma_release_library();
-	const unsigned long evma_install_oneshot_timer (int seconds);
-	const unsigned long evma_connect_to_server (const char *bind_addr, int bind_port, const char *server, int port);
-	const unsigned long evma_connect_to_unix_server (const char *server);
-
-	const unsigned long evma_attach_fd (int file_descriptor, int watch_mode);
-	int evma_detach_fd (const unsigned long binding);
-	int evma_get_file_descriptor (const unsigned long binding);
-	int evma_is_notify_readable (const unsigned long binding);
-	void evma_set_notify_readable (const unsigned long binding, int mode);
-	int evma_is_notify_writable (const unsigned long binding);
-	void evma_set_notify_writable (const unsigned long binding, int mode);
-
-	int evma_pause(const unsigned long binding);
-	int evma_is_paused(const unsigned long binding);
-	int evma_resume(const unsigned long binding);
-
-    int evma_num_close_scheduled();
-
-	void evma_stop_tcp_server (const unsigned long signature);
-	const unsigned long evma_create_tcp_server (const char *address, int port);
-	const unsigned long evma_create_unix_domain_server (const char *filename);
-	const unsigned long evma_open_datagram_socket (const char *server, int port);
-	const unsigned long evma_open_keyboard();
-	void evma_set_tls_parms (const unsigned long binding, const char *privatekey_filename, const char *certchain_filenane, int verify_peer);
-	void evma_start_tls (const unsigned long binding);
+	const uintptr_t evma_install_oneshot_timer (int seconds);
+	const uintptr_t evma_connect_to_server (const char *bind_addr, int bind_port, const char *server, int port);
+	const uintptr_t evma_connect_to_unix_server (const char *server);
+
+	const uintptr_t evma_attach_fd (int file_descriptor, int watch_mode);
+	int evma_detach_fd (const uintptr_t binding);
+	int evma_get_file_descriptor (const uintptr_t binding);
+	int evma_is_notify_readable (const uintptr_t binding);
+	void evma_set_notify_readable (const uintptr_t binding, int mode);
+	int evma_is_notify_writable (const uintptr_t binding);
+	void evma_set_notify_writable (const uintptr_t binding, int mode);
+
+	int evma_pause(const uintptr_t binding);
+	int evma_is_paused(const uintptr_t binding);
+	int evma_resume(const uintptr_t binding);
+
+	int evma_num_close_scheduled();
+
+	void evma_stop_tcp_server (const uintptr_t binding);
+	const uintptr_t evma_create_tcp_server (const char *address, int port);
+	const uintptr_t evma_create_unix_domain_server (const char *filename);
+	const uintptr_t evma_attach_sd (int sd);
+	const uintptr_t evma_open_datagram_socket (const char *server, int port);
+	const uintptr_t evma_open_keyboard();
+	void evma_set_tls_parms (const uintptr_t binding, const char *privatekey_filename, const char *certchain_filenane, int verify_peer, int fail_if_no_peer_cert, const char *sni_hostname, const char *cipherlist, const char *ecdh_curve, const char *dhparam, int protocols);
+	void evma_start_tls (const uintptr_t binding);
 
 	#ifdef WITH_SSL
-	X509 *evma_get_peer_cert (const unsigned long binding);
-	void evma_accept_ssl_peer (const unsigned long binding);
+	X509 *evma_get_peer_cert (const uintptr_t binding);
+	int evma_get_cipher_bits (const uintptr_t binding);
+	const char *evma_get_cipher_name (const uintptr_t binding);
+	const char *evma_get_cipher_protocol (const uintptr_t binding);
+	const char *evma_get_sni_hostname (const uintptr_t binding);
+	void evma_accept_ssl_peer (const uintptr_t binding);
 	#endif
 
-	int evma_get_peername (const unsigned long binding, struct sockaddr*, socklen_t*);
-	int evma_get_sockname (const unsigned long binding, struct sockaddr*, socklen_t*);
-	int evma_get_subprocess_pid (const unsigned long binding, pid_t*);
-	int evma_get_subprocess_status (const unsigned long binding, int*);
+	int evma_get_peername (const uintptr_t binding, struct sockaddr*, socklen_t*);
+	int evma_get_sockname (const uintptr_t binding, struct sockaddr*, socklen_t*);
+	int evma_get_subprocess_pid (const uintptr_t binding, pid_t*);
+	int evma_get_subprocess_status (const uintptr_t binding, int*);
 	int evma_get_connection_count();
-	int evma_send_data_to_connection (const unsigned long binding, const char *data, int data_length);
-	int evma_send_datagram (const unsigned long binding, const char *data, int data_length, const char *address, int port);
-	float evma_get_comm_inactivity_timeout (const unsigned long binding);
-	int evma_set_comm_inactivity_timeout (const unsigned long binding, float value);
-	float evma_get_pending_connect_timeout (const unsigned long binding);
-	int evma_set_pending_connect_timeout (const unsigned long binding, float value);
-	int evma_get_outbound_data_size (const unsigned long binding);
-	uint64_t evma_get_last_activity_time (const unsigned long);
-	int evma_send_file_data_to_connection (const unsigned long binding, const char *filename);
-
-	void evma_close_connection (const unsigned long binding, int after_writing);
-	int evma_report_connection_error_status (const unsigned long binding);
+	int evma_send_data_to_connection (const uintptr_t binding, const char *data, int data_length);
+	int evma_send_datagram (const uintptr_t binding, const char *data, int data_length, const char *address, int port);
+	float evma_get_comm_inactivity_timeout (const uintptr_t binding);
+	int evma_set_comm_inactivity_timeout (const uintptr_t binding, float value);
+	float evma_get_pending_connect_timeout (const uintptr_t binding);
+	int evma_set_pending_connect_timeout (const uintptr_t binding, float value);
+	int evma_get_outbound_data_size (const uintptr_t binding);
+	uint64_t evma_get_last_activity_time (const uintptr_t binding);
+	int evma_send_file_data_to_connection (const uintptr_t binding, const char *filename);
+
+	void evma_close_connection (const uintptr_t binding, int after_writing);
+	int evma_report_connection_error_status (const uintptr_t binding);
 	void evma_signal_loopbreak();
 	void evma_set_timer_quantum (int);
 	int evma_get_max_timer_count();
 	void evma_set_max_timer_count (int);
+	int evma_get_simultaneous_accept_count();
+	void evma_set_simultaneous_accept_count (int);
 	void evma_setuid_string (const char *username);
 	void evma_stop_machine();
+	bool evma_stopping();
 	float evma_get_heartbeat_interval();
 	int evma_set_heartbeat_interval(float);
 
-	const unsigned long evma_popen (char * const*cmd_strings);
+	const uintptr_t evma_popen (char * const*cmd_strings);
 
-	const unsigned long evma_watch_filename (const char *fname);
-	void evma_unwatch_filename (const unsigned long);
+	const uintptr_t evma_watch_filename (const char *fname);
+	void evma_unwatch_filename (const uintptr_t binding);
 
-	const unsigned long evma_watch_pid (int);
-	void evma_unwatch_pid (const unsigned long);
+	const uintptr_t evma_watch_pid (int);
+	void evma_unwatch_pid (const uintptr_t binding);
 
-	void evma_start_proxy(const unsigned long, const unsigned long, const unsigned long, const unsigned long);
-	void evma_stop_proxy(const unsigned long);
-	unsigned long evma_proxied_bytes(const unsigned long);
+	void evma_start_proxy(const uintptr_t from, const uintptr_t to, const unsigned long bufsize, const unsigned long length);
+	void evma_stop_proxy(const uintptr_t from);
+	unsigned long evma_proxied_bytes(const uintptr_t from);
 
 	int evma_set_rlimit_nofile (int n_files);
 

data/ext/extconf.rb

@@ -1,6 +1,9 @@
 require 'fileutils'
 require 'mkmf'
 
+# Eager check devs tools
+have_devel? if respond_to?(:have_devel?)
+
 def check_libs libs = [], fatal = false
   libs.all? { |lib| have_library(lib) || (abort("could not find library: #{lib}") if fatal) }
 end
@@ -22,31 +25,59 @@ def append_library(libs, lib)
   libs + " " + format(LIBARG, lib)
 end
 
-def manual_ssl_config
-  ssl_libs_heads_args = {
-    :unix => [%w[ssl crypto], %w[openssl/ssl.h openssl/err.h]],
-    :mswin => [%w[ssleay32 eay32], %w[openssl/ssl.h openssl/err.h]],
-  }
+SSL_HEADS = %w(openssl/ssl.h openssl/err.h)
+SSL_LIBS = case RUBY_PLATFORM
+when /mswin|mingw|bccwin/ ; %w(ssleay32 libeay32)
+else                      ; %w(crypto ssl)
+end
 
-  dc_flags = ['ssl']
-  dc_flags += ["#{ENV['OPENSSL']}/include", ENV['OPENSSL']] if /linux/ =~ RUBY_PLATFORM and ENV['OPENSSL']
+def dir_config_wrapper(pretty_name, name, idefault=nil, ldefault=nil)
+  inc, lib = dir_config(name, idefault, ldefault)
+  if inc && lib
+    # TODO: Remove when 2.0.0 is the minimum supported version
+    # Ruby versions not incorporating the mkmf fix at
+    # https://bugs.ruby-lang.org/projects/ruby-trunk/repository/revisions/39717
+    # do not properly search for lib directories, and must be corrected
+    unless lib && lib[-3, 3] == 'lib'
+      @libdir_basename = 'lib'
+      inc, lib = dir_config(name, idefault, ldefault)
+    end
+    unless idefault && ldefault
+      abort "-----\nCannot find #{pretty_name} include path #{inc}\n-----" unless inc && inc.split(File::PATH_SEPARATOR).any? { |dir| File.directory?(dir) }
+      abort "-----\nCannot find #{pretty_name} library path #{lib}\n-----" unless lib && lib.split(File::PATH_SEPARATOR).any? { |dir| File.directory?(dir) }
+      warn "-----\nUsing #{pretty_name} in path #{File.dirname inc}\n-----"
+    end
+    true
+  end
+end
 
-  libs, heads = case RUBY_PLATFORM
-  when /mswin/    ; ssl_libs_heads_args[:mswin]
-  else              ssl_libs_heads_args[:unix]
+def dir_config_search(pretty_name, name, paths, &b)
+  paths.each do |p|
+    if dir_config_wrapper('OpenSSL', 'ssl', p + '/include', p + '/lib') && yield
+      warn "-----\nFound #{pretty_name} in path #{p}\n-----"
+      return true
+    end
+  end
+  false
+end
+
+def pkg_config_wrapper(pretty_name, name)
+  cflags, ldflags, libs = pkg_config(name)
+  unless [cflags, ldflags, libs].any?(&:nil?) || [cflags, ldflags, libs].any?(&:empty?)
+    warn "-----\nUsing #{pretty_name} from pkg-config #{cflags} && #{ldflags} && #{libs}\n-----"
+    true
   end
-  dir_config(*dc_flags)
-  check_libs(libs) and check_heads(heads)
 end
 
 if ENV['CROSS_COMPILING']
-  openssl_version = ENV.fetch("OPENSSL_VERSION", "1.0.0j")
+  openssl_version = ENV.fetch("OPENSSL_VERSION", "1.0.2e")
   openssl_dir = File.expand_path("~/.rake-compiler/builds/openssl-#{openssl_version}/")
-  if File.exists?(openssl_dir)
+  if File.exist?(openssl_dir)
     FileUtils.mkdir_p Dir.pwd+"/openssl/"
     FileUtils.cp Dir[openssl_dir+"/include/openssl/*.h"], Dir.pwd+"/openssl/", :verbose => true
     FileUtils.cp Dir[openssl_dir+"/lib*.a"], Dir.pwd, :verbose => true
     $INCFLAGS << " -I#{Dir.pwd}" # for the openssl headers
+    add_define "WITH_SSL"
   else
     STDERR.puts
     STDERR.puts "**************************************************************************************"
@@ -55,26 +86,44 @@ if ENV['CROSS_COMPILING']
     STDERR.puts "**************************************************************************************"
     STDERR.puts
   end
-end
-
-# Try to use pkg_config first, fixes #73
-if (!ENV['CROSS_COMPILING'] and pkg_config('openssl')) || manual_ssl_config
-  add_define "WITH_SSL"
-else
-  add_define "WITHOUT_SSL"
+elsif dir_config_wrapper('OpenSSL', 'ssl')
+  # If the user has provided a --with-ssl-dir argument, we must respect it or fail.
+  add_define 'WITH_SSL' if check_libs(SSL_LIBS) && check_heads(SSL_HEADS)
+elsif pkg_config_wrapper('OpenSSL', 'openssl')
+  # If we can detect OpenSSL by pkg-config, use it as the next-best option
+  add_define 'WITH_SSL' if check_libs(SSL_LIBS) && check_heads(SSL_HEADS)
+elsif check_libs(SSL_LIBS) && check_heads(SSL_HEADS)
+  # If we don't even need any options to find a usable OpenSSL, go with it
+  add_define 'WITH_SSL'
+elsif dir_config_search('OpenSSL', 'ssl', ['/usr/local', '/opt/local', '/usr/local/opt/openssl']) do
+    check_libs(SSL_LIBS) && check_heads(SSL_HEADS)
+  end
+  # Finally, look for OpenSSL in alternate locations including MacPorts and HomeBrew
+  add_define 'WITH_SSL'
 end
 
 add_define 'BUILD_FOR_RUBY'
-add_define 'HAVE_RBTRAP' if have_var('rb_trap_immediate', ['ruby.h', 'rubysig.h'])
-add_define "HAVE_TBR" if have_func('rb_thread_blocking_region')# and have_macro('RUBY_UBF_IO', 'ruby.h')
-add_define "HAVE_INOTIFY" if inotify = have_func('inotify_init', 'sys/inotify.h')
-add_define "HAVE_OLD_INOTIFY" if !inotify && have_macro('__NR_inotify_init', 'sys/syscall.h')
-add_define 'HAVE_WRITEV' if have_func('writev', 'sys/uio.h')
 
+# Ruby features:
+
+have_var('rb_trap_immediate', ['ruby.h', 'rubysig.h'])
+have_func('rb_thread_blocking_region')
+have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+have_func('rb_thread_fd_select')
+have_type('rb_fdset_t', 'ruby/intern.h')
 have_func('rb_wait_for_single_fd')
 have_func('rb_enable_interrupt')
 have_func('rb_time_new')
 
+# System features:
+
+add_define('HAVE_INOTIFY') if inotify = have_func('inotify_init', 'sys/inotify.h')
+add_define('HAVE_OLD_INOTIFY') if !inotify && have_macro('__NR_inotify_init', 'sys/syscall.h')
+have_func('writev', 'sys/uio.h')
+have_func('pipe2', 'unistd.h')
+have_func('accept4', 'sys/socket.h')
+have_const('SOCK_CLOEXEC', 'sys/socket.h')
+
 # Minor platform details between *nix and Windows:
 
 if RUBY_PLATFORM =~ /(mswin|mingw|bccwin)/
@@ -86,7 +135,7 @@ else
   OS_UNIX = true
   add_define 'OS_UNIX'
 
-  add_define "HAVE_KQUEUE" if have_header("sys/event.h") and have_header("sys/queue.h")
+  add_define "HAVE_KQUEUE" if have_header("sys/event.h") && have_header("sys/queue.h")
 end
 
 # Adjust number of file descriptors (FD) on Windows
@@ -106,23 +155,35 @@ when /mswin32/, /mingw32/, /bccwin32/
   check_libs(%w[kernel32 rpcrt4 gdi32], true)
 
   if GNU_CHAIN
-    CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++"
+    CONFIG['LDSHAREDXX'] = "$(CXX) -shared -static-libgcc -static-libstdc++"
   else
     $defs.push "-EHs"
     $defs.push "-GR"
   end
 
+  # Newer versions of Ruby already define _WIN32_WINNT, which is needed
+  # to get access to newer POSIX networking functions (e.g. getaddrinfo)
+  add_define '_WIN32_WINNT=0x0501' unless have_func('getaddrinfo')
+
 when /solaris/
   add_define 'OS_SOLARIS8'
   check_libs(%w[nsl socket], true)
 
-  if CONFIG['CC'] == 'cc' and `cc -flags 2>&1` =~ /Sun/ # detect SUNWspro compiler
+  # If Ruby was compiled for 32-bits, then select() can only handle 1024 fds
+  # There is an alternate function, select_large_fdset, that supports more.
+  have_func('select_large_fdset', 'sys/select.h')
+
+  if CONFIG['CC'] == 'cc' && (
+     `cc -flags 2>&1` =~ /Sun/ || # detect SUNWspro compiler
+     `cc -V 2>&1` =~ /Sun/        # detect Solaris Studio compiler
+    )
     # SUN CHAIN
     add_define 'CC_SUNWspro'
     $preload = ["\nCXX = CC"] # hack a CXX= line into the makefile
     $CFLAGS = CONFIG['CFLAGS'] = "-KPIC"
     CONFIG['CCDLFLAGS'] = "-KPIC"
     CONFIG['LDSHARED'] = "$(CXX) -G -KPIC -lCstd"
+    CONFIG['LDSHAREDXX'] = "$(CXX) -G -KPIC -lCstd"
   else
     # GNU CHAIN
     # on Unix we need a g++ link, not gcc.
@@ -137,6 +198,8 @@ when /openbsd/
   CONFIG['LDSHAREDXX'] = "$(CXX) -shared -lstdc++ -fPIC"
 
 when /darwin/
+  add_define 'OS_DARWIN'
+
   # on Unix we need a g++ link, not gcc.
   # Ff line contributed by Daniel Harple.
   CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
@@ -164,13 +227,43 @@ else
   CONFIG['LDSHARED'] = "$(CXX) -shared"
 end
 
+# Platform-specific time functions
+if have_func('clock_gettime')
+  # clock_gettime is POSIX, but the monotonic clocks are not
+  have_const('CLOCK_MONOTONIC_RAW', 'time.h') # Linux
+  have_const('CLOCK_MONOTONIC', 'time.h') # Linux, Solaris, BSDs
+else
+  have_func('gethrtime') # Older Solaris and HP-UX
+end
 
-# solaris c++ compiler doesn't have make_pair()
+# Hack so that try_link will test with a C++ compiler instead of a C compiler
 TRY_LINK.sub!('$(CC)', '$(CXX)')
+
+# This is our wishlist. We use whichever flags work on the host.
+# In the future, add -Werror to make sure all warnings are resolved.
+# deprecated-declarations are used in OS X OpenSSL
+# ignored-qualifiers are used by the Bindings (would-be void *)
+# unused-result because GCC 4.6 no longer silences (void) ignore_this(function)
+# address because on Windows, rb_fd_select checks if &fds is non-NULL, which it cannot be
+%w(
+  -Wall
+  -Wextra
+  -Wno-deprecated-declarations
+  -Wno-ignored-qualifiers
+  -Wno-unused-result
+  -Wno-address
+).select do |flag|
+  try_link('int main() {return 0;}', flag)
+end.each do |flag|
+  CONFIG['CXXFLAGS'] << ' ' << flag
+end
+puts "CXXFLAGS=#{CONFIG['CXXFLAGS']}"
+
+# Solaris C++ compiler doesn't have make_pair()
 add_define 'HAVE_MAKE_PAIR' if try_link(<<SRC, '-lstdc++')
   #include <utility>
   using namespace std;
-  int main(){ pair<int,int> tuple = make_pair(1,2); }
+  int main(){ pair<const int,int> tuple = make_pair(1,2); }
 SRC
 TRY_LINK.sub!('$(CXX)', '$(CC)')