PostgreSQL Source Code: src/backend/utils/adt/encode.c Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
15
16#include <ctype.h>
17
22
23
24
25
26
27
28
29
30
31
32
34{
39};
40
42
43
44
45
46
49{
53 char *namebuf;
54 char *dataptr;
55 size_t datalen;
59
61
63 if (enc == NULL)
65 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
66 errmsg("unrecognized encoding: \"%s\"", namebuf)));
67
70
72
73
74
75
76
79 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
80 errmsg("result of encoding conversion is too large")));
81
83
85
86
87 if (res > resultlen)
88 elog(FATAL, "overflow - encode estimate too small");
89
91
93}
94
97{
101 char *namebuf;
102 char *dataptr;
103 size_t datalen;
107
109
111 if (enc == NULL)
113 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
114 errmsg("unrecognized encoding: \"%s\"", namebuf)));
115
118
120
121
122
123
124
127 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
128 errmsg("result of decoding conversion is too large")));
129
131
133
134
135 if (res > resultlen)
136 elog(FATAL, "overflow - decode estimate too small");
137
139
141}
142
143
144
145
146
147
148
149
150
152"000102030405060708090a0b0c0d0e0f"
153"101112131415161718191a1b1c1d1e1f"
154"202122232425262728292a2b2c2d2e2f"
155"303132333435363738393a3b3c3d3e3f"
156"404142434445464748494a4b4c4d4e4f"
157"505152535455565758595a5b5c5d5e5f"
158"606162636465666768696a6b6c6d6e6f"
159"707172737475767778797a7b7c7d7e7f"
160"808182838485868788898a8b8c8d8e8f"
161"909192939495969798999a9b9c9d9e9f"
162"a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
163"b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
164"c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
165"d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
166"e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
167"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
168
170 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
171 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
172 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
173 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
174 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
175 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
176 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
177 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
178};
179
182{
183 const char *end = src + len;
184
185 while (src < end)
186 {
187 unsigned char usrc = *((const unsigned char *) src);
188
189 memcpy(dst, &hextbl[2 * usrc], 2);
190 src++;
191 dst += 2;
192 }
194}
195
196static inline bool
198{
199 unsigned char c = (unsigned char) *cp;
200 int res = -1;
201
202 if (c < 127)
204
205 *out = (char) res;
206
207 return (res >= 0);
208}
209
212{
214}
215
218{
219 const char *s,
220 *srcend;
221 char v1,
222 v2,
223 *p;
224
225 srcend = src + len;
226 s = src;
227 p = dst;
228 while (s < srcend)
229 {
230 if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r')
231 {
232 s++;
233 continue;
234 }
237 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
238 errmsg("invalid hexadecimal digit: \"%.*s\"",
240 s++;
241 if (s >= srcend)
243 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
244 errmsg("invalid hexadecimal data: odd number of digits")));
247 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
248 errmsg("invalid hexadecimal digit: \"%.*s\"",
250 s++;
251 *p++ = (v1 << 4) | v2;
252 }
253
254 return p - dst;
255}
256
259{
260 return (uint64) srclen << 1;
261}
262
265{
266 return (uint64) srclen >> 1;
267}
268
269
270
271
272
274"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
275
277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
280 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
281 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
282 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
283 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
284 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
285};
286
289{
290 char *p,
291 *lend = dst + 76;
292 const char *s,
293 *end = src + len;
294 int pos = 2;
296
297 s = src;
298 p = dst;
299
300 while (s < end)
301 {
302 buf |= (unsigned char) *s << (pos << 3);
303 pos--;
304 s++;
305
306
307 if (pos < 0)
308 {
313
314 pos = 2;
316 }
317 if (p >= lend)
318 {
319 *p++ = '\n';
320 lend = p + 76;
321 }
322 }
323 if (pos != 2)
324 {
327 *p++ = (pos == 0) ? _base64[(buf >> 6) & 0x3f] : '=';
328 *p++ = '=';
329 }
330
331 return p - dst;
332}
333
336{
337 const char *srcend = src + len,
338 *s = src;
339 char *p = dst;
340 char c;
341 int b = 0;
343 int pos = 0,
344 end = 0;
345
346 while (s < srcend)
347 {
348 c = *s++;
349
350 if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
351 continue;
352
353 if (c == '=')
354 {
355
356 if (!end)
357 {
358 if (pos == 2)
359 end = 1;
360 else if (pos == 3)
361 end = 2;
362 else
364 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
365 errmsg("unexpected \"=\" while decoding base64 sequence")));
366 }
367 b = 0;
368 }
369 else
370 {
371 b = -1;
374 if (b < 0)
376 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
377 errmsg("invalid symbol \"%.*s\" found while decoding base64 sequence",
379 }
380
382 pos++;
383 if (pos == 4)
384 {
385 *p++ = (buf >> 16) & 255;
386 if (end == 0 || end > 1)
387 *p++ = (buf >> 8) & 255;
388 if (end == 0 || end > 2)
389 *p++ = buf & 255;
391 pos = 0;
392 }
393 }
394
395 if (pos != 0)
397 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
398 errmsg("invalid base64 end sequence"),
399 errhint("Input data is missing padding, is truncated, or is otherwise corrupted.")));
400
401 return p - dst;
402}
403
404
407{
408
409 return ((uint64) srclen + 2) / 3 * 4 + (uint64) srclen / (76 * 3 / 4);
410}
411
414{
415 return ((uint64) srclen * 3) >> 2;
416}
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432#define VAL(CH) ((CH) - '0')
433#define DIG(VAL) ((VAL) + '0')
434
436esc_encode(const char *src, size_t srclen, char *dst)
437{
438 const char *end = src + srclen;
439 char *rp = dst;
441
442 while (src < end)
443 {
444 unsigned char c = (unsigned char) *src;
445
447 {
448 rp[0] = '\\';
450 rp[2] = DIG((c >> 3) & 7);
452 rp += 4;
453 len += 4;
454 }
455 else if (c == '\\')
456 {
457 rp[0] = '\\';
458 rp[1] = '\\';
459 rp += 2;
460 len += 2;
461 }
462 else
463 {
464 *rp++ = c;
466 }
467
468 src++;
469 }
470
471 return len;
472}
473
475esc_decode(const char *src, size_t srclen, char *dst)
476{
477 const char *end = src + srclen;
478 char *rp = dst;
480
481 while (src < end)
482 {
483 if (src[0] != '\\')
484 *rp++ = *src++;
485 else if (src + 3 < end &&
486 (src[1] >= '0' && src[1] <= '3') &&
487 (src[2] >= '0' && src[2] <= '7') &&
488 (src[3] >= '0' && src[3] <= '7'))
489 {
491
493 val <<= 3;
495 val <<= 3;
496 *rp++ = val + VAL(src[3]);
497 src += 4;
498 }
499 else if (src + 1 < end &&
500 (src[1] == '\\'))
501 {
502 *rp++ = '\\';
503 src += 2;
504 }
505 else
506 {
507
508
509
510
512 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
513 errmsg("invalid input syntax for type %s", "bytea")));
514 }
515
517 }
518
519 return len;
520}
521
524{
525 const char *end = src + srclen;
527
528 while (src < end)
529 {
531 len += 4;
532 else if (*src == '\\')
533 len += 2;
534 else
536
537 src++;
538 }
539
540 return len;
541}
542
545{
546 const char *end = src + srclen;
548
549 while (src < end)
550 {
551 if (src[0] != '\\')
552 src++;
553 else if (src + 3 < end &&
554 (src[1] >= '0' && src[1] <= '3') &&
555 (src[2] >= '0' && src[2] <= '7') &&
556 (src[3] >= '0' && src[3] <= '7'))
557 {
558
559
560
561 src += 4;
562 }
563 else if (src + 1 < end &&
564 (src[1] == '\\'))
565 {
566
567
568
569 src += 2;
570 }
571 else
572 {
573
574
575
577 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
578 errmsg("invalid input syntax for type %s", "bytea")));
579 }
580
582 }
583 return len;
584}
585
586
587
588
589
590static const struct
591{
595
596{
597 {
598 "hex",
599 {
601 }
602 },
603 {
604 "base64",
605 {
607 }
608 },
609 {
610 "escape",
611 {
613 }
614 },
615 {
616 NULL,
617 {
618 NULL, NULL, NULL, NULL
619 }
620 }
622
625{
626 int i;
627
631
632 return NULL;
633}
#define TextDatumGetCString(d)
#define IS_HIGHBIT_SET(ch)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereturn(context, dummy_value,...)
#define ereport(elevel,...)
static uint64 pg_base64_decode(const char *src, size_t len, char *dst)
static const struct @22 enclist[]
static bool get_hex(const char *cp, char *out)
static uint64 hex_dec_len(const char *src, size_t srclen)
static const struct pg_encoding * pg_find_encoding(const char *name)
static uint64 pg_base64_encode(const char *src, size_t len, char *dst)
static uint64 esc_encode(const char *src, size_t srclen, char *dst)
static uint64 hex_enc_len(const char *src, size_t srclen)
Datum binary_decode(PG_FUNCTION_ARGS)
static const char hextbl[512]
uint64 hex_decode_safe(const char *src, size_t len, char *dst, Node *escontext)
uint64 hex_encode(const char *src, size_t len, char *dst)
static uint64 esc_enc_len(const char *src, size_t srclen)
static uint64 pg_base64_enc_len(const char *src, size_t srclen)
static const char _base64[]
static uint64 esc_decode(const char *src, size_t srclen, char *dst)
static uint64 esc_dec_len(const char *src, size_t srclen)
Datum binary_encode(PG_FUNCTION_ARGS)
uint64 hex_decode(const char *src, size_t len, char *dst)
static const int8 b64lookup[128]
static const int8 hexlookup[128]
static uint64 pg_base64_dec_len(const char *src, size_t srclen)
#define PG_GETARG_BYTEA_PP(n)
#define PG_GETARG_TEXT_PP(n)
#define PG_RETURN_BYTEA_P(x)
#define PG_GETARG_DATUM(n)
#define PG_RETURN_TEXT_P(x)
int pg_mblen(const char *mbstr)
int pg_strcasecmp(const char *s1, const char *s2)
uint64(* encode_len)(const char *data, size_t dlen)
uint64(* decode_len)(const char *data, size_t dlen)
uint64(* decode)(const char *data, size_t dlen, char *res)
uint64(* encode)(const char *data, size_t dlen, char *res)
#define SET_VARSIZE(PTR, len)
#define VARSIZE_ANY_EXHDR(PTR)