iodine 0.7.38 → 0.7.43

data/ext/iodine/fio_tls_missing.c

@@ -33,6 +33,11 @@ Feel free to copy, use and enjoy according to the license provided.
   FIO_LOG_FATAL("No supported SSL/TLS library available.");                    \
   exit(-1);
 #endif
+
+#ifndef FIO_TLS_TIMEOUT
+#define FIO_TLS_TIMEOUT 4
+#endif
+
 /* STOP deleting after this line */
 
 /* *****************************************************************************
@@ -590,6 +595,7 @@ file_missing:
  */
 void FIO_TLS_WEAK fio_tls_accept(intptr_t uuid, fio_tls_s *tls, void *udata) {
   REQUIRE_LIBRARY();
+  fio_timeout_set(uuid, FIO_TLS_TIMEOUT);
   fio_tls_attach2uuid(uuid, tls, udata, 1);
 }
 

data/ext/iodine/fio_tls_openssl.c

@@ -29,6 +29,10 @@ The SSL/TLS helper data types (can be left as is)
 #define FIO_FORCE_MALLOC_TMP 1
 #include <fio.h>
 
+#ifndef FIO_TLS_TIMEOUT
+#define FIO_TLS_TIMEOUT 4
+#endif
+
 typedef struct {
   fio_str_s private_key;
   fio_str_s public_key;
@@ -190,8 +194,12 @@ typedef struct {
 
 FIO_FUNC inline void alpn_select___task(void *t_, void *ignr_) {
   alpn_task_s *t = t_;
-  t->alpn.on_selected((fio_is_valid(t->uuid) ? t->uuid : -1),
-                      t->udata_connection, t->alpn.udata_tls);
+  if (fio_is_valid(t->uuid)) {
+    fio_timeout_set(t->uuid, 0); // remove TLS timeout
+    t->alpn.on_selected(t->uuid, t->udata_connection, t->alpn.udata_tls);
+  } else {
+    t->alpn.on_selected(-1, t->udata_connection, t->alpn.udata_tls);
+  }
   fio_free(t);
   (void)ignr_;
 }
@@ -537,19 +545,21 @@ static ssize_t fio_tls_read(intptr_t uuid, void *udata, void *buf,
   case SSL_ERROR_SSL: /* overflow */
   case SSL_ERROR_ZERO_RETURN:
     return 0;                      /* EOF */
+  case SSL_ERROR_SYSCALL:          /* allow errno to inform us */
+    break;                         /* return -1 */
   case SSL_ERROR_NONE:             /* overflow */
   case SSL_ERROR_WANT_CONNECT:     /* overflow */
   case SSL_ERROR_WANT_ACCEPT:      /* overflow */
   case SSL_ERROR_WANT_X509_LOOKUP: /* overflow */
+  case SSL_ERROR_WANT_WRITE:       /* overflow */
+  case SSL_ERROR_WANT_READ:        /* overflow */
 #ifdef SSL_ERROR_WANT_ASYNC
   case SSL_ERROR_WANT_ASYNC: /* overflow */
 #endif
-  case SSL_ERROR_WANT_WRITE: /* overflow */
-  case SSL_ERROR_WANT_READ:
   default:
+    errno = EWOULDBLOCK;
     break;
   }
-  errno = EWOULDBLOCK;
   return -1;
   (void)uuid;
 }
@@ -591,19 +601,21 @@ static ssize_t fio_tls_write(intptr_t uuid, void *udata, const void *buf,
   case SSL_ERROR_SSL: /* overflow */
   case SSL_ERROR_ZERO_RETURN:
     return 0;                      /* EOF */
+  case SSL_ERROR_SYSCALL:          /* allow errno to inform us */
+    break;                         /* return -1 */
   case SSL_ERROR_NONE:             /* overflow */
   case SSL_ERROR_WANT_CONNECT:     /* overflow */
   case SSL_ERROR_WANT_ACCEPT:      /* overflow */
   case SSL_ERROR_WANT_X509_LOOKUP: /* overflow */
+  case SSL_ERROR_WANT_WRITE:       /* overflow */
+  case SSL_ERROR_WANT_READ:        /* overflow */
 #ifdef SSL_ERROR_WANT_ASYNC
   case SSL_ERROR_WANT_ASYNC: /* overflow */
 #endif
-  case SSL_ERROR_WANT_WRITE: /* overflow */
-  case SSL_ERROR_WANT_READ:
   default:
+    errno = EWOULDBLOCK;
     break;
   }
-  errno = EWOULDBLOCK;
   return -1;
   (void)uuid;
 }
@@ -640,13 +652,20 @@ static void fio_tls_cleanup(void *udata) {
 static fio_rw_hook_s FIO_TLS_HOOKS = {
     .read = fio_tls_read,
     .write = fio_tls_write,
-    .before_close = fio_tls_before_close,
     .flush = fio_tls_flush,
+    .before_close = fio_tls_before_close,
     .cleanup = fio_tls_cleanup,
 };
 
+#define FIO_TLS_HANDSHAKE_ERROR 0
+#define FIO_TLS_HANDSHAKE_OK 1
+#define FIO_TLS_HANDSHAKE_NEED_READ 2
+#define FIO_TLS_HANDSHAKE_NEED_WRITE 4
+
 static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
+  size_t status = FIO_TLS_HANDSHAKE_ERROR;
   fio_tls_connection_s *c = udata;
+
   int ri;
   if (c->is_server) {
     ri = SSL_accept(c->ssl);
@@ -659,26 +678,29 @@ static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
     case SSL_ERROR_NONE:
       // FIO_LOG_DEBUG("SSL_accept/SSL_connect %p state: SSL_ERROR_NONE",
       //               (void *)uuid);
-      return 0;
+      status = FIO_TLS_HANDSHAKE_NEED_READ | FIO_TLS_HANDSHAKE_NEED_WRITE;
+      return status;
     case SSL_ERROR_WANT_WRITE:
       // FIO_LOG_DEBUG("SSL_accept/SSL_connect %p state: SSL_ERROR_WANT_WRITE",
       //               (void *)uuid);
-      //   fio_force_event(uuid, FIO_EVENT_ON_READY);
-      return 0;
+      status = FIO_TLS_HANDSHAKE_NEED_WRITE;
+      return status;
     case SSL_ERROR_WANT_READ:
       // FIO_LOG_DEBUG("SSL_accept/SSL_connect %p state: SSL_ERROR_WANT_READ",
       //               (void *)uuid);
-      // fio_force_event(uuid, FIO_EVENT_ON_DATA);
-      return 0;
+      status = FIO_TLS_HANDSHAKE_NEED_READ;
+      return status;
     case SSL_ERROR_SYSCALL:
-      FIO_LOG_DEBUG(
-          "SSL_accept/SSL_connect %p error: SSL_ERROR_SYSCALL, errno: %s",
-          (void *)uuid, strerror(errno));
-      // fio_force_event(uuid, FIO_EVENT_ON_DATA);
-      return 0;
+      if (errno) {
+        FIO_LOG_DEBUG(
+            "SSL_accept/SSL_connect %p error: SSL_ERROR_SYSCALL, errno: %s",
+            (void *)uuid, strerror(errno));
+      }
+      break;
     case SSL_ERROR_SSL:
-      FIO_LOG_DEBUG("SSL_accept/SSL_connect %p error: SSL_ERROR_SSL",
-                    (void *)uuid);
+      FIO_LOG_DEBUG(
+          "SSL_accept/SSL_connect %p error: SSL_ERROR_SSL (non SSL attempt?)",
+          (void *)uuid);
       break;
     case SSL_ERROR_ZERO_RETURN:
       FIO_LOG_DEBUG("SSL_accept/SSL_connect %p error: SSL_ERROR_ZERO_RETURN",
@@ -715,8 +737,9 @@ static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
                     (void *)uuid, ri);
       break;
     }
+    fio_rw_hook_replace_unsafe(uuid, &FIO_TLS_HOOKS, udata);
     fio_defer(fio_tls_delayed_close, (void *)uuid, NULL);
-    return 0;
+    return status;
   }
   if (!c->alpn_ok) {
     c->alpn_ok = 1;
@@ -745,7 +768,7 @@ static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
   } else {
     FIO_LOG_DEBUG("Something went wrong during TLS handshake for %p",
                   (void *)uuid);
-    return 0;
+    return status;
   }
   /* make sure the connection is re-added to the reactor */
   fio_force_event(uuid, FIO_EVENT_ON_DATA);
@@ -768,14 +791,18 @@ static size_t fio_tls_handshake(intptr_t uuid, void *udata) {
                   buff2);
   }
 #endif
-  return 1;
+  status = FIO_TLS_HANDSHAKE_OK;
+  return status;
 }
 
 static ssize_t fio_tls_read4handshake(intptr_t uuid, void *udata, void *buf,
                                       size_t count) {
   // FIO_LOG_DEBUG("TLS handshake from read %p", (void *)uuid);
-  if (fio_tls_handshake(uuid, udata))
+  size_t s = fio_tls_handshake(uuid, udata);
+  if (s == FIO_TLS_HANDSHAKE_OK)
     return fio_tls_read(uuid, udata, buf, count);
+  if (!s)
+    return 0;
   errno = EWOULDBLOCK;
   return -1;
 }
@@ -783,20 +810,27 @@ static ssize_t fio_tls_read4handshake(intptr_t uuid, void *udata, void *buf,
 static ssize_t fio_tls_write4handshake(intptr_t uuid, void *udata,
                                        const void *buf, size_t count) {
   // FIO_LOG_DEBUG("TLS handshake from write %p", (void *)uuid);
-  if (fio_tls_handshake(uuid, udata))
+  size_t s = fio_tls_handshake(uuid, udata);
+  if (s == FIO_TLS_HANDSHAKE_OK)
     return fio_tls_write(uuid, udata, buf, count);
+  if (!s)
+    return 0;
   errno = EWOULDBLOCK;
   return -1;
 }
 
 static ssize_t fio_tls_flush4handshake(intptr_t uuid, void *udata) {
   // FIO_LOG_DEBUG("TLS handshake from flush %p", (void *)uuid);
-  if (fio_tls_handshake(uuid, udata)) {
+  size_t s = fio_tls_handshake(uuid, udata);
+  if (s == FIO_TLS_HANDSHAKE_OK) {
     return fio_tls_flush(uuid, udata);
   }
+  if (!s)
+    return 0;
   errno = 0;
-  return 1;
+  return s | FIO_TLS_HANDSHAKE_NEED_WRITE;
 }
+
 static fio_rw_hook_s FIO_TLS_HANDSHAKE_HOOKS = {
     .read = fio_tls_read4handshake,
     .write = fio_tls_write4handshake,
@@ -967,6 +1001,7 @@ file_missing:
  */
 void FIO_TLS_WEAK fio_tls_accept(intptr_t uuid, fio_tls_s *tls, void *udata) {
   REQUIRE_LIBRARY();
+  fio_timeout_set(uuid, FIO_TLS_TIMEOUT);
   fio_tls_attach2uuid(uuid, tls, udata, 1);
 }
 
@@ -1007,6 +1042,7 @@ void FIO_TLS_WEAK fio_tls_destroy(fio_tls_s *tls) {
   cert_ary_free(&tls->sni);
   trust_ary_free(&tls->trust);
   free(tls);
+  FIO_LOG_DEBUG("freed TLS context %p", (void *)tls);
 }
 
 #endif /* Library compiler flags */

data/ext/iodine/http.c

@@ -874,19 +874,23 @@ static uint8_t fio_http_at_capa = 0;
 
 static void http_on_server_protocol_http1(intptr_t uuid, void *set,
                                           void *ignr_) {
-  fio_timeout_set(uuid, ((http_settings_s *)set)->timeout);
-  if (fio_uuid2fd(uuid) >= ((http_settings_s *)set)->max_clients) {
-    if (!fio_http_at_capa)
-      FIO_LOG_WARNING("HTTP server at capacity");
-    fio_http_at_capa = 1;
-    http_send_error2(uuid, 503, set);
-    fio_close(uuid);
+  if ((unsigned int)fio_uuid2fd(uuid) >=
+      ((http_settings_s *)set)->max_clients) {
+    if (fio_uuid2fd(uuid) != -1) {
+      if (!fio_http_at_capa)
+        FIO_LOG_WARNING("HTTP server at capacity");
+      fio_http_at_capa = 1;
+      http_send_error2(uuid, 503, set);
+      fio_close(uuid);
+    }
     return;
   }
   fio_http_at_capa = 0;
   fio_protocol_s *pr = http1_new(uuid, set, NULL, 0);
   if (!pr)
     fio_close(uuid);
+  else
+    fio_timeout_set(uuid, ((http_settings_s *)set)->timeout);
   (void)ignr_;
 }
 
@@ -2089,111 +2093,94 @@ See the libc `gmtime_r` documentation for details.
 
 Falls back to `gmtime_r` for dates before epoch.
 */
-struct tm *http_gmtime(time_t timer, struct tm *tmbuf) {
-  // static char* DAYS[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri",
-  // "Sat"}; static char * Months = {  "Jan", "Feb", "Mar", "Apr", "May",
-  // "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-  static const uint8_t month_len[] = {
-      31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, // nonleap year
-      31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // leap year
-  };
-  if (timer < 0)
-    return gmtime_r(&timer, tmbuf);
+struct tm *http_gmtime(time_t timer, struct tm *tm) {
   ssize_t a, b;
-#if HAVE_TM_TM_ZONE
-  *tmbuf = (struct tm){
+#if HAVE_TM_TM_ZONE || defined(BSD)
+  *tm = (struct tm){
       .tm_isdst = 0,
-      .tm_year = 70, // tm_year == The number of years since 1900
-      .tm_mon = 0,
-      .tm_zone = "UTC",
+      .tm_zone = (char *)"UTC",
   };
 #else
-  *tmbuf = (struct tm){
+  *tm = (struct tm){
       .tm_isdst = 0,
-      .tm_year = 70, // tm_year == The number of years since 1900
-      .tm_mon = 0,
   };
 #endif
-  // for seconds up to weekdays, we build up, as small values clean up
-  // larger values.
-  a = (ssize_t)timer;
-  b = a / 60;
-  tmbuf->tm_sec = a - (b * 60);
-  a = b / 60;
-  tmbuf->tm_min = b - (a * 60);
-  b = a / 24;
-  tmbuf->tm_hour = a - (b * 24);
-  // day of epoch was a thursday. Add + 4 so sunday == 0...
-  tmbuf->tm_wday = (b + 4) % 7;
-// tmp == number of days since epoch
-#define DAYS_PER_400_YEARS ((400 * 365) + 97)
-  while (b >= DAYS_PER_400_YEARS) {
-    tmbuf->tm_year += 400;
-    b -= DAYS_PER_400_YEARS;
-  }
-#undef DAYS_PER_400_YEARS
-#define DAYS_PER_100_YEARS ((100 * 365) + 24)
-  while (b >= DAYS_PER_100_YEARS) {
-    tmbuf->tm_year += 100;
-    b -= DAYS_PER_100_YEARS;
-    if (((tmbuf->tm_year / 100) & 3) ==
-        0) // leap century divisable by 400 => add leap
+
+  // convert seconds from epoch to days from epoch + extract data
+  if (timer >= 0) {
+    // for seconds up to weekdays, we reduce the reminder every step.
+    a = (ssize_t)timer;
+    b = a / 60; // b == time in minutes
+    tm->tm_sec = a - (b * 60);
+    a = b / 60; // b == time in hours
+    tm->tm_min = b - (a * 60);
+    b = a / 24; // b == time in days since epoch
+    tm->tm_hour = a - (b * 24);
+    // b == number of days since epoch
+    // day of epoch was a thursday. Add + 4 so sunday == 0...
+    tm->tm_wday = (b + 4) % 7;
+  } else {
+    // for seconds up to weekdays, we reduce the reminder every step.
+    a = (ssize_t)timer;
+    b = a / 60; // b == time in minutes
+    if (b * 60 != a) {
+      /* seconds passed */
+      tm->tm_sec = (a - (b * 60)) + 60;
       --b;
-  }
-#undef DAYS_PER_100_YEARS
-#define DAYS_PER_32_YEARS ((32 * 365) + 8)
-  while (b >= DAYS_PER_32_YEARS) {
-    tmbuf->tm_year += 32;
-    b -= DAYS_PER_32_YEARS;
-  }
-#undef DAYS_PER_32_YEARS
-#define DAYS_PER_8_YEARS ((8 * 365) + 2)
-  while (b >= DAYS_PER_8_YEARS) {
-    tmbuf->tm_year += 8;
-    b -= DAYS_PER_8_YEARS;
-  }
-#undef DAYS_PER_8_YEARS
-#define DAYS_PER_4_YEARS ((4 * 365) + 1)
-  while (b >= DAYS_PER_4_YEARS) {
-    tmbuf->tm_year += 4;
-    b -= DAYS_PER_4_YEARS;
-  }
-#undef DAYS_PER_4_YEARS
-  while (b >= 365) {
-    tmbuf->tm_year += 1;
-    b -= 365;
-    if ((tmbuf->tm_year & 3) == 0) { // leap year
-      if (b > 0) {
-        --b;
-        continue;
-      } else {
-        b += 365;
-        --tmbuf->tm_year;
-        break;
-      }
+    } else {
+      /* no seconds */
+      tm->tm_sec = 0;
     }
-  }
-  b++; /* day 1 of the year is 1, not 0. */
-  tmbuf->tm_yday = b;
-  if ((tmbuf->tm_year & 3) == 1) {
-    // regular year
-    for (size_t i = 0; i < 12; i++) {
-      if (b <= month_len[i])
-        break;
-      b -= month_len[i];
-      ++tmbuf->tm_mon;
+    a = b / 60; // b == time in hours
+    if (a * 60 != b) {
+      /* minutes passed */
+      tm->tm_min = (b - (a * 60)) + 60;
+      --a;
+    } else {
+      /* no minutes */
+      tm->tm_min = 0;
     }
-  } else {
-    // leap year
-    for (size_t i = 12; i < 24; i++) {
-      if (b <= month_len[i])
-        break;
-      b -= month_len[i];
-      ++tmbuf->tm_mon;
+    b = a / 24; // b == time in days since epoch?
+    if (b * 24 != a) {
+      /* hours passed */
+      tm->tm_hour = (a - (b * 24)) + 24;
+      --b;
+    } else {
+      /* no hours */
+      tm->tm_hour = 0;
     }
+    // day of epoch was a thursday. Add + 4 so sunday == 0...
+    tm->tm_wday = ((b - 3) % 7);
+    if (tm->tm_wday)
+      tm->tm_wday += 7;
+    /* b == days from epoch */
   }
-  tmbuf->tm_mday = b;
-  return tmbuf;
+
+  // at this point we can apply the algorithm described here:
+  // http://howardhinnant.github.io/date_algorithms.html#civil_from_days
+  // Credit to Howard Hinnant.
+  {
+    b += 719468L; // adjust to March 1st, 2000 (post leap of 400 year era)
+    // 146,097 = days in era (400 years)
+    const size_t era = (b >= 0 ? b : b - 146096) / 146097;
+    const uint32_t doe = (b - (era * 146097)); // day of era
+    const uint16_t yoe =
+        (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; // year of era
+    a = yoe;
+    a += era * 400; // a == year number, assuming year starts on March 1st...
+    const uint16_t doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    const uint16_t mp = (5U * doy + 2) / 153;
+    const uint16_t d = doy - (153U * mp + 2) / 5 + 1;
+    const uint8_t m = mp + (mp < 10 ? 2 : -10);
+    a += (m <= 1);
+    tm->tm_year = a - 1900; // tm_year == years since 1900
+    tm->tm_mon = m;
+    tm->tm_mday = d;
+    const uint8_t is_leap = (a % 4 == 0 && (a % 100 != 0 || a % 400 == 0));
+    tm->tm_yday = (doy + (is_leap) + 28 + 31) % (365 + is_leap);
+  }
+
+  return tm;
 }
 
 static const char *DAY_NAMES[] = {"Sun", "Mon", "Tue", "Wed",