grpc 1.64.0 → 1.65.0.pre1

data/src/core/xds/xds_client/xds_client_stats.cc

@@ -43,14 +43,14 @@ XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
                                          absl::string_view lrs_server,
                                          absl::string_view cluster_name,
                                          absl::string_view eds_service_name)
-    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(xds_client_refcount)
                      ? "XdsClusterDropStats"
                      : nullptr),
       xds_client_(std::move(xds_client)),
       lrs_server_(lrs_server),
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] created drop stats %p for {%s, %s, %s}",
             xds_client_.get(), this, std::string(lrs_server_).c_str(),
             std::string(cluster_name_).c_str(),
@@ -59,7 +59,7 @@ XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
 }
 
 XdsClusterDropStats::~XdsClusterDropStats() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] destroying drop stats %p for {%s, %s, %s}",
             xds_client_.get(), this, std::string(lrs_server_).c_str(),
@@ -96,7 +96,7 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
     RefCountedPtr<XdsClient> xds_client, absl::string_view lrs_server,
     absl::string_view cluster_name, absl::string_view eds_service_name,
     RefCountedPtr<XdsLocalityName> name)
-    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(xds_client_refcount)
                      ? "XdsClusterLocalityStats"
                      : nullptr),
       xds_client_(std::move(xds_client)),
@@ -104,24 +104,26 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name),
       name_(std::move(name)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_client %p] created locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str(),
-            name_->human_readable_string().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
+    gpr_log(
+        GPR_INFO,
+        "[xds_client %p] created locality stats %p for {%s, %s, %s, %s}",
+        xds_client_.get(), this, std::string(lrs_server_).c_str(),
+        std::string(cluster_name_).c_str(),
+        std::string(eds_service_name_).c_str(),
+        name_ == nullptr ? "<none>" : name_->human_readable_string().c_str());
   }
 }
 
 XdsClusterLocalityStats::~XdsClusterLocalityStats() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_client %p] destroying locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str(),
-            name_->human_readable_string().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
+    gpr_log(
+        GPR_INFO,
+        "[xds_client %p] destroying locality stats %p for {%s, %s, %s, %s}",
+        xds_client_.get(), this, std::string(lrs_server_).c_str(),
+        std::string(cluster_name_).c_str(),
+        std::string(eds_service_name_).c_str(),
+        name_ == nullptr ? "<none>" : name_->human_readable_string().c_str());
   }
   xds_client_->RemoveClusterLocalityStats(lrs_server_, cluster_name_,
                                           eds_service_name_, name_, this);

data/src/core/xds/xds_client/xds_client_stats.h

@@ -31,13 +31,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/per_cpu.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/telemetry/call_tracer.h"
+#include "src/core/util/useful.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 
 namespace grpc_core {

data/src/ruby/ext/grpc/rb_call.c

@@ -808,6 +808,12 @@ struct call_run_batch_args {
   run_batch_stack* st;
 };
 
+static void cancel_call_unblock_func(void* arg) {
+  gpr_log(GPR_INFO, "GRPC_RUBY: cancel_call_unblock_func");
+  grpc_call* call = (grpc_call*)arg;
+  grpc_call_cancel(call, NULL);
+}
+
 static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
   grpc_rb_fork_unsafe_begin();
   struct call_run_batch_args* args = (struct call_run_batch_args*)value_args;
@@ -830,7 +836,8 @@ static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
              grpc_call_error_detail_of(err), err);
   }
   ev = rb_completion_queue_pluck(args->call->queue, tag,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                                 gpr_inf_future(GPR_CLOCK_REALTIME),
+                                 cancel_call_unblock_func, args->call->wrapped);
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "call#run_batch failed somehow");
   }

data/src/ruby/ext/grpc/rb_completion_queue.c

@@ -35,23 +35,15 @@ typedef struct next_call_stack {
   grpc_event event;
   gpr_timespec timeout;
   void* tag;
-  volatile int interrupted;
+  void (*unblock_func)(void*);
+  void* unblock_func_arg;
 } next_call_stack;
 
 /* Calls grpc_completion_queue_pluck without holding the ruby GIL */
 static void* grpc_rb_completion_queue_pluck_no_gil(void* param) {
   next_call_stack* const next_call = (next_call_stack*)param;
-  gpr_timespec increment = gpr_time_from_millis(20, GPR_TIMESPAN);
-  gpr_timespec deadline;
-  do {
-    deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), increment);
-    next_call->event = grpc_completion_queue_pluck(
-        next_call->cq, next_call->tag, deadline, NULL);
-    if (next_call->event.type != GRPC_QUEUE_TIMEOUT ||
-        gpr_time_cmp(deadline, next_call->timeout) > 0) {
-      break;
-    }
-  } while (!next_call->interrupted);
+  next_call->event = grpc_completion_queue_pluck(next_call->cq, next_call->tag,
+                                                 next_call->timeout, NULL);
   return NULL;
 }
 
@@ -65,37 +57,28 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq) {
   grpc_completion_queue_destroy(cq);
 }
 
-static void unblock_func(void* param) {
+static void outer_unblock_func(void* param) {
   next_call_stack* const next_call = (next_call_stack*)param;
-  next_call->interrupted = 1;
+  if (next_call->unblock_func == NULL) return;
+  next_call->unblock_func(next_call->unblock_func_arg);
 }
 
 /* Does the same thing as grpc_completion_queue_pluck, while properly releasing
    the GVL and handling interrupts */
 grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
-                                     gpr_timespec deadline, void* reserved) {
+                                     gpr_timespec deadline,
+                                     void (*unblock_func)(void* param),
+                                     void* unblock_func_arg) {
   next_call_stack next_call;
   MEMZERO(&next_call, next_call_stack, 1);
   next_call.cq = queue;
   next_call.timeout = deadline;
   next_call.tag = tag;
   next_call.event.type = GRPC_QUEUE_TIMEOUT;
-  (void)reserved;
-  /* Loop until we finish a pluck without an interruption. The internal
-     pluck function runs either until it is interrupted or it gets an
-     event, or time runs out.
-
-     The basic reason we need this relatively complicated construction is that
-     we need to re-acquire the GVL when an interrupt comes in, so that the ruby
-     interpreter can do what it needs to do with the interrupt. But we also need
-     to get back to plucking when the interrupt has been handled. */
-  do {
-    next_call.interrupted = 0;
-    rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
-                               (void*)&next_call, unblock_func,
-                               (void*)&next_call);
-    /* If an interrupt prevented pluck from returning useful information, then
-       any plucks that did complete must have timed out */
-  } while (next_call.interrupted && next_call.event.type == GRPC_QUEUE_TIMEOUT);
+  next_call.unblock_func = unblock_func;
+  next_call.unblock_func_arg = unblock_func_arg;
+  rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
+                             (void*)&next_call, outer_unblock_func,
+                             (void*)&next_call);
   return next_call.event;
 }

data/src/ruby/ext/grpc/rb_completion_queue.h

@@ -29,8 +29,14 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq);
  * Makes the implementation of CompletionQueue#pluck available in other files
  *
  * This avoids having code that holds the GIL repeated at multiple sites.
+ *
+ * unblock_func is invoked with the provided argument to unblock the CQ
+ * operation in the event of process termination (e.g. a signal), but
+ * unblock_func may be NULL in which case it's unused.
  */
 grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
-                                     gpr_timespec deadline, void* reserved);
+                                     gpr_timespec deadline,
+                                     void (*unblock_func)(void* param),
+                                     void* unblock_func_arg);
 
 #endif /* GRPC_RB_COMPLETION_QUEUE_H_ */

data/src/ruby/ext/grpc/rb_server.c

@@ -49,29 +49,28 @@ typedef struct grpc_rb_server {
   /* The actual server */
   grpc_server* wrapped;
   grpc_completion_queue* queue;
-  int shutdown_and_notify_done;
   int destroy_done;
 } grpc_rb_server;
 
-static void grpc_rb_server_maybe_shutdown_and_notify(grpc_rb_server* server,
-                                                     gpr_timespec deadline) {
+static void grpc_rb_server_shutdown_and_notify_internal(grpc_rb_server* server,
+                                                        gpr_timespec deadline) {
   grpc_event ev;
   void* tag = &ev;
-  if (!server->shutdown_and_notify_done) {
-    server->shutdown_and_notify_done = 1;
-    if (server->wrapped != NULL) {
-      grpc_server_shutdown_and_notify(server->wrapped, server->queue, tag);
-      ev = rb_completion_queue_pluck(server->queue, tag, deadline, NULL);
-      if (ev.type == GRPC_QUEUE_TIMEOUT) {
-        grpc_server_cancel_all_calls(server->wrapped);
-        ev = rb_completion_queue_pluck(
-            server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
-      }
-      if (ev.type != GRPC_OP_COMPLETE) {
-        gpr_log(GPR_INFO,
-                "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:%d",
-                ev.type);
-      }
+  if (server->wrapped != NULL) {
+    grpc_server_shutdown_and_notify(server->wrapped, server->queue, tag);
+    // Following pluck calls will release the GIL and block but cannot
+    // be interrupted. They should terminate quickly enough though b/c
+    // we will cancel all server calls after the deadline.
+    ev = rb_completion_queue_pluck(server->queue, tag, deadline, NULL, NULL);
+    if (ev.type == GRPC_QUEUE_TIMEOUT) {
+      grpc_server_cancel_all_calls(server->wrapped);
+      ev = rb_completion_queue_pluck(
+          server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL, NULL);
+    }
+    if (ev.type != GRPC_OP_COMPLETE) {
+      gpr_log(GPR_INFO,
+              "GRPC_RUBY: bad grpc_server_shutdown_and_notify result:%d",
+              ev.type);
     }
   }
 }
@@ -100,7 +99,7 @@ static void grpc_rb_server_free_internal(void* p) {
   deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                           gpr_time_from_seconds(2, GPR_TIMESPAN));
 
-  grpc_rb_server_maybe_shutdown_and_notify(svr, deadline);
+  grpc_rb_server_shutdown_and_notify_internal(svr, deadline);
   grpc_rb_server_maybe_destroy(svr);
 
   xfree(p);
@@ -132,7 +131,6 @@ static VALUE grpc_rb_server_alloc(VALUE cls) {
   grpc_rb_server* wrapper = ALLOC(grpc_rb_server);
   wrapper->wrapped = NULL;
   wrapper->destroy_done = 0;
-  wrapper->shutdown_and_notify_done = 0;
   return TypedData_Wrap_Struct(cls, &grpc_rb_server_data_type, wrapper);
 }
 
@@ -192,6 +190,24 @@ struct server_request_call_args {
   request_call_stack st;
 };
 
+static void shutdown_server_unblock_func(void* arg) {
+  grpc_rb_server* server = (grpc_rb_server*)arg;
+  gpr_log(GPR_INFO, "GRPC_RUBY: shutdown_server_unblock_func");
+  GPR_ASSERT(server->wrapped != NULL);
+  grpc_event event;
+  void* tag = &event;
+  grpc_server_shutdown_and_notify(server->wrapped, server->queue, tag);
+  grpc_server_cancel_all_calls(server->wrapped);
+  // Following call is blocking, but should finish quickly since we've
+  // cancelled all calls.
+  event = grpc_completion_queue_pluck(server->queue, tag,
+                                      gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  gpr_log(GPR_INFO,
+          "GRPC_RUBY: shutdown_server_unblock_func pluck event.type: %d "
+          "event.success: %d",
+          event.type, event.success);
+}
+
 static VALUE grpc_rb_server_request_call_try(VALUE value_args) {
   grpc_rb_fork_unsafe_begin();
   struct server_request_call_args* args =
@@ -215,7 +231,8 @@ static VALUE grpc_rb_server_request_call_try(VALUE value_args) {
   }
 
   grpc_event ev = rb_completion_queue_pluck(
-      args->server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+      args->server->queue, tag, gpr_inf_future(GPR_CLOCK_REALTIME),
+      shutdown_server_unblock_func, args->server);
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "request_call completion failed");
   }
@@ -288,7 +305,7 @@ static VALUE grpc_rb_server_shutdown_and_notify(VALUE self, VALUE timeout) {
     deadline = grpc_rb_time_timeval(timeout, /* absolute time*/ 0);
   }
 
-  grpc_rb_server_maybe_shutdown_and_notify(s, deadline);
+  grpc_rb_server_shutdown_and_notify_internal(s, deadline);
 
   return Qnil;
 }

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.64.0'
+  VERSION = '1.65.0.pre1'
 end

data/third_party/boringssl-with-bazel/src/crypto/base64/base64.c

@@ -307,6 +307,10 @@ static int base64_decode_quad(uint8_t *out, size_t *out_num_bytes,
                                    (in[2] == '=') << 1 |
                                    (in[3] == '=');
 
+  // In presence of padding, the lowest bits of v are unused. Canonical encoding
+  // (RFC 4648, section 3.5) requires that these bits all be set to zero. Common
+  // PEM parsers accept noncanonical base64, adding to the malleability of the
+  // format. This decoder follows OpenSSL's and Go's PEM parsers and accepts it.
   switch (padding_pattern) {
     case 0:
       // The common case of no padding.

data/third_party/boringssl-with-bazel/src/crypto/bio/bio.c

@@ -658,38 +658,38 @@ void BIO_meth_free(BIO_METHOD *method) {
 }
 
 int BIO_meth_set_create(BIO_METHOD *method,
-                        int (*create)(BIO *)) {
-  method->create = create;
+                        int (*create_func)(BIO *)) {
+  method->create = create_func;
   return 1;
 }
 
 int BIO_meth_set_destroy(BIO_METHOD *method,
-                         int (*destroy)(BIO *)) {
-  method->destroy = destroy;
+                         int (*destroy_func)(BIO *)) {
+  method->destroy = destroy_func;
   return 1;
 }
 
 int BIO_meth_set_write(BIO_METHOD *method,
-                       int (*write)(BIO *, const char *, int)) {
-  method->bwrite = write;
+                       int (*write_func)(BIO *, const char *, int)) {
+  method->bwrite = write_func;
   return 1;
 }
 
 int BIO_meth_set_read(BIO_METHOD *method,
-                      int (*read)(BIO *, char *, int)) {
-  method->bread = read;
+                      int (*read_func)(BIO *, char *, int)) {
+  method->bread = read_func;
   return 1;
 }
 
 int BIO_meth_set_gets(BIO_METHOD *method,
-                      int (*gets)(BIO *, char *, int)) {
-  method->bgets = gets;
+                      int (*gets_func)(BIO *, char *, int)) {
+  method->bgets = gets_func;
   return 1;
 }
 
 int BIO_meth_set_ctrl(BIO_METHOD *method,
-                      long (*ctrl)(BIO *, int, long, void *)) {
-  method->ctrl = ctrl;
+                      long (*ctrl_func)(BIO *, int, long, void *)) {
+  method->ctrl = ctrl_func;
   return 1;
 }
 

data/third_party/boringssl-with-bazel/src/crypto/conf/conf.c

@@ -56,6 +56,7 @@
 
 #include <openssl/conf.h>
 
+#include <assert.h>
 #include <string.h>
 #include <ctype.h>
 
@@ -65,7 +66,6 @@
 #include <openssl/lhash.h>
 #include <openssl/mem.h>
 
-#include "conf_def.h"
 #include "internal.h"
 #include "../internal.h"
 
@@ -183,6 +183,26 @@ err:
   return NULL;
 }
 
+static int is_comment(char c) { return c == '#'; }
+
+static int is_quote(char c) { return c == '"' || c == '\'' || c == '`'; }
+
+static int is_esc(char c) { return c == '\\'; }
+
+static int is_conf_ws(char c) {
+  // This differs from |OPENSSL_isspace| in that CONF does not accept '\v' and
+  // '\f' as whitespace.
+  return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+}
+
+static int is_name_char(char c) {
+  // Alphanumeric characters, and a handful of symbols, may appear in value and
+  // section names without escaping.
+  return OPENSSL_isalnum(c) || c == '_' || c == '!' || c == '.' || c == '%' ||
+         c == '&' || c == '*' || c == '+' || c == ',' || c == '/' || c == ';' ||
+         c == '?' || c == '@' || c == '^' || c == '~' || c == '|' || c == '-';
+}
+
 static int str_copy(CONF *conf, char *section, char **pto, char *from) {
   int q, to = 0, len = 0;
   char v;
@@ -199,13 +219,13 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
   }
 
   for (;;) {
-    if (IS_QUOTE(conf, *from)) {
+    if (is_quote(*from)) {
       q = *from;
       from++;
-      while (!IS_EOF(conf, *from) && (*from != q)) {
-        if (IS_ESC(conf, *from)) {
+      while (*from != '\0' && *from != q) {
+        if (is_esc(*from)) {
           from++;
-          if (IS_EOF(conf, *from)) {
+          if (*from == '\0') {
             break;
           }
         }
@@ -214,10 +234,10 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
       if (*from == q) {
         from++;
       }
-    } else if (IS_ESC(conf, *from)) {
+    } else if (is_esc(*from)) {
       from++;
       v = *(from++);
-      if (IS_EOF(conf, v)) {
+      if (v == '\0') {
         break;
       } else if (v == 'r') {
         v = '\r';
@@ -229,11 +249,13 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
         v = '\t';
       }
       buf->data[to++] = v;
-    } else if (IS_EOF(conf, *from)) {
+    } else if (*from == '\0') {
       break;
     } else if (*from == '$') {
       // Historically, $foo would expand to a previously-parsed value. This
-      // feature has been removed as it was unused and is a DoS vector.
+      // feature has been removed as it was unused and is a DoS vector. If
+      // trying to embed '$' in a line, either escape it or wrap the value in
+      // quotes.
       OPENSSL_PUT_ERROR(CONF, CONF_R_VARIABLE_EXPANSION_NOT_SUPPORTED);
       goto err;
     } else {
@@ -312,36 +334,39 @@ static int add_string(const CONF *conf, CONF_SECTION *section,
   return 1;
 }
 
-static char *eat_ws(CONF *conf, char *p) {
-  while (IS_WS(conf, *p) && !IS_EOF(conf, *p)) {
+static char *eat_ws(char *p) {
+  while (*p != '\0' && is_conf_ws(*p)) {
     p++;
   }
   return p;
 }
 
-#define scan_esc(conf, p) (((IS_EOF((conf), (p)[1])) ? ((p) + 1) : ((p) + 2)))
+static char *scan_esc(char *p) {
+  assert(p[0] == '\\');
+  return p[1] == '\0' ? p + 1 : p + 2;
+}
 
-static char *eat_alpha_numeric(CONF *conf, char *p) {
+static char *eat_name(char *p) {
   for (;;) {
-    if (IS_ESC(conf, *p)) {
-      p = scan_esc(conf, p);
+    if (is_esc(*p)) {
+      p = scan_esc(p);
       continue;
     }
-    if (!IS_ALPHA_NUMERIC_PUNCT(conf, *p)) {
+    if (!is_name_char(*p)) {
       return p;
     }
     p++;
   }
 }
 
-static char *scan_quote(CONF *conf, char *p) {
+static char *scan_quote(char *p) {
   int q = *p;
 
   p++;
-  while (!IS_EOF(conf, *p) && *p != q) {
-    if (IS_ESC(conf, *p)) {
+  while (*p != '\0' && *p != q) {
+    if (is_esc(*p)) {
       p++;
-      if (IS_EOF(conf, *p)) {
+      if (*p == '\0') {
         return p;
       }
     }
@@ -353,28 +378,28 @@ static char *scan_quote(CONF *conf, char *p) {
   return p;
 }
 
-static void clear_comments(CONF *conf, char *p) {
+static void clear_comments(char *p) {
   for (;;) {
-    if (!IS_WS(conf, *p)) {
+    if (!is_conf_ws(*p)) {
       break;
     }
     p++;
   }
 
   for (;;) {
-    if (IS_COMMENT(conf, *p)) {
+    if (is_comment(*p)) {
       *p = '\0';
       return;
     }
-    if (IS_QUOTE(conf, *p)) {
-      p = scan_quote(conf, p);
+    if (is_quote(*p)) {
+      p = scan_quote(p);
       continue;
     }
-    if (IS_ESC(conf, *p)) {
-      p = scan_esc(conf, p);
+    if (is_esc(*p)) {
+      p = scan_esc(p);
       continue;
     }
-    if (IS_EOF(conf, *p)) {
+    if (*p == '\0') {
       return;
     } else {
       p++;
@@ -454,7 +479,7 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
       // If we have bytes and the last char '\\' and
       // second last char is not '\\'
       p = &(buff->data[bufnum - 1]);
-      if (IS_ESC(conf, p[0]) && ((bufnum <= 1) || !IS_ESC(conf, p[-1]))) {
+      if (is_esc(p[0]) && ((bufnum <= 1) || !is_esc(p[-1]))) {
         bufnum--;
         again = 1;
       }
@@ -465,20 +490,20 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
     bufnum = 0;
     buf = buff->data;
 
-    clear_comments(conf, buf);
-    s = eat_ws(conf, buf);
-    if (IS_EOF(conf, *s)) {
+    clear_comments(buf);
+    s = eat_ws(buf);
+    if (*s == '\0') {
       continue;  // blank line
     }
     if (*s == '[') {
       char *ss;
 
       s++;
-      start = eat_ws(conf, s);
+      start = eat_ws(s);
       ss = start;
     again:
-      end = eat_alpha_numeric(conf, ss);
-      p = eat_ws(conf, end);
+      end = eat_name(ss);
+      p = eat_ws(end);
       if (*p != ']') {
         if (*p != '\0' && ss != p) {
           ss = p;
@@ -502,27 +527,27 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
     } else {
       pname = s;
       psection = NULL;
-      end = eat_alpha_numeric(conf, s);
+      end = eat_name(s);
       if ((end[0] == ':') && (end[1] == ':')) {
         *end = '\0';
         end += 2;
         psection = pname;
         pname = end;
-        end = eat_alpha_numeric(conf, end);
+        end = eat_name(end);
       }
-      p = eat_ws(conf, end);
+      p = eat_ws(end);
       if (*p != '=') {
         OPENSSL_PUT_ERROR(CONF, CONF_R_MISSING_EQUAL_SIGN);
         goto err;
       }
       *end = '\0';
       p++;
-      start = eat_ws(conf, p);
-      while (!IS_EOF(conf, *p)) {
+      start = eat_ws(p);
+      while (*p != '\0') {
         p++;
       }
       p--;
-      while ((p != start) && (IS_WS(conf, *p))) {
+      while (p != start && is_conf_ws(*p)) {
         p--;
       }
       p++;