Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	base64-inl.h	Lines:	82	83	98.8 %
Date:	2022-12-31 04:22:30	Branches:	62	71	87.3 %


#ifndef SRC_BASE64_INL_H_
#define SRC_BASE64_INL_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "base64.h"
#include "libbase64.h"
#include "util.h"

namespace node {

static constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                           "abcdefghijklmnopqrstuvwxyz"
                                           "0123456789-_";

extern const int8_t unbase64_table[256];


inline static int8_t unbase64(uint8_t x) {
  return unbase64_table[x];
}


inline uint32_t ReadUint32BE(const unsigned char* p) {
  return static_cast<uint32_t>(p[0] << 24U) |
         static_cast<uint32_t>(p[1] << 16U) |
         static_cast<uint32_t>(p[2] << 8U) |
         static_cast<uint32_t>(p[3]);
}

#ifdef _MSC_VER
#pragma warning(push)
// MSVC C4003: not enough actual parameters for macro 'identifier'
#pragma warning(disable : 4003)
#endif

template <typename TypeName>
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;
#define V(expr)                                                                \
  for (;;) {                                                                   \
    const uint8_t c = static_cast<uint8_t>(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
  return true;  // Continue decoding.
}

#ifdef _MSC_VER
#pragma warning(pop)
#endif

template <typename TypeName>
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_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) {
    const unsigned char txt[] = {
        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
    };

    const uint32_t v = ReadUint32BE(txt);
    // If MSB is set, input contains whitespace or is not valid base64.
    if (v & 0x80808080) {
      if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
        return k;
      max_i = 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;
    }
  }
  if (i < srclen && k < dstlen) {
    base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
  }
  return k;
}


template <typename TypeName>
size_t base64_decoded_size(const TypeName* src, size_t size) {
  // 1-byte input cannot be decoded
  if (size < 2)
    return 0;

  if (src[size - 1] == '=') {
    size--;
    if (src[size - 1] == '=')
      size--;
  }
  return base64_decoded_size_fast(size);
}


template <typename TypeName>
size_t base64_decode(char* const dst, const size_t dstlen,
                     const TypeName* const src, const size_t srclen) {
  const size_t decoded_size = base64_decoded_size(src, srclen);
  return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
}


inline size_t base64_encode(const char* src,
                            size_t slen,
                            char* dst,
                            size_t dlen,
                            Base64Mode mode) {
  // We know how much we'll write, just make sure that there's space.
  CHECK(dlen >= base64_encoded_size(slen, mode) &&
        "not enough space provided for base64 encode");

  dlen = base64_encoded_size(slen, mode);

  if (mode == Base64Mode::NORMAL) {
    ::base64_encode(src, slen, dst, &dlen, 0);
    return dlen;
  }

  unsigned a;
  unsigned b;
  unsigned c;
  unsigned i;
  unsigned k;
  unsigned n;

  const char* table = base64_table_url;

  i = 0;
  k = 0;
  n = slen / 3 * 3;

  while (i < n) {
    a = src[i + 0] & 0xff;
    b = src[i + 1] & 0xff;
    c = src[i + 2] & 0xff;

    dst[k + 0] = table[a >> 2];
    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
    dst[k + 3] = table[c & 0x3f];

    i += 3;
    k += 4;
  }

  switch (slen - n) {
    case 1:
      a = src[i + 0] & 0xff;
      dst[k + 0] = table[a >> 2];
      dst[k + 1] = table[(a & 3) << 4];
      break;
    case 2:
      a = src[i + 0] & 0xff;
      b = src[i + 1] & 0xff;
      dst[k + 0] = table[a >> 2];
      dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
      dst[k + 2] = table[(b & 0x0f) << 2];
      break;
  }

  return dlen;
}

}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_BASE64_INL_H_


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#ifndef SRC_BASE64_INL_H_
2			#define SRC_BASE64_INL_H_
3
4			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6			#include "base64.h"
7			#include "libbase64.h"
8			#include "util.h"
9
10			namespace node {
11
12			static constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
13			"abcdefghijklmnopqrstuvwxyz"
14			"0123456789-_";
15
16			extern const int8_t unbase64_table[256];
17
18
19		18672954	inline static int8_t unbase64(uint8_t x) {
20		18672954	return unbase64_table[x];
21			}
22
23
24		4666108	inline uint32_t ReadUint32BE(const unsigned char* p) {
25		9332216	return static_cast<uint32_t>(p[0] << 24U) \|
26		9332216	static_cast<uint32_t>(p[1] << 16U) \|
27		4666108	static_cast<uint32_t>(p[2] << 8U) \|
28		4666108	static_cast<uint32_t>(p[3]);
29			}
30
31			#ifdef _MSC_VER
32			#pragma warning(push)
33			// MSVC C4003: not enough actual parameters for macro 'identifier'
34			#pragma warning(disable : 4003)
35			#endif
36
37			template <typename TypeName>
38		6921	bool base64_decode_group_slow(char* const dst, const size_t dstlen,
39			const TypeName* const src, const size_t srclen,
40			size_t* const i, size_t* const k) {
41			uint8_t hi;
42			uint8_t lo;
43			#define V(expr) \
44			for (;;) { \
45			const uint8_t c = static_cast<uint8_t>(src[*i]); \
46			lo = unbase64(c); \
47			*i += 1; \
48			if (lo < 64) break; /* Legal character. */ \
49			if (c == '=' \|\| i >= srclen) return false; / Stop decoding. */ \
50			} \
51			expr; \
52			if (*i >= srclen) return false; \
53			if (*k >= dstlen) return false; \
54			hi = lo;
55	✓✓✓✓ ✓✓✗✓ ✗✓	6921	V(/* Nothing. */);
56	✓✓✓✗ ✗✓✓✓ ✓✓	6743	V(dst[(*k)++] = ((hi & 0x3F) << 2) \| ((lo & 0x30) >> 4));
57	✓✓✓✓ ✓✓✓✓ ✓✓	3239	V(dst[(*k)++] = ((hi & 0x0F) << 4) \| ((lo & 0x3C) >> 2));
58	✓✓✓✓ ✗✓✓✓ ✗✓	168	V(dst[(*k)++] = ((hi & 0x03) << 6) \| ((lo & 0x3F) >> 0));
59			#undef V
60		120	return true; // Continue decoding.
61			}
62
63			#ifdef _MSC_VER
64			#pragma warning(pop)
65			#endif
66
67			template <typename TypeName>
68		8498	size_t base64_decode_fast(char* const dst, const size_t dstlen,
69			const TypeName* const src, const size_t srclen,
70			const size_t decoded_size) {
71	✓✓	8498	const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
72		8498	const size_t max_k = available / 3 * 3;
73		8498	size_t max_i = srclen / 4 * 4;
74		8498	size_t i = 0;
75		8498	size_t k = 0;
76	✓✓✓✓	9339997	while (i < max_i && k < max_k) {
77		37326200	const unsigned char txt[] = {
78		9331550	static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
79		9331550	static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
80		9331550	static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
81		9331550	static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
82			};
83
84		9331550	const uint32_t v = ReadUint32BE(txt);
85			// If MSB is set, input contains whitespace or is not valid base64.
86	✓✓	9331550	if (v & 0x80808080) {
87	✓✓	171	if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
88		51	return k;
89		120	max_i = i + (srclen - i) / 4 * 4; // Align max_i again.
90			} else {
91		9331379	dst[k + 0] = ((v >> 22) & 0xFC) \| ((v >> 20) & 0x03);
92		9331379	dst[k + 1] = ((v >> 12) & 0xF0) \| ((v >> 10) & 0x0F);
93		9331379	dst[k + 2] = ((v >> 2) & 0xC0) \| ((v >> 0) & 0x3F);
94		9331379	i += 4;
95		9331379	k += 3;
96			}
97			}
98	✓✓✓✓	8447	if (i < srclen && k < dstlen) {
99		6562	base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
100			}
101		8447	return k;
102			}
103
104
105			template <typename TypeName>
106		14940	size_t base64_decoded_size(const TypeName* src, size_t size) {
107			// 1-byte input cannot be decoded
108	✗✓	14940	if (size < 2)
109			return 0;
110
111	✓✓	14940	if (src[size - 1] == '=') {
112		1444	size--;
113	✓✓	1444	if (src[size - 1] == '=')
114		918	size--;
115			}
116		14940	return base64_decoded_size_fast(size);
117			}
118
119
120			template <typename TypeName>
121		8498	size_t base64_decode(char* const dst, const size_t dstlen,
122			const TypeName* const src, const size_t srclen) {
123		8498	const size_t decoded_size = base64_decoded_size(src, srclen);
124		8498	return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
125			}
126
127
128		5692	inline size_t base64_encode(const char* src,
129			size_t slen,
130			char* dst,
131			size_t dlen,
132			Base64Mode mode) {
133			// We know how much we'll write, just make sure that there's space.
134	✗✓✗✓	5692	CHECK(dlen >= base64_encoded_size(slen, mode) &&
135			"not enough space provided for base64 encode");
136
137		5692	dlen = base64_encoded_size(slen, mode);
138
139	✓✓	5692	if (mode == Base64Mode::NORMAL) {
140		1965	::base64_encode(src, slen, dst, &dlen, 0);
141		1965	return dlen;
142			}
143
144			unsigned a;
145			unsigned b;
146			unsigned c;
147			unsigned i;
148			unsigned k;
149			unsigned n;
150
151		3727	const char* table = base64_table_url;
152
153		3727	i = 0;
154		3727	k = 0;
155		3727	n = slen / 3 * 3;
156
157	✓✓	100151	while (i < n) {
158		96424	a = src[i + 0] & 0xff;
159		96424	b = src[i + 1] & 0xff;
160		96424	c = src[i + 2] & 0xff;
161
162		96424	dst[k + 0] = table[a >> 2];
163		96424	dst[k + 1] = table[((a & 3) << 4) \| (b >> 4)];
164		96424	dst[k + 2] = table[((b & 0x0f) << 2) \| (c >> 6)];
165		96424	dst[k + 3] = table[c & 0x3f];
166
167		96424	i += 3;
168		96424	k += 4;
169			}
170
171	✓✓✓	3727	switch (slen - n) {
172		1333	case 1:
173		1333	a = src[i + 0] & 0xff;
174		1333	dst[k + 0] = table[a >> 2];
175		1333	dst[k + 1] = table[(a & 3) << 4];
176		1333	break;
177		1173	case 2:
178		1173	a = src[i + 0] & 0xff;
179		1173	b = src[i + 1] & 0xff;
180		1173	dst[k + 0] = table[a >> 2];
181		1173	dst[k + 1] = table[((a & 3) << 4) \| (b >> 4)];
182		1173	dst[k + 2] = table[(b & 0x0f) << 2];
183		1173	break;
184			}
185
186		3727	return dlen;
187			}
188
189			} // namespace node
190
191			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
192
193			#endif // SRC_BASE64_INL_H_