unicorn-rupcio 6.1.0

data/ext/unicorn_http/epollexclusive.h

@@ -0,0 +1,128 @@
+/*
+ * This is only intended for use inside a unicorn worker, nowhere else.
+ * EPOLLEXCLUSIVE somewhat mitigates the thundering herd problem for
+ * mostly idle processes since we can't use blocking accept4.
+ * This is NOT intended for use with multi-threaded servers, nor
+ * single-threaded multi-client ("C10K") servers or anything advanced
+ * like that.  This use of epoll is only appropriate for a primitive,
+ * single-client, single-threaded servers like unicorn that need to
+ * support SIGKILL timeouts and parent death detection.
+ */
+#if defined(HAVE_EPOLL_CREATE1)
+#  include <sys/epoll.h>
+#  include <errno.h>
+#  include <ruby/io.h>
+#  include <ruby/thread.h>
+#endif /* __linux__ */
+
+#if defined(EPOLLEXCLUSIVE) && defined(HAVE_EPOLL_CREATE1)
+#  define USE_EPOLL (1)
+#else
+#  define USE_EPOLL (0)
+#endif
+
+#if USE_EPOLL
+#if defined(HAVE_RB_IO_DESCRIPTOR) /* Ruby 3.1+ */
+#	define my_fileno(io) rb_io_descriptor(io)
+#else /* Ruby <3.1 */
+static int my_fileno(VALUE io)
+{
+	rb_io_t *fptr;
+	GetOpenFile(io, fptr);
+	rb_io_check_closed(fptr);
+	return fptr->fd;
+}
+#endif /* Ruby <3.1 */
+
+/*
+ * :nodoc:
+ * returns IO object if EPOLLEXCLUSIVE works and arms readers
+ */
+static VALUE prep_readers(VALUE cls, VALUE readers)
+{
+	long i;
+	int epfd = epoll_create1(EPOLL_CLOEXEC);
+	VALUE epio;
+
+	if (epfd < 0) rb_sys_fail("epoll_create1");
+
+	epio = rb_funcall(cls, rb_intern("for_fd"), 1, INT2NUM(epfd));
+
+	Check_Type(readers, T_ARRAY);
+	for (i = 0; i < RARRAY_LEN(readers); i++) {
+		int rc, fd;
+		struct epoll_event e;
+		VALUE io = rb_ary_entry(readers, i);
+
+		e.data.u64 = i; /* the reason readers shouldn't change */
+
+		/*
+		 * I wanted to use EPOLLET here, but maintaining our own
+		 * equivalent of ep->rdllist in Ruby-space doesn't fit
+		 * our design at all (and the kernel already has it's own
+		 * code path for doing it).  So let the kernel spend
+		 * cycles on maintaining level-triggering.
+		 */
+		e.events = EPOLLEXCLUSIVE | EPOLLIN;
+		fd = my_fileno(rb_io_get_io(io));
+		rc = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &e);
+		if (rc < 0) rb_sys_fail("epoll_ctl");
+	}
+	return epio;
+}
+#endif /* USE_EPOLL */
+
+#if USE_EPOLL
+struct ep_wait {
+	struct epoll_event event;
+	int epfd;
+	int timeout_msec;
+};
+
+static void *do_wait(void *ptr) /* runs w/o GVL */
+{
+	struct ep_wait *epw = ptr;
+	/*
+	 * Linux delivers epoll events in the order received, and using
+	 * maxevents=1 ensures we pluck one item off ep->rdllist
+	 * at-a-time (c.f. fs/eventpoll.c in linux.git, it's quite
+	 * easy-to-understand for anybody familiar with Ruby C).
+	 */
+	return (void *)(long)epoll_wait(epw->epfd, &epw->event, 1,
+					epw->timeout_msec);
+}
+
+/* :nodoc: */
+/* readers must not change between prepare_readers and get_readers */
+static VALUE
+get_readers(VALUE epio, VALUE ready, VALUE readers, VALUE timeout_msec)
+{
+	struct ep_wait epw;
+	long n;
+
+	Check_Type(ready, T_ARRAY);
+	Check_Type(readers, T_ARRAY);
+
+	epw.epfd = my_fileno(epio);
+	epw.timeout_msec = NUM2INT(timeout_msec);
+	n = (long)rb_thread_call_without_gvl(do_wait, &epw, RUBY_UBF_IO, NULL);
+	if (n < 0) {
+		if (errno != EINTR) rb_sys_fail("epoll_wait");
+	} else if (n > 0) { /* maxevents is hardcoded to 1 */
+		VALUE obj = rb_ary_entry(readers, epw.event.data.u64);
+
+		if (RTEST(obj))
+			rb_ary_push(ready, obj);
+	} /* n == 0 : timeout */
+	return Qfalse;
+}
+#endif /* USE_EPOLL */
+
+static void init_epollexclusive(VALUE mUnicorn)
+{
+#if USE_EPOLL
+	VALUE cWaiter = rb_define_class_under(mUnicorn, "Waiter", rb_cIO);
+	rb_define_singleton_method(cWaiter, "prep_readers", prep_readers, 1);
+	rb_define_method(cWaiter, "get_readers", get_readers, 3);
+#endif
+}

data/ext/unicorn_http/ext_help.h

@@ -0,0 +1,38 @@
+#ifndef ext_help_h
+#define ext_help_h
+
+/* not all Ruby implementations support frozen objects (Rubinius does not) */
+#if defined(OBJ_FROZEN)
+#  define assert_frozen(f) assert(OBJ_FROZEN(f) && "unfrozen object")
+#else
+#  define assert_frozen(f) do {} while (0)
+#endif /* !defined(OBJ_FROZEN) */
+
+static inline int str_cstr_eq(VALUE val, const char *ptr, long len)
+{
+  return (RSTRING_LEN(val) == len && !memcmp(ptr, RSTRING_PTR(val), len));
+}
+
+#define STR_CSTR_EQ(val, const_str) \
+  str_cstr_eq(val, const_str, sizeof(const_str) - 1)
+
+/* strcasecmp isn't locale independent */
+static int str_cstr_case_eq(VALUE val, const char *ptr, long len)
+{
+  if (RSTRING_LEN(val) == len) {
+    const char *v = RSTRING_PTR(val);
+
+    for (; len--; ++ptr, ++v) {
+      if ((*ptr == *v) || (*v >= 'A' && *v <= 'Z' && (*v | 0x20) == *ptr))
+        continue;
+      return 0;
+    }
+    return 1;
+  }
+  return 0;
+}
+
+#define STR_CSTR_CASE_EQ(val, const_str) \
+  str_cstr_case_eq(val, const_str, sizeof(const_str) - 1)
+
+#endif /* ext_help_h */

data/ext/unicorn_http/extconf.rb

@@ -0,0 +1,40 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+require 'mkmf'
+
+have_func("rb_hash_clear", "ruby.h") or abort 'Ruby 2.0+ required'
+
+message('checking if String#-@ (str_uminus) dedupes... ')
+begin
+  a = -(%w(t e s t).join)
+  b = -(%w(t e s t).join)
+  if a.equal?(b)
+    $CPPFLAGS += ' -DSTR_UMINUS_DEDUPE=1 '
+    message("yes\n")
+  else
+    $CPPFLAGS += ' -DSTR_UMINUS_DEDUPE=0 '
+    message("no, needs Ruby 2.5+\n")
+  end
+rescue NoMethodError
+  $CPPFLAGS += ' -DSTR_UMINUS_DEDUPE=0 '
+  message("no, String#-@ not available\n")
+end
+
+message('checking if Hash#[]= (rb_hash_aset) dedupes... ')
+h = {}
+x = {}
+r = rand.to_s
+h[%W(#{r}).join('')] = :foo
+x[%W(#{r}).join('')] = :foo
+if x.keys[0].equal?(h.keys[0])
+  $CPPFLAGS += ' -DHASH_ASET_DEDUPE=1 '
+  message("yes\n")
+else
+  $CPPFLAGS += ' -DHASH_ASET_DEDUPE=0 '
+  message("no, needs Ruby 2.6+\n")
+end
+
+if have_func('epoll_create1', %w(sys/epoll.h))
+  have_func('rb_io_descriptor') # Ruby 3.1+
+end
+create_makefile("unicorn_http")

data/ext/unicorn_http/global_variables.h

@@ -0,0 +1,97 @@
+#ifndef global_variables_h
+#define global_variables_h
+static VALUE eHttpParserError;
+static VALUE e413;
+static VALUE e414;
+
+static VALUE g_rack_url_scheme;
+static VALUE g_request_method;
+static VALUE g_request_uri;
+static VALUE g_fragment;
+static VALUE g_query_string;
+static VALUE g_http_version;
+static VALUE g_request_path;
+static VALUE g_path_info;
+static VALUE g_server_name;
+static VALUE g_server_port;
+static VALUE g_server_protocol;
+static VALUE g_http_host;
+static VALUE g_http_x_forwarded_proto;
+static VALUE g_http_x_forwarded_ssl;
+static VALUE g_http_transfer_encoding;
+static VALUE g_content_length;
+static VALUE g_http_trailer;
+static VALUE g_http_connection;
+static VALUE g_port_80;
+static VALUE g_port_443;
+static VALUE g_localhost;
+static VALUE g_http;
+static VALUE g_https;
+static VALUE g_http_09;
+static VALUE g_http_10;
+static VALUE g_http_11;
+
+/** Defines common length and error messages for input length validation. */
+#define DEF_MAX_LENGTH(N, length) \
+  static const size_t MAX_##N##_LENGTH = length; \
+  static const char * const MAX_##N##_LENGTH_ERR = \
+    "HTTP element " # N  " is longer than the " # length " allowed length."
+
+NORETURN(static void parser_raise(VALUE klass, const char *));
+
+/**
+ * Validates the max length of given input and throws an HttpParserError
+ * exception if over.
+ */
+#define VALIDATE_MAX_LENGTH(len, N) do { \
+  if (len > MAX_##N##_LENGTH) \
+    parser_raise(eHttpParserError, MAX_##N##_LENGTH_ERR); \
+} while (0)
+
+#define VALIDATE_MAX_URI_LENGTH(len, N) do { \
+  if (len > MAX_##N##_LENGTH) \
+    parser_raise(e414, MAX_##N##_LENGTH_ERR); \
+} while (0)
+
+/** Defines global strings in the init method. */
+#define DEF_GLOBAL(N, val) do { \
+  g_##N = str_new_dd_freeze(val, (long)sizeof(val) - 1); \
+  rb_gc_register_mark_object(g_##N); \
+} while (0)
+
+/* Defines the maximum allowed lengths for various input elements.*/
+DEF_MAX_LENGTH(FIELD_NAME, 256);
+DEF_MAX_LENGTH(FIELD_VALUE, 80 * 1024);
+DEF_MAX_LENGTH(REQUEST_URI, 1024 * 15);
+DEF_MAX_LENGTH(FRAGMENT, 1024); /* Don't know if this length is specified somewhere or not */
+DEF_MAX_LENGTH(REQUEST_PATH, 4096); /* common PATH_MAX on modern systems */
+DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
+
+static void init_globals(void)
+{
+  DEF_GLOBAL(rack_url_scheme, "rack.url_scheme");
+  DEF_GLOBAL(request_method, "REQUEST_METHOD");
+  DEF_GLOBAL(request_uri, "REQUEST_URI");
+  DEF_GLOBAL(fragment, "FRAGMENT");
+  DEF_GLOBAL(query_string, "QUERY_STRING");
+  DEF_GLOBAL(http_version, "HTTP_VERSION");
+  DEF_GLOBAL(request_path, "REQUEST_PATH");
+  DEF_GLOBAL(path_info, "PATH_INFO");
+  DEF_GLOBAL(server_name, "SERVER_NAME");
+  DEF_GLOBAL(server_port, "SERVER_PORT");
+  DEF_GLOBAL(server_protocol, "SERVER_PROTOCOL");
+  DEF_GLOBAL(http_x_forwarded_proto, "HTTP_X_FORWARDED_PROTO");
+  DEF_GLOBAL(http_x_forwarded_ssl, "HTTP_X_FORWARDED_SSL");
+  DEF_GLOBAL(port_80, "80");
+  DEF_GLOBAL(port_443, "443");
+  DEF_GLOBAL(localhost, "localhost");
+  DEF_GLOBAL(http, "http");
+  DEF_GLOBAL(https, "https");
+  DEF_GLOBAL(http_11, "HTTP/1.1");
+  DEF_GLOBAL(http_10, "HTTP/1.0");
+  DEF_GLOBAL(http_09, "HTTP/0.9");
+}
+
+#undef DEF_GLOBAL
+
+#endif /* global_variables_h */

data/ext/unicorn_http/httpdate.c

@@ -0,0 +1,91 @@
+#include <ruby.h>
+#include <time.h>
+#include <sys/time.h>
+#include <stdio.h>
+
+static const size_t buf_capa = sizeof("Thu, 01 Jan 1970 00:00:00 GMT");
+static VALUE buf;
+static char *buf_ptr;
+static const char week[] = "Sun\0Mon\0Tue\0Wed\0Thu\0Fri\0Sat";
+static const char months[] = "Jan\0Feb\0Mar\0Apr\0May\0Jun\0"
+                             "Jul\0Aug\0Sep\0Oct\0Nov\0Dec";
+
+/* for people on wonky systems only */
+#ifndef HAVE_GMTIME_R
+# warning using fake gmtime_r
+static struct tm * my_gmtime_r(time_t *now, struct tm *tm)
+{
+	struct tm *global = gmtime(now);
+	if (global)
+		*tm = *global;
+	return tm;
+}
+#  define gmtime_r my_gmtime_r
+#endif
+
+
+/*
+ * Returns a string which represents the time as rfc1123-date of HTTP-date
+ * defined by RFC 2616:
+ *
+ *   day-of-week, DD month-name CCYY hh:mm:ss GMT
+ *
+ * Note that the result is always GMT.
+ *
+ * This method is identical to Time#httpdate in the Ruby standard library,
+ * except it is implemented in C for performance.  We always saw
+ * Time#httpdate at or near the top of the profiler output so we
+ * decided to rewrite this in C.
+ *
+ * Caveats: it relies on a Ruby implementation with the global VM lock,
+ * a thread-safe version will be provided when a Unix-only, GVL-free Ruby
+ * implementation becomes viable.
+ */
+static VALUE httpdate(VALUE self)
+{
+	static time_t last;
+	struct timeval now;
+	struct tm tm;
+
+	/*
+	 * Favor gettimeofday(2) over time(2), as the latter can return the
+	 * wrong value in the first 1 .. 2.5 ms of every second(!)
+	 *
+	 * https://lore.kernel.org/git/20230320230507.3932018-1-gitster@pobox.com/
+	 * https://inbox.sourceware.org/libc-alpha/20230306160321.2942372-1-adhemerval.zanella@linaro.org/T/
+	 * https://sourceware.org/bugzilla/show_bug.cgi?id=30200
+	 */
+	if (gettimeofday(&now, NULL))
+		rb_sys_fail("gettimeofday");
+
+	if (last == now.tv_sec)
+		return buf;
+	last = now.tv_sec;
+	gmtime_r(&now.tv_sec, &tm);
+
+	/* we can make this thread-safe later if our Ruby loses the GVL */
+	snprintf(buf_ptr, buf_capa,
+	         "%s, %02d %s %4d %02d:%02d:%02d GMT",
+	         week + (tm.tm_wday * 4),
+	         tm.tm_mday,
+	         months + (tm.tm_mon * 4),
+	         tm.tm_year + 1900,
+	         tm.tm_hour,
+	         tm.tm_min,
+	         tm.tm_sec);
+
+	return buf;
+}
+
+void init_unicorn_httpdate(void)
+{
+	VALUE mod = rb_define_module("Unicorn");
+	mod = rb_define_module_under(mod, "HttpResponse");
+
+	buf = rb_str_new(0, buf_capa - 1);
+	rb_gc_register_mark_object(buf);
+	buf_ptr = RSTRING_PTR(buf);
+	httpdate(Qnil);
+
+	rb_define_method(mod, "httpdate", httpdate, 0);
+}