Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * encode.c
4 : * Various data encoding/decoding things.
5 : *
6 : * Copyright (c) 2001-2020, PostgreSQL Global Development Group
7 : *
8 : *
9 : * IDENTIFICATION
10 : * src/backend/utils/adt/encode.c
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 : #include "postgres.h"
15 :
16 : #include <ctype.h>
17 :
18 : #include "utils/builtins.h"
19 : #include "utils/memutils.h"
20 :
21 :
22 : /*
23 : * Encoding conversion API.
24 : * encode_len() and decode_len() compute the amount of space needed, while
25 : * encode() and decode() perform the actual conversions. It is okay for
26 : * the _len functions to return an overestimate, but not an underestimate.
27 : * (Having said that, large overestimates could cause unnecessary errors,
28 : * so it's better to get it right.) The conversion routines write to the
29 : * buffer at *res and return the true length of their output.
30 : */
31 : struct pg_encoding
32 : {
33 : uint64 (*encode_len) (const char *data, size_t dlen);
34 : uint64 (*decode_len) (const char *data, size_t dlen);
35 : uint64 (*encode) (const char *data, size_t dlen, char *res);
36 : uint64 (*decode) (const char *data, size_t dlen, char *res);
37 : };
38 :
39 : static const struct pg_encoding *pg_find_encoding(const char *name);
40 :
41 : /*
42 : * SQL functions.
43 : */
44 :
45 : Datum
46 244 : binary_encode(PG_FUNCTION_ARGS)
47 : {
48 244 : bytea *data = PG_GETARG_BYTEA_PP(0);
49 244 : Datum name = PG_GETARG_DATUM(1);
50 : text *result;
51 : char *namebuf;
52 : char *dataptr;
53 : size_t datalen;
54 : uint64 resultlen;
55 : uint64 res;
56 : const struct pg_encoding *enc;
57 :
58 244 : namebuf = TextDatumGetCString(name);
59 :
60 244 : enc = pg_find_encoding(namebuf);
61 244 : if (enc == NULL)
62 0 : ereport(ERROR,
63 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
64 : errmsg("unrecognized encoding: \"%s\"", namebuf)));
65 :
66 244 : dataptr = VARDATA_ANY(data);
67 244 : datalen = VARSIZE_ANY_EXHDR(data);
68 :
69 244 : resultlen = enc->encode_len(dataptr, datalen);
70 :
71 : /*
72 : * resultlen possibly overflows uint32, therefore on 32-bit machines it's
73 : * unsafe to rely on palloc's internal check.
74 : */
75 244 : if (resultlen > MaxAllocSize - VARHDRSZ)
76 0 : ereport(ERROR,
77 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
78 : errmsg("result of encoding conversion is too large")));
79 :
80 244 : result = palloc(VARHDRSZ + resultlen);
81 :
82 244 : res = enc->encode(dataptr, datalen, VARDATA(result));
83 :
84 : /* Make this FATAL 'cause we've trodden on memory ... */
85 244 : if (res > resultlen)
86 0 : elog(FATAL, "overflow - encode estimate too small");
87 :
88 244 : SET_VARSIZE(result, VARHDRSZ + res);
89 :
90 244 : PG_RETURN_TEXT_P(result);
91 : }
92 :
93 : Datum
94 202 : binary_decode(PG_FUNCTION_ARGS)
95 : {
96 202 : text *data = PG_GETARG_TEXT_PP(0);
97 202 : Datum name = PG_GETARG_DATUM(1);
98 : bytea *result;
99 : char *namebuf;
100 : char *dataptr;
101 : size_t datalen;
102 : uint64 resultlen;
103 : uint64 res;
104 : const struct pg_encoding *enc;
105 :
106 202 : namebuf = TextDatumGetCString(name);
107 :
108 202 : enc = pg_find_encoding(namebuf);
109 202 : if (enc == NULL)
110 0 : ereport(ERROR,
111 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
112 : errmsg("unrecognized encoding: \"%s\"", namebuf)));
113 :
114 202 : dataptr = VARDATA_ANY(data);
115 202 : datalen = VARSIZE_ANY_EXHDR(data);
116 :
117 202 : resultlen = enc->decode_len(dataptr, datalen);
118 :
119 : /*
120 : * resultlen possibly overflows uint32, therefore on 32-bit machines it's
121 : * unsafe to rely on palloc's internal check.
122 : */
123 202 : if (resultlen > MaxAllocSize - VARHDRSZ)
124 0 : ereport(ERROR,
125 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
126 : errmsg("result of decoding conversion is too large")));
127 :
128 202 : result = palloc(VARHDRSZ + resultlen);
129 :
130 202 : res = enc->decode(dataptr, datalen, VARDATA(result));
131 :
132 : /* Make this FATAL 'cause we've trodden on memory ... */
133 202 : if (res > resultlen)
134 0 : elog(FATAL, "overflow - decode estimate too small");
135 :
136 202 : SET_VARSIZE(result, VARHDRSZ + res);
137 :
138 202 : PG_RETURN_BYTEA_P(result);
139 : }
140 :
141 :
142 : /*
143 : * HEX
144 : */
145 :
146 : static const char hextbl[] = "0123456789abcdef";
147 :
148 : static const int8 hexlookup[128] = {
149 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
150 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
151 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
152 : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
153 : -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
154 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
155 : -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
156 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
157 : };
158 :
159 : uint64
160 133572 : hex_encode(const char *src, size_t len, char *dst)
161 : {
162 133572 : const char *end = src + len;
163 :
164 1034400 : while (src < end)
165 : {
166 900828 : *dst++ = hextbl[(*src >> 4) & 0xF];
167 900828 : *dst++ = hextbl[*src & 0xF];
168 900828 : src++;
169 : }
170 133572 : return (uint64) len * 2;
171 : }
172 :
173 : static inline char
174 204652 : get_hex(char c)
175 : {
176 204652 : int res = -1;
177 :
178 204652 : if (c > 0 && c < 127)
179 204652 : res = hexlookup[(unsigned char) c];
180 :
181 204652 : if (res < 0)
182 4 : ereport(ERROR,
183 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
184 : errmsg("invalid hexadecimal digit: \"%c\"", c)));
185 :
186 204648 : return (char) res;
187 : }
188 :
189 : uint64
190 270 : hex_decode(const char *src, size_t len, char *dst)
191 : {
192 : const char *s,
193 : *srcend;
194 : char v1,
195 : v2,
196 : *p;
197 :
198 270 : srcend = src + len;
199 270 : s = src;
200 270 : p = dst;
201 102792 : while (s < srcend)
202 : {
203 102530 : if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r')
204 : {
205 202 : s++;
206 202 : continue;
207 : }
208 102328 : v1 = get_hex(*s++) << 4;
209 102328 : if (s >= srcend)
210 4 : ereport(ERROR,
211 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
212 : errmsg("invalid hexadecimal data: odd number of digits")));
213 :
214 102324 : v2 = get_hex(*s++);
215 102320 : *p++ = v1 | v2;
216 : }
217 :
218 262 : return p - dst;
219 : }
220 :
221 : static uint64
222 216 : hex_enc_len(const char *src, size_t srclen)
223 : {
224 216 : return (uint64) srclen << 1;
225 : }
226 :
227 : static uint64
228 174 : hex_dec_len(const char *src, size_t srclen)
229 : {
230 174 : return (uint64) srclen >> 1;
231 : }
232 :
233 : /*
234 : * BASE64
235 : */
236 :
237 : static const char _base64[] =
238 : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
239 :
240 : static const int8 b64lookup[128] = {
241 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
242 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
243 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
244 : 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
245 : -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
246 : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
247 : -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
248 : 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
249 : };
250 :
251 : static uint64
252 8 : pg_base64_encode(const char *src, size_t len, char *dst)
253 : {
254 : char *p,
255 8 : *lend = dst + 76;
256 : const char *s,
257 8 : *end = src + len;
258 8 : int pos = 2;
259 8 : uint32 buf = 0;
260 :
261 8 : s = src;
262 8 : p = dst;
263 :
264 568 : while (s < end)
265 : {
266 560 : buf |= (unsigned char) *s << (pos << 3);
267 560 : pos--;
268 560 : s++;
269 :
270 : /* write it out */
271 560 : if (pos < 0)
272 : {
273 184 : *p++ = _base64[(buf >> 18) & 0x3f];
274 184 : *p++ = _base64[(buf >> 12) & 0x3f];
275 184 : *p++ = _base64[(buf >> 6) & 0x3f];
276 184 : *p++ = _base64[buf & 0x3f];
277 :
278 184 : pos = 2;
279 184 : buf = 0;
280 : }
281 560 : if (p >= lend)
282 : {
283 8 : *p++ = '\n';
284 8 : lend = p + 76;
285 : }
286 : }
287 8 : if (pos != 2)
288 : {
289 8 : *p++ = _base64[(buf >> 18) & 0x3f];
290 8 : *p++ = _base64[(buf >> 12) & 0x3f];
291 8 : *p++ = (pos == 0) ? _base64[(buf >> 6) & 0x3f] : '=';
292 8 : *p++ = '=';
293 : }
294 :
295 8 : return p - dst;
296 : }
297 :
298 : static uint64
299 8 : pg_base64_decode(const char *src, size_t len, char *dst)
300 : {
301 8 : const char *srcend = src + len,
302 8 : *s = src;
303 8 : char *p = dst;
304 : char c;
305 8 : int b = 0;
306 8 : uint32 buf = 0;
307 8 : int pos = 0,
308 8 : end = 0;
309 :
310 428 : while (s < srcend)
311 : {
312 420 : c = *s++;
313 :
314 420 : if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
315 4 : continue;
316 :
317 416 : if (c == '=')
318 : {
319 : /* end sequence */
320 12 : if (!end)
321 : {
322 8 : if (pos == 2)
323 4 : end = 1;
324 4 : else if (pos == 3)
325 4 : end = 2;
326 : else
327 0 : ereport(ERROR,
328 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
329 : errmsg("unexpected \"=\" while decoding base64 sequence")));
330 : }
331 12 : b = 0;
332 : }
333 : else
334 : {
335 404 : b = -1;
336 404 : if (c > 0 && c < 127)
337 404 : b = b64lookup[(unsigned char) c];
338 404 : if (b < 0)
339 0 : ereport(ERROR,
340 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
341 : errmsg("invalid symbol \"%c\" while decoding base64 sequence", (int) c)));
342 : }
343 : /* add it to buffer */
344 416 : buf = (buf << 6) + b;
345 416 : pos++;
346 416 : if (pos == 4)
347 : {
348 104 : *p++ = (buf >> 16) & 255;
349 104 : if (end == 0 || end > 1)
350 100 : *p++ = (buf >> 8) & 255;
351 104 : if (end == 0 || end > 2)
352 96 : *p++ = buf & 255;
353 104 : buf = 0;
354 104 : pos = 0;
355 : }
356 : }
357 :
358 8 : if (pos != 0)
359 0 : ereport(ERROR,
360 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
361 : errmsg("invalid base64 end sequence"),
362 : errhint("Input data is missing padding, is truncated, or is otherwise corrupted.")));
363 :
364 8 : return p - dst;
365 : }
366 :
367 :
368 : static uint64
369 8 : pg_base64_enc_len(const char *src, size_t srclen)
370 : {
371 : /* 3 bytes will be converted to 4, linefeed after 76 chars */
372 8 : return ((uint64) srclen + 2) * 4 / 3 + (uint64) srclen / (76 * 3 / 4);
373 : }
374 :
375 : static uint64
376 8 : pg_base64_dec_len(const char *src, size_t srclen)
377 : {
378 8 : return ((uint64) srclen * 3) >> 2;
379 : }
380 :
381 : /*
382 : * Escape
383 : * Minimally escape bytea to text.
384 : * De-escape text to bytea.
385 : *
386 : * We must escape zero bytes and high-bit-set bytes to avoid generating
387 : * text that might be invalid in the current encoding, or that might
388 : * change to something else if passed through an encoding conversion
389 : * (leading to failing to de-escape to the original bytea value).
390 : * Also of course backslash itself has to be escaped.
391 : *
392 : * De-escaping processes \\ and any \### octal
393 : */
394 :
395 : #define VAL(CH) ((CH) - '0')
396 : #define DIG(VAL) ((VAL) + '0')
397 :
398 : static uint64
399 20 : esc_encode(const char *src, size_t srclen, char *dst)
400 : {
401 20 : const char *end = src + srclen;
402 20 : char *rp = dst;
403 20 : uint64 len = 0;
404 :
405 184 : while (src < end)
406 : {
407 164 : unsigned char c = (unsigned char) *src;
408 :
409 164 : if (c == '\0' || IS_HIGHBIT_SET(c))
410 : {
411 48 : rp[0] = '\\';
412 48 : rp[1] = DIG(c >> 6);
413 48 : rp[2] = DIG((c >> 3) & 7);
414 48 : rp[3] = DIG(c & 7);
415 48 : rp += 4;
416 48 : len += 4;
417 : }
418 116 : else if (c == '\\')
419 : {
420 0 : rp[0] = '\\';
421 0 : rp[1] = '\\';
422 0 : rp += 2;
423 0 : len += 2;
424 : }
425 : else
426 : {
427 116 : *rp++ = c;
428 116 : len++;
429 : }
430 :
431 164 : src++;
432 : }
433 :
434 20 : return len;
435 : }
436 :
437 : static uint64
438 20 : esc_decode(const char *src, size_t srclen, char *dst)
439 : {
440 20 : const char *end = src + srclen;
441 20 : char *rp = dst;
442 20 : uint64 len = 0;
443 :
444 1600056 : while (src < end)
445 : {
446 1600036 : if (src[0] != '\\')
447 1600016 : *rp++ = *src++;
448 20 : else if (src + 3 < end &&
449 20 : (src[1] >= '0' && src[1] <= '3') &&
450 20 : (src[2] >= '0' && src[2] <= '7') &&
451 20 : (src[3] >= '0' && src[3] <= '7'))
452 20 : {
453 : int val;
454 :
455 20 : val = VAL(src[1]);
456 20 : val <<= 3;
457 20 : val += VAL(src[2]);
458 20 : val <<= 3;
459 20 : *rp++ = val + VAL(src[3]);
460 20 : src += 4;
461 : }
462 0 : else if (src + 1 < end &&
463 0 : (src[1] == '\\'))
464 : {
465 0 : *rp++ = '\\';
466 0 : src += 2;
467 : }
468 : else
469 : {
470 : /*
471 : * One backslash, not followed by ### valid octal. Should never
472 : * get here, since esc_dec_len does same check.
473 : */
474 0 : ereport(ERROR,
475 : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
476 : errmsg("invalid input syntax for type %s", "bytea")));
477 : }
478 :
479 1600036 : len++;
480 : }
481 :
482 20 : return len;
483 : }
484 :
485 : static uint64
486 20 : esc_enc_len(const char *src, size_t srclen)
487 : {
488 20 : const char *end = src + srclen;
489 20 : uint64 len = 0;
490 :
491 184 : while (src < end)
492 : {
493 164 : if (*src == '\0' || IS_HIGHBIT_SET(*src))
494 48 : len += 4;
495 116 : else if (*src == '\\')
496 0 : len += 2;
497 : else
498 116 : len++;
499 :
500 164 : src++;
501 : }
502 :
503 20 : return len;
504 : }
505 :
506 : static uint64
507 20 : esc_dec_len(const char *src, size_t srclen)
508 : {
509 20 : const char *end = src + srclen;
510 20 : uint64 len = 0;
511 :
512 1600056 : while (src < end)
513 : {
514 1600036 : if (src[0] != '\\')
515 1600016 : src++;
516 20 : else if (src + 3 < end &&
517 20 : (src[1] >= '0' && src[1] <= '3') &&
518 20 : (src[2] >= '0' && src[2] <= '7') &&
519 20 : (src[3] >= '0' && src[3] <= '7'))
520 : {
521 : /*
522 : * backslash + valid octal
523 : */
524 20 : src += 4;
525 : }
526 0 : else if (src + 1 < end &&
527 0 : (src[1] == '\\'))
528 : {
529 : /*
530 : * two backslashes = backslash
531 : */
532 0 : src += 2;
533 : }
534 : else
535 : {
536 : /*
537 : * one backslash, not followed by ### valid octal
538 : */
539 0 : ereport(ERROR,
540 : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
541 : errmsg("invalid input syntax for type %s", "bytea")));
542 : }
543 :
544 1600036 : len++;
545 : }
546 20 : return len;
547 : }
548 :
549 : /*
550 : * Common
551 : */
552 :
553 : static const struct
554 : {
555 : const char *name;
556 : struct pg_encoding enc;
557 : } enclist[] =
558 :
559 : {
560 : {
561 : "hex",
562 : {
563 : hex_enc_len, hex_dec_len, hex_encode, hex_decode
564 : }
565 : },
566 : {
567 : "base64",
568 : {
569 : pg_base64_enc_len, pg_base64_dec_len, pg_base64_encode, pg_base64_decode
570 : }
571 : },
572 : {
573 : "escape",
574 : {
575 : esc_enc_len, esc_dec_len, esc_encode, esc_decode
576 : }
577 : },
578 : {
579 : NULL,
580 : {
581 : NULL, NULL, NULL, NULL
582 : }
583 : }
584 : };
585 :
586 : static const struct pg_encoding *
587 446 : pg_find_encoding(const char *name)
588 : {
589 : int i;
590 :
591 542 : for (i = 0; enclist[i].name; i++)
592 542 : if (pg_strcasecmp(enclist[i].name, name) == 0)
593 446 : return &enclist[i].enc;
594 :
595 0 : return NULL;
596 : }
|
