@fails-components/webtransport 0.0.1-rc.2 → 0.0.1

package/CMakeLists.txt

@@ -63,8 +63,6 @@ platform/quiche_platform_impl/quiche_prefetch_impl.h
 platform/quiche_platform_impl/quiche_server_stats_impl.h
 platform/quiche_platform_impl/simple_libuv_epoll_server.cc
 platform/quiche_platform_impl/simple_libuv_epoll_server.h
-platform/net/quiche/common/platform/impl/quiche_flags_impl.h
-platform/net/quiche/common/platform/impl/quiche_flags_impl.cc
 platform/quiche_platform_impl/quiche_mem_slice_impl.h
 platform/quiche_platform_impl/quiche_flag_utils_impl.h
 #protofiles
@@ -106,6 +104,11 @@ third_party/quiche/quiche/common/platform/api/quiche_reference_counted.h
 third_party/quiche/quiche/common/platform/api/quiche_thread_local.h
 third_party/quiche/quiche/common/platform/api/quiche_time_utils.h
 third_party/quiche/quiche/common/platform/api/quiche_url_utils.h
+third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quic_flags_impl.cc
+third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quic_flags_impl.h
+third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flag_utils_impl.h
+third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
+third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.cc
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_prefetch_impl.h
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.cc
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "0.0.1-rc.2",
+  "version": "0.0.1",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "main": "src/webtransport.js",
   "module": "src/webtransport.js",

package/platform/net/quiche/common/platform/impl/quiche_flags_impl.h

@@ -7,59 +7,6 @@
 #ifndef NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_
 #define NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_
 
-#include <cstdint>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-#include <algorithm>
-
-#include "third_party/quiche/quiche/common/platform/api/quiche_flags.h"
-#include "third_party/quiche/quiche/common/platform/api/quiche_export.h"
-#define QUIC_FLAG(flag, value) QUICHE_EXPORT_PRIVATE extern bool flag;
-#define QUIC_FLAGT(type, flag, value) QUICHE_EXPORT_PRIVATE extern type flag;
-#include "third_party/quiche/quiche/quic/core/quic_flags_list.h"
-#include "net/quiche/common/platform/impl/quic_flags_list_add.h"
-#undef QUIC_FLAG
-#undef QUIC_FLAGT
-
-inline bool GetQuicheFlagImpl(bool flag) {
-  return flag;
-}
-inline int32_t GetQuicheFlagImpl(int32_t flag) {
-  return flag;
-}
-inline int64_t GetQuicheFlagImpl(int64_t flag) {
-  return flag;
-}
-inline uint32_t GetQuicheFlagImpl(uint32_t flag) {
-  return flag;
-}
-inline uint64_t GetQuicheFlagImpl(uint64_t flag) {
-  return flag;
-}
-inline double GetQuicheFlagImpl(double flag) {
-  return flag;
-}
-inline std::string GetQuicheFlagImpl(const std::string& flag) {
-  return flag;
-}
-
-#define SetQuicheFlagImpl(flag, value) ((flag) = (value))
-
-// ------------------------------------------------------------------------
-// QUIC feature flags implementation.
-// ------------------------------------------------------------------------
-
-#define RELOADABLE_FLAG(flag) FLAGS_quic_reloadable_flag_##flag
-#define RESTART_FLAG(flag) FLAGS_quic_restart_flag_##flag
-
-#define GetQuicheReloadableFlagImpl(module, flag) \
-  GetQuicheFlag(RELOADABLE_FLAG(flag))
-#define SetQuicheReloadableFlagImpl(module, flag, value) \
-  SetQuicheFlag(RELOADABLE_FLAG(flag), value)
-#define GetQuicheRestartFlagImpl(module, flag) GetQuicheFlag(RESTART_FLAG(flag))
-#define SetQuicheRestartFlagImpl(module, flag, value) \
-  SetQuicheFlag(RESTART_FLAG(flag), value)
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h"
 
 #endif  // NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_

package/platform/quiche_platform_impl/quic_flags_impl.h

@@ -2,34 +2,8 @@
 #ifndef QUIC_FLAGS_IMPL
 #define QUIC_FLAGS_IMPL
 
-// This file is part of the QUICHE platform implementation, and is not to be
-// consumed or referenced directly by other Envoy code. It serves purely as a
-// porting layer for QUICHE.
-
-
-#include <string>
-#include <vector>
-
-#include "net/quiche/common/platform/impl/quiche_flags_impl.h"
-
-// Not wired into command-line parsing.
-#define DEFINE_QUIC_COMMAND_LINE_FLAG_IMPL(type, flag, value, help) \
-  QUICHE_DVLOG_IMPL(3) << "Type:" #type "FLAG_" #flag ": value: " << value \
-           << " help: " << help                               
-
-namespace quic {
-
-// TODO(mpwarres): implement. Lower priority since only used by QUIC command-line tools.
-inline std::vector<std::string> QuicParseCommandLineFlagsImpl(const char* /*usage*/, int /*argc*/,
-                                                              const char* const* /*argv*/) {
-  return std::vector<std::string>();
-}
-
-// TODO(mpwarres): implement. Lower priority since only used by QUIC command-line tools.
-inline void QuicPrintCommandLineFlagHelpImpl(const char* /*usage*/) {}
-
-} // namespace quic
 
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quic_flags_impl.h"
 
 
 #endif

package/platform/quiche_platform_impl/quiche_flag_utils_impl.h

@@ -5,22 +5,7 @@
 #ifndef NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_UTILS_IMPL_H_
 #define NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_UTILS_IMPL_H_
 
-#include "quiche_platform_impl/quiche_logging_impl.h"
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flag_utils_impl.h"
 
-#define QUICHE_RELOADABLE_FLAG_COUNT_IMPL(flag) \
-  QUICHE_DVLOG_IMPL(3) << "FLAG_" #flag ": reloadable"
-#define QUICHE_RELOADABLE_FLAG_COUNT_N_IMPL(flag, instance, total) \
-  QUICHE_DVLOG_IMPL(3) << "FLAG_" #flag ": reloadable, instance: " << instance \
-           << " total: " << total
-
-#define QUICHE_RESTART_FLAG_COUNT_IMPL(flag) \
-  QUICHE_DVLOG_IMPL(3) << "FLAG_" #flag ": resart"
-#define QUICHE_RESTART_FLAG_COUNT_N_IMPL(flag, instance, total) \
-  QUICHE_DVLOG_IMPL(3) << "FLAG_" #flag ": restart, instance: " << instance \
-           << " total: " << total
-
-#define QUICHE_CODE_COUNT_IMPL(flag) QUICHE_DVLOG_IMPL(3) << "FLAG_" #flag
-#define QUICHE_CODE_COUNT_N_IMPL(flag, instance, total) \
-  QUICHE_DVLOG_IMPL(3) << "FLAG_" #flag
 
 #endif  // NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_UTILS_IMPL_H_

package/platform/quiche_platform_impl/quiche_flags_impl.h

@@ -1,3 +1,8 @@
 // only for redirects
 
-#include "net/quiche/common/platform/impl/quiche_flags_impl.h"
+#ifndef NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_IMPL_H_
+#define NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_IMPL_H_
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h"
+
+#endif

package/src/http3client.cc

@@ -81,12 +81,13 @@ namespace quic
 
     Http3Client::Http3Client(Http3EventLoop *eventloop,
                              QuicSocketAddress server_address, const std::string &server_hostname,
+                             int local_port,
                              std::unique_ptr<ProofVerifier> proof_verifier,
                              std::unique_ptr<SessionCache> session_cache,
                              std::unique_ptr<QuicConnectionHelperInterface> helper)
         : server_id_(QuicServerId(server_hostname, server_address.port(), false)),
           initialized_(false),
-          local_port_(0),
+          local_port_(local_port),
           store_response_(false),
           latest_response_code_(-1),
           overflow_supported_(false),
@@ -1290,6 +1291,7 @@ namespace quic
             std::vector<WebTransportHash> serverCertificateHashes;
             std::string privkey;
             std::string hostname = "localhost";
+            int local_port = 0;
 
             v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
 
@@ -1303,6 +1305,7 @@ namespace quic
                 v8::Local<v8::String> valueProp = Nan::New("value").ToLocalChecked();
                 v8::Local<v8::String> portProp = Nan::New("port").ToLocalChecked();
                 v8::Local<v8::String> hostnameProp = Nan::New("hostname").ToLocalChecked();
+                v8::Local<v8::String> localPortProp = Nan::New("localPort").ToLocalChecked();
                 if (!obj.IsEmpty())
                 {
 
@@ -1365,6 +1368,15 @@ namespace quic
                         else
                             return Nan::ThrowError("serverCertificateHashes is not an array");
                     }
+
+                    if (Nan::HasOwnProperty(lobj, localPortProp).FromJust() && !Nan::Get(lobj, localPortProp).IsEmpty())
+                    {
+                        v8::Local<v8::Value> localPortValue = Nan::Get(lobj, localPortProp).ToLocalChecked();
+                        if (localPortValue->IsNumber())
+                            local_port = Nan::To<int>(localPortValue).FromJust();
+                        else
+                            return Nan::ThrowError("localPort is not a number");
+                    }
                 }
             }
 
@@ -1439,7 +1451,7 @@ namespace quic
                                                                             freeaddrinfo);
             address = QuicSocketAddress(info_list->ai_addr, info_list->ai_addrlen);
 
-            Http3Client *object = new Http3Client(eventloop, address, hostname,
+            Http3Client *object = new Http3Client(eventloop, address, hostname, local_port,
                                                   std::move(verifier), std::move(cache), std::move(helper));
             object->SetUserAgentID("fails-components/webtransport");
             object->Wrap(info.This());

package/src/http3client.h

@@ -48,28 +48,27 @@ namespace quic
                         public QuicClientPushPromiseIndex::Delegate,
                         public ProcessPacketInterface,
                         public Nan::ObjectWrap,
-                        public LifetimeHelper 
+                        public LifetimeHelper
     {
     public:
         Http3Client(Http3EventLoop *eventloop, QuicSocketAddress server_address,
                     const std::string &server_hostname,
+                    int local_port,
                     std::unique_ptr<ProofVerifier> proof_verifier,
                     std::unique_ptr<SessionCache> session_cache,
                     std::unique_ptr<QuicConnectionHelperInterface> helper);
 
         ~Http3Client() override;
 
-
         // From EpollCallbackInterface
         std::string Name() const override { return "Http3Client"; }
 
-        
         void OnRegistration(QuicEpollServer * /*eps*/,
                             int /*fd*/,
                             int /*event_mask*/) override;
         void OnModification(int /*fd*/, int /*event_mask*/) override;
         void OnEvent(int /*fd*/, QuicEpollEvent * /*event*/) override;
-        void OnUnregistration(int /*fd*/, bool /*replaced*/) override ;
+        void OnUnregistration(int /*fd*/, bool /*replaced*/) override;
 
         void OnShutdown(QuicEpollServer * /*eps*/, int /*fd*/) override;
 
@@ -101,12 +100,12 @@ namespace quic
         // Sends a request containing |headers| and |body| and returns the number of
         // bytes sent (the size of the serialized request headers and body).
         void SendMessageAsync(const spdy::SpdyHeaderBlock &headers,
-                            absl::string_view body);
+                              absl::string_view body);
         // Sends a request containing |headers| and |body| with the fin bit set to
         // |fin| and returns the number of bytes sent (the size of the serialized
         // request headers and body).
         void SendMessageAsync(const spdy::SpdyHeaderBlock &headers,
-                            absl::string_view body, bool fin);
+                              absl::string_view body, bool fin);
 
         void SendConnectivityProbing();
         void Connect();
@@ -152,7 +151,6 @@ namespace quic
         size_t bytes_read() const;
         size_t bytes_written() const;
 
-
         // If the client has at least one UDP socket, return the latest created one.
         // Otherwise, return -1.
         int GetLatestFD() const;
@@ -178,7 +176,7 @@ namespace quic
         const QuicSocketAddress &address() const;
 
         // Returns a newly created QuicSpdyClientStream to callback
-        void CreateClientStream(std::function<void (QuicSpdyClientStream *)> finish);
+        void CreateClientStream(std::function<void(QuicSpdyClientStream *)> finish);
 
         // From QuicSpdyStream::Visitor
         void OnClose(QuicSpdyStream *stream) override;
@@ -195,7 +193,7 @@ namespace quic
         void OnRendezvousResult(QuicSpdyStream *) override;
 
         // Returns nullptr if the maximum number of streams have already been created.
-        //QuicSpdyClientStream *GetOrCreateStream();
+        // QuicSpdyClientStream *GetOrCreateStream();
         // async replacement
         void RunOnStreamMaybeCreateStream(std::function<void(QuicSpdyClientStream *)> finish);
 
@@ -208,7 +206,6 @@ namespace quic
         QuicRstStreamErrorCode stream_error() { return stream_error_; }
         QuicErrorCode connection_error() const;
 
-
         // Get the server config map.  Server config must exist.
         const QuicTagValueMap &GetServerConfig();
 
@@ -252,7 +249,6 @@ namespace quic
 
         static NAN_METHOD(New);
 
-
         static NAN_METHOD(openWTSession);
         static NAN_METHOD(closeClient);
 
@@ -262,8 +258,8 @@ namespace quic
             return my_constructor;
         }
 
-        
-        void doUnref() override {
+        void doUnref() override
+        {
             Unref();
         }
 
@@ -326,7 +322,6 @@ namespace quic
             int64_t response_body_size;
         };
 
-
         // Index of pending promised streams. Must outlive |session_|.
         QuicClientPushPromiseIndex push_promise_index_;
 
@@ -530,7 +525,7 @@ namespace quic
         uint32_t num_attempts_connect_;
         bool webtransport_server_support_inform_;
 
-        std::queue<std::function<void (QuicSpdyClientStream *)>> finish_stream_open_;
+        std::queue<std::function<void(QuicSpdyClientStream *)>> finish_stream_open_;
     };
 
 } // namespace quic

package/src/webtransport.js

@@ -5,12 +5,15 @@
 import { existsSync } from 'fs'
 import { createRequire } from 'module'
 import { ReadableStream, WritableStream } from 'node:stream/web'
+import * as path from 'path'
+import * as url from 'url'
 
 const require = createRequire(import.meta.url)
+const dirname = url.fileURLToPath(new URL('.', import.meta.url))
 let wtpath = '../build/Release/webtransport.node'
 if (
   process.env.NODE_ENV !== 'production' &&
-  existsSync('build/Debug/webtransport.node')
+  existsSync(path.join(dirname,'../build/Debug/webtransport.node'))
 ) {
   wtpath = '../build/Debug/webtransport.node'
 }

package/third_party/boringssl/src/.clang-format

@@ -46,6 +46,7 @@ StatementMacros:
   - "IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name"
   - "IMPLEMENT_ASN1_FUNCTIONS_fname"
   - "IMPLEMENT_ASN1_FUNCTIONS_name"
+  - "IMPLEMENT_ASN1_TYPE_ex"
   - "IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS"
   - "IMPLEMENT_PEM_read"
   - "IMPLEMENT_PEM_read_bio"
@@ -65,3 +66,13 @@ StatementMacros:
   - "IMPLEMENT_PEM_write_const"
   - "IMPLEMENT_PEM_write_fp"
   - "IMPLEMENT_PEM_write_fp_const"
+  - "ASN1_ADB_END"
+  - "ASN1_CHOICE_END"
+  - "ASN1_ITEM_TEMPLATE_END"
+  - "ASN1_SEQUENCE_END"
+  - "ASN1_SEQUENCE_END_cb"
+  - "ASN1_SEQUENCE_END_enc"
+  - "ASN1_SEQUENCE_END_ref"
+  # This isn't quite right, but it causes clang-format to do a slightly better
+  # job with this macro.
+  - "ASN1_EX_TEMPLATE_TYPE"

package/third_party/boringssl/src/crypto/CMakeLists.txt

@@ -288,7 +288,6 @@ add_library(
   err/err.c
   err_data.c
   engine/engine.c
-  evp/digestsign.c
   evp/evp.c
   evp/evp_asn1.c
   evp/evp_ctx.c

package/third_party/boringssl/src/crypto/asn1/a_strex.c

@@ -64,25 +64,12 @@
 #include <openssl/bio.h>
 #include <openssl/mem.h>
 
-#include "charmap.h"
 #include "internal.h"
 
 
-// These flags must be distinct from |ESC_FLAGS| and fit in a byte.
-
-// Character is a valid PrintableString character
-#define CHARTYPE_PRINTABLESTRING 0x10
-// Character needs escaping if it is the first character
-#define CHARTYPE_FIRST_ESC_2253 0x20
-// Character needs escaping if it is the last character
-#define CHARTYPE_LAST_ESC_2253 0x40
-
-#define CHARTYPE_BS_ESC         (ASN1_STRFLGS_ESC_2253 | CHARTYPE_FIRST_ESC_2253 | CHARTYPE_LAST_ESC_2253)
-
-#define ESC_FLAGS (ASN1_STRFLGS_ESC_2253 | \
-                  ASN1_STRFLGS_ESC_QUOTE | \
-                  ASN1_STRFLGS_ESC_CTRL | \
-                  ASN1_STRFLGS_ESC_MSB)
+#define ESC_FLAGS                                                           \
+  (ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_QUOTE | ASN1_STRFLGS_ESC_CTRL | \
+   ASN1_STRFLGS_ESC_MSB)
 
 static int maybe_write(BIO *out, const void *buf, int len)
 {
@@ -90,70 +77,54 @@ static int maybe_write(BIO *out, const void *buf, int len)
     return out == NULL || BIO_write(out, buf, len) == len;
 }
 
-/*
- * This function handles display of strings, one character at a time. It is
- * passed an unsigned long for each character because it could come from 2 or
- * even 4 byte forms.
- */
-
-#define HEX_SIZE(type) (sizeof(type)*2)
-
-static int do_esc_char(uint32_t c, unsigned char flags, char *do_quotes,
-                       BIO *out)
+static int is_control_character(unsigned char c)
 {
-    unsigned char chflgs, chtmp;
-    char tmphex[HEX_SIZE(uint32_t) + 3];
+    return c < 32 || c == 127;
+}
 
+static int do_esc_char(uint32_t c, unsigned long flags, char *do_quotes,
+                       BIO *out, int is_first, int is_last)
+{
+    /* |c| is a |uint32_t| because, depending on |ASN1_STRFLGS_UTF8_CONVERT|,
+     * we may be escaping bytes or Unicode codepoints. */
+    char buf[16];  /* Large enough for "\\W01234567". */
+    unsigned char u8 = (unsigned char)c;
     if (c > 0xffff) {
-        BIO_snprintf(tmphex, sizeof tmphex, "\\W%08" PRIX32, c);
-        if (!maybe_write(out, tmphex, 10))
-            return -1;
-        return 10;
-    }
-    if (c > 0xff) {
-        BIO_snprintf(tmphex, sizeof tmphex, "\\U%04" PRIX32, c);
-        if (!maybe_write(out, tmphex, 6))
-            return -1;
-        return 6;
-    }
-    chtmp = (unsigned char)c;
-    if (chtmp > 0x7f)
-        chflgs = flags & ASN1_STRFLGS_ESC_MSB;
-    else
-        chflgs = char_type[chtmp] & flags;
-    if (chflgs & CHARTYPE_BS_ESC) {
-        /* If we don't escape with quotes, signal we need quotes */
-        if (chflgs & ASN1_STRFLGS_ESC_QUOTE) {
-            if (do_quotes)
-                *do_quotes = 1;
-            if (!maybe_write(out, &chtmp, 1))
-                return -1;
-            return 1;
+        BIO_snprintf(buf, sizeof(buf), "\\W%08" PRIX32, c);
+    } else if (c > 0xff) {
+        BIO_snprintf(buf, sizeof(buf), "\\U%04" PRIX32, c);
+    } else if ((flags & ASN1_STRFLGS_ESC_MSB) && c > 0x7f) {
+        BIO_snprintf(buf, sizeof(buf), "\\%02X", c);
+    } else if ((flags & ASN1_STRFLGS_ESC_CTRL) && is_control_character(c)) {
+        BIO_snprintf(buf, sizeof(buf), "\\%02X", c);
+    } else if (flags & ASN1_STRFLGS_ESC_2253) {
+        /* See RFC 2253, sections 2.4 and 4. */
+        if (c == '\\' || c == '"') {
+            /* Quotes and backslashes are always escaped, quoted or not. */
+            BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
+        } else if (c == ',' || c == '+' || c == '<' || c == '>' || c == ';' ||
+                   (is_first && (c == ' ' || c == '#')) ||
+                   (is_last && (c == ' '))) {
+            if (flags & ASN1_STRFLGS_ESC_QUOTE) {
+                /* No need to escape, just tell the caller to quote. */
+                if (do_quotes != NULL) {
+                    *do_quotes = 1;
+                }
+                return maybe_write(out, &u8, 1) ? 1 : -1;
+            }
+            BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
+        } else {
+            return maybe_write(out, &u8, 1) ? 1 : -1;
         }
-        if (!maybe_write(out, "\\", 1))
-            return -1;
-        if (!maybe_write(out, &chtmp, 1))
-            return -1;
-        return 2;
-    }
-    if (chflgs & (ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB)) {
-        BIO_snprintf(tmphex, 11, "\\%02X", chtmp);
-        if (!maybe_write(out, tmphex, 3))
-            return -1;
-        return 3;
-    }
-    /*
-     * If we get this far and do any escaping at all must escape the escape
-     * character itself: backslash.
-     */
-    if (chtmp == '\\' && flags & ESC_FLAGS) {
-        if (!maybe_write(out, "\\\\", 2))
-            return -1;
-        return 2;
+    } else if ((flags & ESC_FLAGS) && c == '\\') {
+        /* If any escape flags are set, also escape backslashes. */
+        BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
+    } else {
+        return maybe_write(out, &u8, 1) ? 1 : -1;
     }
-    if (!maybe_write(out, &chtmp, 1))
-        return -1;
-    return 1;
+
+    int len = strlen(buf);
+    return maybe_write(out, buf, len) ? len : -1;
 }
 
 /*
@@ -163,7 +134,7 @@ static int do_esc_char(uint32_t c, unsigned char flags, char *do_quotes,
  */
 
 static int do_buf(const unsigned char *buf, int buflen, int encoding,
-                  int utf8_convert, unsigned char flags, char *quotes, BIO *out)
+                  int utf8_convert, unsigned long flags, char *quotes, BIO *out)
 {
     /* Reject invalid UCS-4 and UCS-2 lengths without parsing. */
     switch (encoding) {
@@ -185,10 +156,7 @@ static int do_buf(const unsigned char *buf, int buflen, int encoding,
     const unsigned char *q = buf + buflen;
     int outlen = 0;
     while (p != q) {
-        unsigned char orflags = 0;
-        if (p == buf && flags & ASN1_STRFLGS_ESC_2253) {
-            orflags = CHARTYPE_FIRST_ESC_2253;
-        }
+        const int is_first = p == buf;
         /* TODO(davidben): Replace this with |cbs_get_ucs2_be|, etc., to check
          * for invalid codepoints. Before doing that, enforce it in the parser,
          * https://crbug.com/boringssl/427, so these error cases are not
@@ -224,8 +192,7 @@ static int do_buf(const unsigned char *buf, int buflen, int encoding,
             assert(0);
             return -1;
         }
-        if (p == q && flags & ASN1_STRFLGS_ESC_2253)
-            orflags = CHARTYPE_LAST_ESC_2253;
+        const int is_last = p == q;
         if (utf8_convert) {
             unsigned char utfbuf[6];
             int utflen;
@@ -237,14 +204,15 @@ static int do_buf(const unsigned char *buf, int buflen, int encoding,
                  * otherwise each character will be > 0x7f and so the
                  * character will never be escaped on first and last.
                  */
-                int len = do_esc_char(utfbuf[i], flags | orflags, quotes, out);
+                int len = do_esc_char(utfbuf[i], flags, quotes, out, is_first,
+                                      is_last);
                 if (len < 0) {
                     return -1;
                 }
                 outlen += len;
             }
         } else {
-            int len = do_esc_char(c, flags | orflags, quotes, out);
+            int len = do_esc_char(c, flags, quotes, out, is_first, is_last);
             if (len < 0) {
                 return -1;
             }
@@ -281,14 +249,14 @@ static int do_hex_dump(BIO *out, unsigned char *buf, int buflen)
  * encoding. This uses the RFC 2253 #01234 format.
  */
 
-static int do_dump(unsigned long lflags, BIO *out, const ASN1_STRING *str)
+static int do_dump(unsigned long flags, BIO *out, const ASN1_STRING *str)
 {
     if (!maybe_write(out, "#", 1)) {
         return -1;
     }
 
     /* If we don't dump DER encoding just dump content octets */
-    if (!(lflags & ASN1_STRFLGS_DUMP_DER)) {
+    if (!(flags & ASN1_STRFLGS_DUMP_DER)) {
         int outlen = do_hex_dump(out, str->data, str->length);
         if (outlen < 0) {
             return -1;
@@ -362,13 +330,11 @@ static int string_type_to_encoding(int type) {
  * an error occurred.
  */
 
-int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long lflags)
+int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags)
 {
-    /* Keep a copy of escape flags */
-    unsigned char flags = (unsigned char)(lflags & ESC_FLAGS);
     int type = str->type;
     int outlen = 0;
-    if (lflags & ASN1_STRFLGS_SHOW_TYPE) {
+    if (flags & ASN1_STRFLGS_SHOW_TYPE) {
         const char *tagname = ASN1_tag2str(type);
         outlen += strlen(tagname);
         if (!maybe_write(out, tagname, outlen) || !maybe_write(out, ":", 1))
@@ -378,21 +344,21 @@ int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long lflags)
 
     /* Decide what to do with |str|, either dump the contents or display it. */
     int encoding;
-    if (lflags & ASN1_STRFLGS_DUMP_ALL) {
+    if (flags & ASN1_STRFLGS_DUMP_ALL) {
         /* Dump everything. */
         encoding = -1;
-    } else if (lflags & ASN1_STRFLGS_IGNORE_TYPE) {
+    } else if (flags & ASN1_STRFLGS_IGNORE_TYPE) {
         /* Ignore the string type and interpret the contents as Latin-1. */
         encoding = MBSTRING_ASC;
     } else {
         encoding = string_type_to_encoding(type);
-        if (encoding == -1 && (lflags & ASN1_STRFLGS_DUMP_UNKNOWN) == 0) {
+        if (encoding == -1 && (flags & ASN1_STRFLGS_DUMP_UNKNOWN) == 0) {
             encoding = MBSTRING_ASC;
         }
     }
 
     if (encoding == -1) {
-        int len = do_dump(lflags, out, str);
+        int len = do_dump(flags, out, str);
         if (len < 0)
             return -1;
         outlen += len;
@@ -400,7 +366,7 @@ int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long lflags)
     }
 
     int utf8_convert = 0;
-    if (lflags & ASN1_STRFLGS_UTF8_CONVERT) {
+    if (flags & ASN1_STRFLGS_UTF8_CONVERT) {
         /* If the string is UTF-8, skip decoding and just interpret it as 1 byte
          * per character to avoid converting twice.
          *