LCOV - code coverage report
Current view: top level - src/backend/utils/adt - encode.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 193 217 88.9 %
Date: 2020-05-29 01:06:25 Functions: 16 16 100.0 %
Legend: Lines: hit not hit

          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             : }

Generated by: LCOV version 1.13