From e77a83f5a5184d42cf5bb9abe9c7ad50ee453399 Mon Sep 17 00:00:00 2001 From: Alexey Orlenko Date: Fri, 31 Mar 2017 16:21:26 +0300 Subject: buffer: optimize decoding wrapped base64 data The fast base64 decoder used to switch to the slow one permanently when it saw a whitespace or other garbage character. Since the most common situation such characters may be encountered in is line-wrapped base64 data, a more profitable strategy is to decode a single 24-bit group with the slow decoder and then continue running the fast algorithm. PR-URL: https://github.com/nodejs/node/pull/12146 Ref: https://github.com/nodejs/node/issues/12114 Reviewed-By: Anna Henningsen Reviewed-By: Trevor Norris Reviewed-By: James M Snell --- src/base64.h | 69 ++++++++++++++++++++++++++++++------------------------------ 1 file changed, 35 insertions(+), 34 deletions(-) (limited to 'src/base64.h') diff --git a/src/base64.h b/src/base64.h index 92dc565e65..2e0f8e3858 100644 --- a/src/base64.h +++ b/src/base64.h @@ -52,36 +52,33 @@ extern const int8_t unbase64_table[256]; template -size_t base64_decode_slow(char* dst, size_t dstlen, - const TypeName* src, size_t srclen) { +bool base64_decode_group_slow(char* const dst, const size_t dstlen, + const TypeName* const src, const size_t srclen, + size_t* const i, size_t* const k) { uint8_t hi; uint8_t lo; - size_t i = 0; - size_t k = 0; - for (;;) { #define V(expr) \ - for (;;) { \ - const uint8_t c = src[i]; \ - lo = unbase64(c); \ - i += 1; \ - if (lo < 64) \ - break; /* Legal character. */ \ - if (c == '=' || i >= srclen) \ - return k; \ - } \ - expr; \ - if (i >= srclen) \ - return k; \ - if (k >= dstlen) \ - return k; \ - hi = lo; - V(/* Nothing. */); - V(dst[k++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4)); - V(dst[k++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2)); - V(dst[k++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0)); + for (;;) { \ + const uint8_t c = src[*i]; \ + lo = unbase64(c); \ + *i += 1; \ + if (lo < 64) \ + break; /* Legal character. */ \ + if (c == '=' || *i >= srclen) \ + return false; /* Stop decoding. */ \ + } \ + expr; \ + if (*i >= srclen) \ + return false; \ + if (*k >= dstlen) \ + return false; \ + hi = lo; + V(/* Nothing. */); + V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4)); + V(dst[(*k)++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2)); + V(dst[(*k)++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0)); #undef V - } - UNREACHABLE(); + return true; // Continue decoding. } @@ -90,8 +87,8 @@ size_t base64_decode_fast(char* const dst, const size_t dstlen, const TypeName* const src, const size_t srclen, const size_t decoded_size) { const size_t available = dstlen < decoded_size ? dstlen : decoded_size; - const size_t max_i = srclen / 4 * 4; const size_t max_k = available / 3 * 3; + size_t max_i = srclen / 4 * 4; size_t i = 0; size_t k = 0; while (i < max_i && k < max_k) { @@ -102,16 +99,20 @@ size_t base64_decode_fast(char* const dst, const size_t dstlen, unbase64(src[i + 3]); // If MSB is set, input contains whitespace or is not valid base64. if (v & 0x80808080) { - break; + const size_t old_i = i; + if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k)) + return k; + max_i = old_i + (srclen - i) / 4 * 4; // Align max_i again. + } else { + dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03); + dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F); + dst[k + 2] = ((v >> 2) & 0xC0) | ((v >> 0) & 0x3F); + i += 4; + k += 3; } - dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03); - dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F); - dst[k + 2] = ((v >> 2) & 0xC0) | ((v >> 0) & 0x3F); - i += 4; - k += 3; } if (i < srclen && k < dstlen) { - return k + base64_decode_slow(dst + k, dstlen - k, src + i, srclen - i); + base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k); } return k; } -- cgit v1.2.3