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;

372 if (c > 0 && c < 127)

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] = '\\';

449 rp[1] = DIG(c >> 6);

450 rp[2] = DIG((c >> 3) & 7);

451 rp[3] = DIG(c & 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)