GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing github.com — src: create helper for reading Uint32BE · nodejs/node@f230039

File tree

Expand file treeCollapse file tree

Open diff view settings

Filter options

node.gyp
src

Expand file treeCollapse file tree

Open diff view settings

Collapse file

`‎node.gyp‎`

Copy file name to clipboardExpand all lines: node.gyp

+1Lines changed: 1 addition & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -656,6 +656,7 @@`
`656`	`656`	`'src/base_object.h',`
`657`	`657`	`'src/base_object-inl.h',`
`658`	`658`	`'src/base64.h',`
	`659`	`+ 'src/base64-inl.h',`
`659`	`660`	`'src/callback_queue.h',`
`660`	`661`	`'src/callback_queue-inl.h',`
`661`	`662`	`'src/connect_wrap.h',`

Collapse file

`‎src/base64-inl.h‎`

Copy file name to clipboard

+98Lines changed: 98 additions & 0 deletions

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,98 @@`
	`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 "util.h"`
	`7`	`+`
	`8`	`+namespace node {`
	`9`	`+`
	`10`	`+extern const int8_t unbase64_table[256];`
	`11`	`+`
	`12`	`+`
	`13`	`+inline static int8_t unbase64(uint8_t x) {`
	`14`	`+ return unbase64_table[x];`
	`15`	`+}`
	`16`	`+`
	`17`	`+`
	`18`	`+inline uint32_t ReadUint32BE(const unsigned char* p) {`
	`19`	`+ return static_cast<uint32_t>(p[0] << 24U) \|`
	`20`	`+ static_cast<uint32_t>(p[1] << 16U) \|`
	`21`	`+ static_cast<uint32_t>(p[2] << 8U) \|`
	`22`	`+ static_cast<uint32_t>(p[3]);`
	`23`	`+}`
	`24`	`+`
	`25`	`+`
	`26`	`+template <typename TypeName>`
	`27`	`+bool base64_decode_group_slow(char* const dst, const size_t dstlen,`
	`28`	`+ const TypeName* const src, const size_t srclen,`
	`29`	`+ size_t* const i, size_t* const k) {`
	`30`	`+ uint8_t hi;`
	`31`	`+ uint8_t lo;`
	`32`	`+#define V(expr) \`
	`33`	`+ for (;;) { \`
	`34`	`+ const uint8_t c = src[*i]; \`
	`35`	`+ lo = unbase64(c); \`
	`36`	`+ *i += 1; \`
	`37`	`+ if (lo < 64) \`
	`38`	`+ break; /* Legal character. */ \`
	`39`	`+ if (c == '=' \|\| *i >= srclen) \`
	`40`	`+ return false; /* Stop decoding. */ \`
	`41`	`+ } \`
	`42`	`+ expr; \`
	`43`	`+ if (*i >= srclen) \`
	`44`	`+ return false; \`
	`45`	`+ if (*k >= dstlen) \`
	`46`	`+ return false; \`
	`47`	`+ hi = lo;`
	`48`	`+ V(/* Nothing. */);`
	`49`	`+ V(dst[(*k)++] = ((hi & 0x3F) << 2) \| ((lo & 0x30) >> 4));`
	`50`	`+ V(dst[(*k)++] = ((hi & 0x0F) << 4) \| ((lo & 0x3C) >> 2));`
	`51`	`+ V(dst[(*k)++] = ((hi & 0x03) << 6) \| ((lo & 0x3F) >> 0));`
	`52`	`+#undef V`
	`53`	`+ return true; // Continue decoding.`
	`54`	`+}`
	`55`	`+`
	`56`	`+`
	`57`	`+template <typename TypeName>`
	`58`	`+size_t base64_decode_fast(char* const dst, const size_t dstlen,`
	`59`	`+ const TypeName* const src, const size_t srclen,`
	`60`	`+ const size_t decoded_size) {`
	`61`	`+ const size_t available = dstlen < decoded_size ? dstlen : decoded_size;`
	`62`	`+ const size_t max_k = available / 3 * 3;`
	`63`	`+ size_t max_i = srclen / 4 * 4;`
	`64`	`+ size_t i = 0;`
	`65`	`+ size_t k = 0;`
	`66`	`+ while (i < max_i && k < max_k) {`
	`67`	`+ const unsigned char txt[] = {`
	`68`	`+ static_cast<unsigned char>(unbase64(src[i + 0])),`
	`69`	`+ static_cast<unsigned char>(unbase64(src[i + 1])),`
	`70`	`+ static_cast<unsigned char>(unbase64(src[i + 2])),`
	`71`	`+ static_cast<unsigned char>(unbase64(src[i + 3])),`
	`72`	`+ };`
	`73`	`+`
	`74`	`+ const uint32_t v = ReadUint32BE(txt);`
	`75`	`+ // If MSB is set, input contains whitespace or is not valid base64.`
	`76`	`+ if (v & 0x80808080) {`
	`77`	`+ if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))`
	`78`	`+ return k;`
	`79`	`+ max_i = i + (srclen - i) / 4 * 4; // Align max_i again.`
	`80`	`+ } else {`
	`81`	`+ dst[k + 0] = ((v >> 22) & 0xFC) \| ((v >> 20) & 0x03);`
	`82`	`+ dst[k + 1] = ((v >> 12) & 0xF0) \| ((v >> 10) & 0x0F);`
	`83`	`+ dst[k + 2] = ((v >> 2) & 0xC0) \| ((v >> 0) & 0x3F);`
	`84`	`+ i += 4;`
	`85`	`+ k += 3;`
	`86`	`+ }`
	`87`	`+ }`
	`88`	`+ if (i < srclen && k < dstlen) {`
	`89`	`+ base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);`
	`90`	`+ }`
	`91`	`+ return k;`
	`92`	`+}`
	`93`	`+`
	`94`	`+} // namespace node`
	`95`	`+`
	`96`	`+#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS`
	`97`	`+`
	`98`	`+#endif // SRC_BASE64_INL_H_`

Collapse file

`‎src/base64.h‎`

Copy file name to clipboardExpand all lines: src/base64.h

+3-75Lines changed: 3 additions & 75 deletions

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS`
`5`	`5`
`6`	`6`	`#include "util.h"`
	`7`	`+#include "base64-inl.h"`
`7`	`8`
`8`	`9`	`#include <cstddef>`
`9`	`10`	`#include <cstdint>`
`@@ -20,6 +21,8 @@ static inline constexpr size_t base64_decoded_size_fast(size_t size) {`
`20`	`21`	`return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;`
`21`	`22`	`}`
`22`	`23`
	`24`	`+inline uint32_t ReadUint32BE(const unsigned char* p);`
	`25`	`+`
`23`	`26`	`template <typename TypeName>`
`24`	`27`	`size_t base64_decoded_size(const TypeName* src, size_t size) {`
`25`	`28`	`// 1-byte input cannot be decoded`
`@@ -34,81 +37,6 @@ size_t base64_decoded_size(const TypeName* src, size_t size) {`
`34`	`37`	`return base64_decoded_size_fast(size);`
`35`	`38`	`}`
`36`	`39`
`37`		`-`
`38`		`-extern const int8_t unbase64_table[256];`
`39`		`-`
`40`		`-`
`41`		`-inline static int8_t unbase64(uint8_t x) {`
`42`		`- return unbase64_table[x];`
`43`		`-}`
`44`		`-`
`45`		`-`
`46`		`-template <typename TypeName>`
`47`		`-bool base64_decode_group_slow(char* const dst, const size_t dstlen,`
`48`		`- const TypeName* const src, const size_t srclen,`
`49`		`- size_t* const i, size_t* const k) {`
`50`		`- uint8_t hi;`
`51`		`- uint8_t lo;`
`52`		`-#define V(expr) \`
`53`		`- for (;;) { \`
`54`		`- const uint8_t c = src[*i]; \`
`55`		`- lo = unbase64(c); \`
`56`		`- *i += 1; \`
`57`		`- if (lo < 64) \`
`58`		`- break; /* Legal character. */ \`
`59`		`- if (c == '=' \|\| *i >= srclen) \`
`60`		`- return false; /* Stop decoding. */ \`
`61`		`- } \`
`62`		`- expr; \`
`63`		`- if (*i >= srclen) \`
`64`		`- return false; \`
`65`		`- if (*k >= dstlen) \`
`66`		`- return false; \`
`67`		`- hi = lo;`
`68`		`- V(/* Nothing. */);`
`69`		`- V(dst[(*k)++] = ((hi & 0x3F) << 2) \| ((lo & 0x30) >> 4));`
`70`		`- V(dst[(*k)++] = ((hi & 0x0F) << 4) \| ((lo & 0x3C) >> 2));`
`71`		`- V(dst[(*k)++] = ((hi & 0x03) << 6) \| ((lo & 0x3F) >> 0));`
`72`		`-#undef V`
`73`		`- return true; // Continue decoding.`
`74`		`-}`
`75`		`-`
`76`		`-`
`77`		`-template <typename TypeName>`
`78`		`-size_t base64_decode_fast(char* const dst, const size_t dstlen,`
`79`		`- const TypeName* const src, const size_t srclen,`
`80`		`- const size_t decoded_size) {`
`81`		`- const size_t available = dstlen < decoded_size ? dstlen : decoded_size;`
`82`		`- const size_t max_k = available / 3 * 3;`
`83`		`- size_t max_i = srclen / 4 * 4;`
`84`		`- size_t i = 0;`
`85`		`- size_t k = 0;`
`86`		`- while (i < max_i && k < max_k) {`
`87`		`- const uint32_t v =`
`88`		`- unbase64(src[i + 0]) << 24 \|`
`89`		`- unbase64(src[i + 1]) << 16 \|`
`90`		`- unbase64(src[i + 2]) << 8 \|`
`91`		`- unbase64(src[i + 3]);`
`92`		`- // If MSB is set, input contains whitespace or is not valid base64.`
`93`		`- if (v & 0x80808080) {`
`94`		`- if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))`
`95`		`- return k;`
`96`		`- max_i = i + (srclen - i) / 4 * 4; // Align max_i again.`
`97`		`- } else {`
`98`		`- dst[k + 0] = ((v >> 22) & 0xFC) \| ((v >> 20) & 0x03);`
`99`		`- dst[k + 1] = ((v >> 12) & 0xF0) \| ((v >> 10) & 0x0F);`
`100`		`- dst[k + 2] = ((v >> 2) & 0xC0) \| ((v >> 0) & 0x3F);`
`101`		`- i += 4;`
`102`		`- k += 3;`
`103`		`- }`
`104`		`- }`
`105`		`- if (i < srclen && k < dstlen) {`
`106`		`- base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);`
`107`		`- }`
`108`		`- return k;`
`109`		`-}`
`110`		`-`
`111`		`-`
`112`	`40`	`template <typename TypeName>`
`113`	`41`	`size_t base64_decode(char* const dst, const size_t dstlen,`
`114`	`42`	`const TypeName* const src, const size_t srclen) {`

Collapse file

`‎src/cares_wrap.cc‎`

Copy file name to clipboardExpand all lines: src/cares_wrap.cc

+6-12Lines changed: 6 additions & 12 deletions

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@`
`22`	`22`	`#define CARES_STATICLIB`
`23`	`23`	`#include "ares.h"`
`24`	`24`	`#include "async_wrap-inl.h"`
	`25`	`+#include "base64-inl.h"`
`25`	`26`	`#include "env-inl.h"`
`26`	`27`	`#include "memory_tracker-inl.h"`
`27`	`28`	`#include "node.h"`
`@@ -79,13 +80,6 @@ inline uint16_t cares_get_16bit(const unsigned char* p) {`
`79`	`80`	`return static_cast<uint32_t>(p[0] << 8U) \| (static_cast<uint32_t>(p[1]));`
`80`	`81`	`}`
`81`	`82`
`82`		`-inline uint32_t cares_get_32bit(const unsigned char* p) {`
`83`		`- return static_cast<uint32_t>(p[0] << 24U) \|`
`84`		`- static_cast<uint32_t>(p[1] << 16U) \|`
`85`		`- static_cast<uint32_t>(p[2] << 8U) \|`
`86`		`- static_cast<uint32_t>(p[3]);`
`87`		`-}`
`88`		`-`
`89`	`83`	`const int ns_t_cname_or_a = -1;`
`90`	`84`
`91`	`85`	`#define DNS_ESETSRVPENDING -1000`
`@@ -1129,11 +1123,11 @@ int ParseSoaReply(Environment* env,`
`1129`	`1123`	`return ARES_EBADRESP;`
`1130`	`1124`	`}`
`1131`	`1125`
`1132`		`- const unsigned int serial = cares_get_32bit(ptr + 0 * 4);`
`1133`		`- const unsigned int refresh = cares_get_32bit(ptr + 1 * 4);`
`1134`		`- const unsigned int retry = cares_get_32bit(ptr + 2 * 4);`
`1135`		`- const unsigned int expire = cares_get_32bit(ptr + 3 * 4);`
`1136`		`- const unsigned int minttl = cares_get_32bit(ptr + 4 * 4);`
	`1126`	`+ const unsigned int serial = ReadUint32BE(ptr + 0 * 4);`
	`1127`	`+ const unsigned int refresh = ReadUint32BE(ptr + 1 * 4);`
	`1128`	`+ const unsigned int retry = ReadUint32BE(ptr + 2 * 4);`
	`1129`	`+ const unsigned int expire = ReadUint32BE(ptr + 3 * 4);`
	`1130`	`+ const unsigned int minttl = ReadUint32BE(ptr + 4 * 4);`
`1137`	`1131`
`1138`	`1132`	`Local<Object> soa_record = Object::New(env->isolate());`
`1139`	`1133`	`soa_record->Set(context,`

0 commit comments

Comments

0 (0)

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.