puma 3.12.6 → 6.2.2

data/ext/puma_http11/puma_http11.c

@@ -10,6 +10,7 @@
 #include "ext_help.h"
 #include <assert.h>
 #include <string.h>
+#include <ctype.h>
 #include "http11_parser.h"
 
 #ifndef MANAGED_STRINGS
@@ -35,11 +36,13 @@ static VALUE global_request_method;
 static VALUE global_request_uri;
 static VALUE global_fragment;
 static VALUE global_query_string;
-static VALUE global_http_version;
+static VALUE global_server_protocol;
 static VALUE global_request_path;
 
 /** Defines common length and error messages for input length validation. */
-#define DEF_MAX_LENGTH(N,length) const size_t MAX_##N##_LENGTH = length; const char *MAX_##N##_LENGTH_ERR = "HTTP element " # N  " is longer than the " # length " allowed length (was %d)"
+#define QUOTE(s) #s
+#define EXPAND_MAX_LENGTH_VALUE(s) QUOTE(s)
+#define DEF_MAX_LENGTH(N,length) const size_t MAX_##N##_LENGTH = length; const char *MAX_##N##_LENGTH_ERR = "HTTP element " # N  " is longer than the " EXPAND_MAX_LENGTH_VALUE(length) " allowed length (was %d)"
 
 /** Validates the max length of given input and throws an HttpParserError exception if over. */
 #define VALIDATE_MAX_LENGTH(len, N) if(len > MAX_##N##_LENGTH) { rb_raise(eHttpParserError, MAX_##N##_LENGTH_ERR, len); }
@@ -49,12 +52,24 @@ static VALUE global_request_path;
 
 
 /* Defines the maximum allowed lengths for various input elements.*/
+#ifndef PUMA_REQUEST_URI_MAX_LENGTH
+#define PUMA_REQUEST_URI_MAX_LENGTH (1024 * 12)
+#endif
+
+#ifndef PUMA_REQUEST_PATH_MAX_LENGTH
+#define PUMA_REQUEST_PATH_MAX_LENGTH (8192)
+#endif
+
+#ifndef PUMA_QUERY_STRING_MAX_LENGTH
+#define PUMA_QUERY_STRING_MAX_LENGTH (1024 * 10)
+#endif
+
 DEF_MAX_LENGTH(FIELD_NAME, 256);
 DEF_MAX_LENGTH(FIELD_VALUE, 80 * 1024);
-DEF_MAX_LENGTH(REQUEST_URI, 1024 * 12);
+DEF_MAX_LENGTH(REQUEST_URI, PUMA_REQUEST_URI_MAX_LENGTH);
 DEF_MAX_LENGTH(FRAGMENT, 1024); /* Don't know if this length is specified somewhere or not */
-DEF_MAX_LENGTH(REQUEST_PATH, 2048);
-DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
+DEF_MAX_LENGTH(REQUEST_PATH, PUMA_REQUEST_PATH_MAX_LENGTH);
+DEF_MAX_LENGTH(QUERY_STRING, PUMA_QUERY_STRING_MAX_LENGTH);
 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
 
 struct common_field {
@@ -111,21 +126,6 @@ static struct common_field common_http_fields[] = {
 # undef f
 };
 
-/*
- * qsort(3) and bsearch(3) improve average performance slightly, but may
- * not be worth it for lack of portability to certain platforms...
- */
-#if defined(HAVE_QSORT_BSEARCH)
-/* sort by length, then by name if there's a tie */
-static int common_field_cmp(const void *a, const void *b)
-{
-  struct common_field *cfa = (struct common_field *)a;
-  struct common_field *cfb = (struct common_field *)b;
-  signed long diff = cfa->len - cfb->len;
-  return diff ? diff : memcmp(cfa->name, cfb->name, cfa->len);
-}
-#endif /* HAVE_QSORT_BSEARCH */
-
 static void init_common_fields(void)
 {
   unsigned i;
@@ -142,28 +142,10 @@ static void init_common_fields(void)
     }
     rb_global_variable(&cf->value);
   }
-
-#if defined(HAVE_QSORT_BSEARCH)
-  qsort(common_http_fields,
-        ARRAY_SIZE(common_http_fields),
-        sizeof(struct common_field),
-        common_field_cmp);
-#endif /* HAVE_QSORT_BSEARCH */
 }
 
 static VALUE find_common_field_value(const char *field, size_t flen)
 {
-#if defined(HAVE_QSORT_BSEARCH)
-  struct common_field key;
-  struct common_field *found;
-  key.name = field;
-  key.len = (signed long)flen;
-  found = (struct common_field *)bsearch(&key, common_http_fields,
-                                         ARRAY_SIZE(common_http_fields),
-                                         sizeof(struct common_field),
-                                         common_field_cmp);
-  return found ? found->value : Qnil;
-#else /* !HAVE_QSORT_BSEARCH */
   unsigned i;
   struct common_field *cf = common_http_fields;
   for(i = 0; i < ARRAY_SIZE(common_http_fields); i++, cf++) {
@@ -171,7 +153,6 @@ static VALUE find_common_field_value(const char *field, size_t flen)
       return cf->value;
   }
   return Qnil;
-#endif /* !HAVE_QSORT_BSEARCH */
 }
 
 void http_field(puma_parser* hp, const char *field, size_t flen,
@@ -200,6 +181,8 @@ void http_field(puma_parser* hp, const char *field, size_t flen,
     f = rb_str_new(hp->buf, new_size);
   }
 
+  while (vlen > 0 && isspace(value[vlen - 1])) vlen--;
+
   /* check for duplicate header */
   v = rb_hash_aref(hp->request, f);
 
@@ -261,10 +244,10 @@ void query_string(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_query_string, val);
 }
 
-void http_version(puma_parser* hp, const char *at, size_t length)
+void server_protocol(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = rb_str_new(at, length);
-  rb_hash_aset(hp->request, global_http_version, val);
+  rb_hash_aset(hp->request, global_server_protocol, val);
 }
 
 /** Finalizes the request header to have a bunch of stuff that's
@@ -284,11 +267,18 @@ void HttpParser_free(void *data) {
   }
 }
 
-void HttpParser_mark(puma_parser* hp) {
+void HttpParser_mark(void *ptr) {
+  puma_parser *hp = ptr;
   if(hp->request) rb_gc_mark(hp->request);
   if(hp->body) rb_gc_mark(hp->body);
 }
 
+const rb_data_type_t HttpParser_data_type = {
+    "HttpParser",
+    { HttpParser_mark, HttpParser_free, 0 },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE HttpParser_alloc(VALUE klass)
 {
   puma_parser *hp = ALLOC_N(puma_parser, 1);
@@ -299,13 +289,13 @@ VALUE HttpParser_alloc(VALUE klass)
   hp->fragment = fragment;
   hp->request_path = request_path;
   hp->query_string = query_string;
-  hp->http_version = http_version;
+  hp->server_protocol = server_protocol;
   hp->header_done = header_done;
   hp->request = Qnil;
 
   puma_parser_init(hp);
 
-  return Data_Wrap_Struct(klass, HttpParser_mark, HttpParser_free, hp);
+  return TypedData_Wrap_Struct(klass, &HttpParser_data_type, hp);
 }
 
 /**
@@ -317,7 +307,7 @@ VALUE HttpParser_alloc(VALUE klass)
 VALUE HttpParser_init(VALUE self)
 {
   puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, http);
+  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
   puma_parser_init(http);
 
   return self;
@@ -334,7 +324,7 @@ VALUE HttpParser_init(VALUE self)
 VALUE HttpParser_reset(VALUE self)
 {
   puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, http);
+  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
   puma_parser_init(http);
 
   return Qnil;
@@ -351,7 +341,7 @@ VALUE HttpParser_reset(VALUE self)
 VALUE HttpParser_finish(VALUE self)
 {
   puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, http);
+  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
   puma_parser_finish(http);
 
   return puma_parser_is_finished(http) ? Qtrue : Qfalse;
@@ -382,7 +372,7 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
   char *dptr = NULL;
   long dlen = 0;
 
-  DATA_GET(self, puma_parser, http);
+  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
 
   from = FIX2INT(start);
   dptr = rb_extract_chars(data, &dlen);
@@ -398,7 +388,7 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
     VALIDATE_MAX_LENGTH(puma_parser_nread(http), HEADER);
 
     if(puma_parser_has_error(http)) {
-      rb_raise(eHttpParserError, "%s", "Invalid HTTP format, parsing fails.");
+      rb_raise(eHttpParserError, "%s", "Invalid HTTP format, parsing fails. Are you trying to open an SSL connection to a non-SSL Puma?");
     } else {
       return INT2FIX(puma_parser_nread(http));
     }
@@ -416,7 +406,7 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
 VALUE HttpParser_has_error(VALUE self)
 {
   puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, http);
+  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
 
   return puma_parser_has_error(http) ? Qtrue : Qfalse;
 }
@@ -431,7 +421,7 @@ VALUE HttpParser_has_error(VALUE self)
 VALUE HttpParser_is_finished(VALUE self)
 {
   puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, http);
+  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
 
   return puma_parser_is_finished(http) ? Qtrue : Qfalse;
 }
@@ -447,7 +437,7 @@ VALUE HttpParser_is_finished(VALUE self)
 VALUE HttpParser_nread(VALUE self)
 {
   puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, http);
+  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
 
   return INT2FIX(http->nread);
 }
@@ -460,15 +450,16 @@ VALUE HttpParser_nread(VALUE self)
  */
 VALUE HttpParser_body(VALUE self) {
   puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, http);
+  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
 
   return http->body;
 }
 
-void Init_io_buffer(VALUE puma);
+#ifdef HAVE_OPENSSL_BIO_H
 void Init_mini_ssl(VALUE mod);
+#endif
 
-void Init_puma_http11()
+void Init_puma_http11(void)
 {
 
   VALUE mPuma = rb_define_module("Puma");
@@ -478,7 +469,7 @@ void Init_puma_http11()
   DEF_GLOBAL(request_uri, "REQUEST_URI");
   DEF_GLOBAL(fragment, "FRAGMENT");
   DEF_GLOBAL(query_string, "QUERY_STRING");
-  DEF_GLOBAL(http_version, "HTTP_VERSION");
+  DEF_GLOBAL(server_protocol, "SERVER_PROTOCOL");
   DEF_GLOBAL(request_path, "REQUEST_PATH");
 
   eHttpParserError = rb_define_class_under(mPuma, "HttpParserError", rb_eIOError);
@@ -495,6 +486,7 @@ void Init_puma_http11()
   rb_define_method(cHttpParser, "body", HttpParser_body, 0);
   init_common_fields();
 
-  Init_io_buffer(mPuma);
+#ifdef HAVE_OPENSSL_BIO_H
   Init_mini_ssl(mPuma);
+#endif
 }

data/lib/puma/app/status.rb

@@ -1,73 +1,95 @@
+# frozen_string_literal: true
+require_relative '../json_serialization'
+
 module Puma
   module App
+    # Check out {#call}'s source code to see what actions this web application
+    # can respond to.
     class Status
-      def initialize(cli)
-        @cli = cli
-        @auth_token = nil
-      end
       OK_STATUS = '{ "status": "ok" }'.freeze
 
-      attr_accessor :auth_token
-
-      def authenticate(env)
-        return true unless @auth_token
-        env['QUERY_STRING'].to_s.split(/&;/).include?("token=#{@auth_token}")
-      end
-
-      def rack_response(status, body, content_type='application/json')
-        headers = {
-          'Content-Type' => content_type,
-          'Content-Length' => body.bytesize.to_s
-        }
-
-        [status, headers, [body]]
+      # @param launcher [::Puma::Launcher]
+      # @param token [String, nil] the token used for authentication
+      #
+      def initialize(launcher, token = nil)
+        @launcher = launcher
+        @auth_token = token
       end
 
+      # most commands call methods in `::Puma::Launcher` based on command in
+      # `env['PATH_INFO']`
       def call(env)
         unless authenticate(env)
           return rack_response(403, 'Invalid auth token', 'text/plain')
         end
 
-        case env['PATH_INFO']
-        when /\/stop$/
-          @cli.stop
-          return rack_response(200, OK_STATUS)
+        # resp_type is processed by following case statement, return
+        # is a number (status) or a string used as the body of a 200 response
+        resp_type =
+          case env['PATH_INFO'][/\/([^\/]+)$/, 1]
+          when 'stop'
+            @launcher.stop ; 200
 
-        when /\/halt$/
-          @cli.halt
-          return rack_response(200, OK_STATUS)
+          when 'halt'
+            @launcher.halt ; 200
 
-        when /\/restart$/
-          @cli.restart
-          return rack_response(200, OK_STATUS)
+          when 'restart'
+            @launcher.restart ; 200
 
-        when /\/phased-restart$/
-          if !@cli.phased_restart
-            return rack_response(404, '{ "error": "phased restart not available" }')
-          else
-            return rack_response(200, OK_STATUS)
-          end
+          when 'phased-restart'
+            @launcher.phased_restart ? 200 : 404
+
+          when 'refork'
+            @launcher.refork ? 200 : 404
+
+          when 'reload-worker-directory'
+            @launcher.send(:reload_worker_directory) ? 200 : 404
+
+          when 'gc'
+            GC.start ; 200
+
+          when 'gc-stats'
+            Puma::JSONSerialization.generate GC.stat
+
+          when 'stats'
+            Puma::JSONSerialization.generate @launcher.stats
+
+          when 'thread-backtraces'
+            backtraces = []
+            @launcher.thread_status do |name, backtrace|
+              backtraces << { name: name, backtrace: backtrace }
+            end
+            Puma::JSONSerialization.generate backtraces
 
-        when /\/reload-worker-directory$/
-          if !@cli.send(:reload_worker_directory)
-            return rack_response(404, '{ "error": "reload_worker_directory not available" }')
           else
-            return rack_response(200, OK_STATUS)
+            return rack_response(404, "Unsupported action", 'text/plain')
           end
 
-        when /\/gc$/
-          GC.start
-          return rack_response(200, OK_STATUS)
+        case resp_type
+        when String
+          rack_response 200, resp_type
+        when 200
+          rack_response 200, OK_STATUS
+        when 404
+          str = env['PATH_INFO'][/\/(\S+)/, 1].tr '-', '_'
+          rack_response 404, "{ \"error\": \"#{str} not available\" }"
+        end
+      end
 
-        when /\/gc-stats$/
-          json = "{" + GC.stat.map { |k, v| "\"#{k}\": #{v}" }.join(",") + "}"
-          return rack_response(200, json)
+      private
 
-        when /\/stats$/
-          return rack_response(200, @cli.stats)
-        else
-          rack_response 404, "Unsupported action", 'text/plain'
-        end
+      def authenticate(env)
+        return true unless @auth_token
+        env['QUERY_STRING'].to_s.split(/&;/).include?("token=#{@auth_token}")
+      end
+
+      def rack_response(status, body, content_type='application/json')
+        headers = {
+          'content-type' => content_type,
+          'content-length' => body.bytesize.to_s
+        }
+
+        [status, headers, [body]]
       end
     end
   end