Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * mbutils.c
4 : : * This file contains functions for encoding conversion.
5 : : *
6 : : * The string-conversion functions in this file share some API quirks.
7 : : * Note the following:
8 : : *
9 : : * The functions return a palloc'd, null-terminated string if conversion
10 : : * is required. However, if no conversion is performed, the given source
11 : : * string pointer is returned as-is.
12 : : *
13 : : * Although the presence of a length argument means that callers can pass
14 : : * non-null-terminated strings, care is required because the same string
15 : : * will be passed back if no conversion occurs. Such callers *must* check
16 : : * whether result == src and handle that case differently.
17 : : *
18 : : * If the source and destination encodings are the same, the source string
19 : : * is returned without any verification; it's assumed to be valid data.
20 : : * If that might not be the case, the caller is responsible for validating
21 : : * the string using a separate call to pg_verify_mbstr(). Whenever the
22 : : * source and destination encodings are different, the functions ensure that
23 : : * the result is validly encoded according to the destination encoding.
24 : : *
25 : : *
26 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
27 : : * Portions Copyright (c) 1994, Regents of the University of California
28 : : *
29 : : *
30 : : * IDENTIFICATION
31 : : * src/backend/utils/mb/mbutils.c
32 : : *
33 : : *-------------------------------------------------------------------------
34 : : */
35 : : #include "postgres.h"
36 : :
37 : : #include "access/xact.h"
38 : : #include "catalog/namespace.h"
39 : : #include "mb/pg_wchar.h"
40 : : #include "utils/fmgrprotos.h"
41 : : #include "utils/memdebug.h"
42 : : #include "utils/memutils.h"
43 : : #include "utils/relcache.h"
44 : : #include "varatt.h"
45 : :
46 : : /*
47 : : * We maintain a simple linked list caching the fmgr lookup info for the
48 : : * currently selected conversion functions, as well as any that have been
49 : : * selected previously in the current session. (We remember previous
50 : : * settings because we must be able to restore a previous setting during
51 : : * transaction rollback, without doing any fresh catalog accesses.)
52 : : *
53 : : * Since we'll never release this data, we just keep it in TopMemoryContext.
54 : : */
55 : : typedef struct ConvProcInfo
56 : : {
57 : : int s_encoding; /* server and client encoding IDs */
58 : : int c_encoding;
59 : : FmgrInfo to_server_info; /* lookup info for conversion procs */
60 : : FmgrInfo to_client_info;
61 : : } ConvProcInfo;
62 : :
63 : : static List *ConvProcList = NIL; /* List of ConvProcInfo */
64 : :
65 : : /*
66 : : * These variables point to the currently active conversion functions,
67 : : * or are NULL when no conversion is needed.
68 : : */
69 : : static FmgrInfo *ToServerConvProc = NULL;
70 : : static FmgrInfo *ToClientConvProc = NULL;
71 : :
72 : : /*
73 : : * This variable stores the conversion function to convert from UTF-8
74 : : * to the server encoding. It's NULL if the server encoding *is* UTF-8,
75 : : * or if we lack a conversion function for this.
76 : : */
77 : : static FmgrInfo *Utf8ToServerConvProc = NULL;
78 : :
79 : : /*
80 : : * These variables track the currently-selected encodings.
81 : : */
82 : : static const pg_enc2name *ClientEncoding = &pg_enc2name_tbl[PG_SQL_ASCII];
83 : : static const pg_enc2name *DatabaseEncoding = &pg_enc2name_tbl[PG_SQL_ASCII];
84 : : static const pg_enc2name *MessageEncoding = &pg_enc2name_tbl[PG_SQL_ASCII];
85 : :
86 : : /*
87 : : * During backend startup we can't set client encoding because we (a)
88 : : * can't look up the conversion functions, and (b) may not know the database
89 : : * encoding yet either. So SetClientEncoding() just accepts anything and
90 : : * remembers it for InitializeClientEncoding() to apply later.
91 : : */
92 : : static bool backend_startup_complete = false;
93 : : static int pending_client_encoding = PG_SQL_ASCII;
94 : :
95 : :
96 : : /* Internal functions */
97 : : static char *perform_default_encoding_conversion(const char *src,
98 : : int len, bool is_client_to_server);
99 : : static int cliplen(const char *str, int len, int limit);
100 : :
101 : : pg_noreturn
102 : : static void report_invalid_encoding_int(int encoding, const char *mbstr,
103 : : int mblen, int len);
104 : :
105 : : pg_noreturn
106 : : static void report_invalid_encoding_db(const char *mbstr, int mblen, int len);
107 : :
108 : :
109 : : /*
110 : : * Prepare for a future call to SetClientEncoding. Success should mean
111 : : * that SetClientEncoding is guaranteed to succeed for this encoding request.
112 : : *
113 : : * (But note that success before backend_startup_complete does not guarantee
114 : : * success after ...)
115 : : *
116 : : * Returns 0 if okay, -1 if not (bad encoding or can't support conversion)
117 : : */
118 : : int
5507 tgl@sss.pgh.pa.us 119 :CBC 35744 : PrepareClientEncoding(int encoding)
120 : : {
121 : : int current_server_encoding;
122 : : ListCell *lc;
123 : :
9007 ishii@postgresql.org 124 [ + - + - : 35744 : if (!PG_VALID_FE_ENCODING(encoding))
- + ]
7419 neilc@samurai.com 125 :UBC 0 : return -1;
126 : :
127 : : /* Can't do anything during startup, per notes above */
8409 tgl@sss.pgh.pa.us 128 [ + + ]:CBC 35744 : if (!backend_startup_complete)
8692 ishii@postgresql.org 129 : 17917 : return 0;
130 : :
8409 tgl@sss.pgh.pa.us 131 : 17827 : current_server_encoding = GetDatabaseEncoding();
132 : :
133 : : /*
134 : : * Check for cases that require no conversion function.
135 : : */
136 [ + + + + ]: 17827 : if (current_server_encoding == encoding ||
7419 neilc@samurai.com 137 [ + + ]: 2028 : current_server_encoding == PG_SQL_ASCII ||
138 : : encoding == PG_SQL_ASCII)
8409 tgl@sss.pgh.pa.us 139 : 17815 : return 0;
140 : :
6242 141 [ + - ]: 12 : if (IsTransactionState())
142 : : {
143 : : /*
144 : : * If we're in a live transaction, it's safe to access the catalogs,
145 : : * so look up the functions. We repeat the lookup even if the info is
146 : : * already cached, so that we can react to changes in the contents of
147 : : * pg_conversion.
148 : : */
149 : : Oid to_server_proc,
150 : : to_client_proc;
151 : : ConvProcInfo *convinfo;
152 : : MemoryContext oldcontext;
153 : :
154 : 12 : to_server_proc = FindDefaultConversionProc(encoding,
155 : : current_server_encoding);
156 [ - + ]: 12 : if (!OidIsValid(to_server_proc))
6242 tgl@sss.pgh.pa.us 157 :UBC 0 : return -1;
6242 tgl@sss.pgh.pa.us 158 :CBC 12 : to_client_proc = FindDefaultConversionProc(current_server_encoding,
159 : : encoding);
160 [ - + ]: 12 : if (!OidIsValid(to_client_proc))
6242 tgl@sss.pgh.pa.us 161 :UBC 0 : return -1;
162 : :
163 : : /*
164 : : * Load the fmgr info into TopMemoryContext (could still fail here)
165 : : */
6242 tgl@sss.pgh.pa.us 166 :CBC 12 : convinfo = (ConvProcInfo *) MemoryContextAlloc(TopMemoryContext,
167 : : sizeof(ConvProcInfo));
168 : 12 : convinfo->s_encoding = current_server_encoding;
169 : 12 : convinfo->c_encoding = encoding;
170 : 12 : fmgr_info_cxt(to_server_proc, &convinfo->to_server_info,
171 : : TopMemoryContext);
172 : 12 : fmgr_info_cxt(to_client_proc, &convinfo->to_client_info,
173 : : TopMemoryContext);
174 : :
175 : : /* Attach new info to head of list */
176 : 12 : oldcontext = MemoryContextSwitchTo(TopMemoryContext);
177 : 12 : ConvProcList = lcons(convinfo, ConvProcList);
178 : 12 : MemoryContextSwitchTo(oldcontext);
179 : :
180 : : /*
181 : : * We cannot yet remove any older entry for the same encoding pair,
182 : : * since it could still be in use. SetClientEncoding will clean up.
183 : : */
184 : :
185 : 12 : return 0; /* success */
186 : : }
187 : : else
188 : : {
189 : : /*
190 : : * If we're not in a live transaction, the only thing we can do is
191 : : * restore a previous setting using the cache. This covers all
192 : : * transaction-rollback cases. The only case it might not work for is
193 : : * trying to change client_encoding on the fly by editing
194 : : * postgresql.conf and SIGHUP'ing. Which would probably be a stupid
195 : : * thing to do anyway.
196 : : */
6242 tgl@sss.pgh.pa.us 197 [ # # # # :UBC 0 : foreach(lc, ConvProcList)
# # ]
198 : : {
199 : 0 : ConvProcInfo *oldinfo = (ConvProcInfo *) lfirst(lc);
200 : :
201 [ # # ]: 0 : if (oldinfo->s_encoding == current_server_encoding &&
202 [ # # ]: 0 : oldinfo->c_encoding == encoding)
203 : 0 : return 0;
204 : : }
205 : :
206 : 0 : return -1; /* it's not cached, so fail */
207 : : }
208 : : }
209 : :
210 : : /*
211 : : * Set the active client encoding and set up the conversion-function pointers.
212 : : * PrepareClientEncoding should have been called previously for this encoding.
213 : : *
214 : : * Returns 0 if okay, -1 if not (bad encoding or can't support conversion)
215 : : */
216 : : int
5507 tgl@sss.pgh.pa.us 217 :CBC 37666 : SetClientEncoding(int encoding)
218 : : {
219 : : int current_server_encoding;
220 : : bool found;
221 : : ListCell *lc;
222 : :
223 [ + - + - : 37666 : if (!PG_VALID_FE_ENCODING(encoding))
- + ]
5507 tgl@sss.pgh.pa.us 224 :UBC 0 : return -1;
225 : :
226 : : /* Can't do anything during startup, per notes above */
5507 tgl@sss.pgh.pa.us 227 [ + + ]:CBC 37666 : if (!backend_startup_complete)
228 : : {
229 : 17836 : pending_client_encoding = encoding;
230 : 17836 : return 0;
231 : : }
232 : :
233 : 19830 : current_server_encoding = GetDatabaseEncoding();
234 : :
235 : : /*
236 : : * Check for cases that require no conversion function.
237 : : */
238 [ + + + + ]: 19830 : if (current_server_encoding == encoding ||
239 [ + + ]: 2028 : current_server_encoding == PG_SQL_ASCII ||
240 : : encoding == PG_SQL_ASCII)
241 : : {
242 : 19818 : ClientEncoding = &pg_enc2name_tbl[encoding];
243 : 19818 : ToServerConvProc = NULL;
244 : 19818 : ToClientConvProc = NULL;
245 : 19818 : return 0;
246 : : }
247 : :
248 : : /*
249 : : * Search the cache for the entry previously prepared by
250 : : * PrepareClientEncoding; if there isn't one, we lose. While at it,
251 : : * release any duplicate entries so that repeated Prepare/Set cycles don't
252 : : * leak memory.
253 : : */
254 : 12 : found = false;
2486 255 [ + - + + : 28 : foreach(lc, ConvProcList)
+ + ]
256 : : {
5507 257 : 16 : ConvProcInfo *convinfo = (ConvProcInfo *) lfirst(lc);
258 : :
259 [ + - ]: 16 : if (convinfo->s_encoding == current_server_encoding &&
260 [ + + ]: 16 : convinfo->c_encoding == encoding)
261 : : {
262 [ + - ]: 12 : if (!found)
263 : : {
264 : : /* Found newest entry, so set up */
265 : 12 : ClientEncoding = &pg_enc2name_tbl[encoding];
266 : 12 : ToServerConvProc = &convinfo->to_server_info;
267 : 12 : ToClientConvProc = &convinfo->to_client_info;
268 : 12 : found = true;
269 : : }
270 : : else
271 : : {
272 : : /* Duplicate entry, release it */
2486 tgl@sss.pgh.pa.us 273 :UBC 0 : ConvProcList = foreach_delete_current(ConvProcList, lc);
5507 274 : 0 : pfree(convinfo);
275 : : }
276 : : }
277 : : }
278 : :
5507 tgl@sss.pgh.pa.us 279 [ + - ]:CBC 12 : if (found)
280 : 12 : return 0; /* success */
281 : : else
5507 tgl@sss.pgh.pa.us 282 :UBC 0 : return -1; /* it's not cached, so fail */
283 : : }
284 : :
285 : : /*
286 : : * Initialize client encoding conversions.
287 : : * Called from InitPostgres() once during backend startup.
288 : : */
289 : : void
8409 tgl@sss.pgh.pa.us 290 :CBC 17449 : InitializeClientEncoding(void)
291 : : {
292 : : int current_server_encoding;
293 : :
294 [ - + ]: 17449 : Assert(!backend_startup_complete);
295 : 17449 : backend_startup_complete = true;
296 : :
5507 297 [ + - - + ]: 34898 : if (PrepareClientEncoding(pending_client_encoding) < 0 ||
298 : 17449 : SetClientEncoding(pending_client_encoding) < 0)
299 : : {
300 : : /*
301 : : * Oops, the requested conversion is not available. We couldn't fail
302 : : * before, but we can now.
303 : : */
8320 tgl@sss.pgh.pa.us 304 [ # # ]:UBC 0 : ereport(FATAL,
305 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
306 : : errmsg("conversion between %s and %s is not supported",
307 : : pg_enc2name_tbl[pending_client_encoding].name,
308 : : GetDatabaseEncodingName())));
309 : : }
310 : :
311 : : /*
312 : : * Also look up the UTF8-to-server conversion function if needed. Since
313 : : * the server encoding is fixed within any one backend process, we don't
314 : : * have to do this more than once.
315 : : */
2251 tgl@sss.pgh.pa.us 316 :CBC 17449 : current_server_encoding = GetDatabaseEncoding();
317 [ + + + + ]: 17449 : if (current_server_encoding != PG_UTF8 &&
318 : : current_server_encoding != PG_SQL_ASCII)
319 : : {
320 : : Oid utf8_to_server_proc;
321 : :
383 noah@leadboat.com 322 : 93 : AssertCouldGetRelation();
323 : : utf8_to_server_proc =
2251 tgl@sss.pgh.pa.us 324 : 93 : FindDefaultConversionProc(PG_UTF8,
325 : : current_server_encoding);
326 : : /* If there's no such conversion, just leave the pointer as NULL */
327 [ + - ]: 93 : if (OidIsValid(utf8_to_server_proc))
328 : : {
329 : : FmgrInfo *finfo;
330 : :
331 : 93 : finfo = (FmgrInfo *) MemoryContextAlloc(TopMemoryContext,
332 : : sizeof(FmgrInfo));
333 : 93 : fmgr_info_cxt(utf8_to_server_proc, finfo,
334 : : TopMemoryContext);
335 : : /* Set Utf8ToServerConvProc only after data is fully valid */
336 : 93 : Utf8ToServerConvProc = finfo;
337 : : }
338 : : }
8476 ishii@postgresql.org 339 : 17449 : }
340 : :
341 : : /*
342 : : * returns the current client encoding
343 : : */
344 : : int
8992 tgl@sss.pgh.pa.us 345 : 6376 : pg_get_client_encoding(void)
346 : : {
7419 neilc@samurai.com 347 : 6376 : return ClientEncoding->encoding;
348 : : }
349 : :
350 : : /*
351 : : * returns the current client encoding name
352 : : */
353 : : const char *
8992 tgl@sss.pgh.pa.us 354 :UBC 0 : pg_get_client_encoding_name(void)
355 : : {
7419 neilc@samurai.com 356 : 0 : return ClientEncoding->name;
357 : : }
358 : :
359 : : /*
360 : : * Convert src string to another encoding (general case).
361 : : *
362 : : * See the notes about string conversion functions at the top of this file.
363 : : */
364 : : unsigned char *
8992 tgl@sss.pgh.pa.us 365 :CBC 1918 : pg_do_encoding_conversion(unsigned char *src, int len,
366 : : int src_encoding, int dest_encoding)
367 : : {
368 : : unsigned char *result;
369 : : Oid proc;
370 : :
4454 371 [ + + ]: 1918 : if (len <= 0)
372 : 24 : return src; /* empty string is always valid */
373 : :
8692 ishii@postgresql.org 374 [ + + ]: 1894 : if (src_encoding == dest_encoding)
4454 tgl@sss.pgh.pa.us 375 : 1474 : return src; /* no conversion required, assume valid */
376 : :
377 [ - + ]: 420 : if (dest_encoding == PG_SQL_ASCII)
4454 tgl@sss.pgh.pa.us 378 :UBC 0 : return src; /* any string is valid in SQL_ASCII */
379 : :
4454 tgl@sss.pgh.pa.us 380 [ + + ]:CBC 420 : if (src_encoding == PG_SQL_ASCII)
381 : : {
382 : : /* No conversion is possible, but we must validate the result */
383 : 8 : (void) pg_verify_mbstr(dest_encoding, (const char *) src, len, false);
8561 ishii@postgresql.org 384 : 8 : return src;
385 : : }
386 : :
4454 tgl@sss.pgh.pa.us 387 [ - + ]: 412 : if (!IsTransactionState()) /* shouldn't happen */
4454 tgl@sss.pgh.pa.us 388 [ # # ]:UBC 0 : elog(ERROR, "cannot perform encoding conversion outside a transaction");
389 : :
8692 ishii@postgresql.org 390 :CBC 412 : proc = FindDefaultConversionProc(src_encoding, dest_encoding);
391 [ - + ]: 412 : if (!OidIsValid(proc))
4454 tgl@sss.pgh.pa.us 392 [ # # ]:UBC 0 : ereport(ERROR,
393 : : (errcode(ERRCODE_UNDEFINED_FUNCTION),
394 : : errmsg("default conversion function for encoding \"%s\" to \"%s\" does not exist",
395 : : pg_encoding_to_char(src_encoding),
396 : : pg_encoding_to_char(dest_encoding))));
397 : :
398 : : /*
399 : : * Allocate space for conversion result, being wary of integer overflow.
400 : : *
401 : : * len * MAX_CONVERSION_GROWTH is typically a vast overestimate of the
402 : : * required space, so it might exceed MaxAllocSize even though the result
403 : : * would actually fit. We do not want to hand back a result string that
404 : : * exceeds MaxAllocSize, because callers might not cope gracefully --- but
405 : : * if we just allocate more than that, and don't use it, that's fine.
406 : : */
2406 tgl@sss.pgh.pa.us 407 [ - + ]:CBC 412 : if ((Size) len >= (MaxAllocHugeSize / (Size) MAX_CONVERSION_GROWTH))
6917 tgl@sss.pgh.pa.us 408 [ # # ]:UBC 0 : ereport(ERROR,
409 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
410 : : errmsg("out of memory"),
411 : : errdetail("String of %d bytes is too long for encoding conversion.",
412 : : len)));
413 : :
414 : : result = (unsigned char *)
2406 tgl@sss.pgh.pa.us 415 :CBC 412 : MemoryContextAllocHuge(CurrentMemoryContext,
416 : 412 : (Size) len * MAX_CONVERSION_GROWTH + 1);
417 : :
1860 heikki.linnakangas@i 418 : 412 : (void) OidFunctionCall6(proc,
419 : : Int32GetDatum(src_encoding),
420 : : Int32GetDatum(dest_encoding),
421 : : CStringGetDatum((char *) src),
422 : : CStringGetDatum((char *) result),
423 : : Int32GetDatum(len),
424 : : BoolGetDatum(false));
425 : :
426 : : /*
427 : : * If the result is large, it's worth repalloc'ing to release any extra
428 : : * space we asked for. The cutoff here is somewhat arbitrary, but we
429 : : * *must* check when len * MAX_CONVERSION_GROWTH exceeds MaxAllocSize.
430 : : */
2406 tgl@sss.pgh.pa.us 431 [ - + ]: 412 : if (len > 1000000)
432 : : {
2406 tgl@sss.pgh.pa.us 433 :UBC 0 : Size resultlen = strlen((char *) result);
434 : :
435 [ # # ]: 0 : if (resultlen >= MaxAllocSize)
436 [ # # ]: 0 : ereport(ERROR,
437 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
438 : : errmsg("out of memory"),
439 : : errdetail("String of %d bytes is too long for encoding conversion.",
440 : : len)));
441 : :
442 : 0 : result = (unsigned char *) repalloc(result, resultlen + 1);
443 : : }
444 : :
9733 tgl@sss.pgh.pa.us 445 :CBC 412 : return result;
446 : : }
447 : :
448 : : /*
449 : : * Convert src string to another encoding.
450 : : *
451 : : * This function has a different API than the other conversion functions.
452 : : * The caller should've looked up the conversion function using
453 : : * FindDefaultConversionProc(). Unlike the other functions, the converted
454 : : * result is not palloc'd. It is written to the caller-supplied buffer
455 : : * instead.
456 : : *
457 : : * src_encoding - encoding to convert from
458 : : * dest_encoding - encoding to convert to
459 : : * src, srclen - input buffer and its length in bytes
460 : : * dest, destlen - destination buffer and its size in bytes
461 : : *
462 : : * The output is null-terminated.
463 : : *
464 : : * If destlen < srclen * MAX_CONVERSION_INPUT_LENGTH + 1, the converted output
465 : : * wouldn't necessarily fit in the output buffer, and the function will not
466 : : * convert the whole input.
467 : : *
468 : : * TODO: The conversion function interface is not great. Firstly, it
469 : : * would be nice to pass through the destination buffer size to the
470 : : * conversion function, so that if you pass a shorter destination buffer, it
471 : : * could still continue to fill up the whole buffer. Currently, we have to
472 : : * assume worst case expansion and stop the conversion short, even if there
473 : : * is in fact space left in the destination buffer. Secondly, it would be
474 : : * nice to return the number of bytes written to the caller, to avoid a call
475 : : * to strlen().
476 : : */
477 : : int
1860 heikki.linnakangas@i 478 : 2620 : pg_do_encoding_conversion_buf(Oid proc,
479 : : int src_encoding,
480 : : int dest_encoding,
481 : : unsigned char *src, int srclen,
482 : : unsigned char *dest, int destlen,
483 : : bool noError)
484 : : {
485 : : Datum result;
486 : :
487 : : /*
488 : : * If the destination buffer is not large enough to hold the result in the
489 : : * worst case, limit the input size passed to the conversion function.
490 : : */
491 [ + + ]: 2620 : if ((Size) srclen >= ((destlen - 1) / (Size) MAX_CONVERSION_GROWTH))
492 : 2580 : srclen = ((destlen - 1) / (Size) MAX_CONVERSION_GROWTH);
493 : :
494 : 2620 : result = OidFunctionCall6(proc,
495 : : Int32GetDatum(src_encoding),
496 : : Int32GetDatum(dest_encoding),
497 : : CStringGetDatum((char *) src),
498 : : CStringGetDatum((char *) dest),
499 : : Int32GetDatum(srclen),
500 : : BoolGetDatum(noError));
501 : 1580 : return DatumGetInt32(result);
502 : : }
503 : :
504 : : /*
505 : : * Convert string to encoding encoding_name. The source
506 : : * encoding is the DB encoding.
507 : : *
508 : : * BYTEA convert_to(TEXT string, NAME encoding_name)
509 : : */
510 : : Datum
6804 andrew@dunslane.net 511 : 272 : pg_convert_to(PG_FUNCTION_ARGS)
512 : : {
8644 bruce@momjian.us 513 : 272 : Datum string = PG_GETARG_DATUM(0);
514 : 272 : Datum dest_encoding_name = PG_GETARG_DATUM(1);
6691 tgl@sss.pgh.pa.us 515 : 272 : Datum src_encoding_name = DirectFunctionCall1(namein,
516 : : CStringGetDatum(DatabaseEncoding->name));
517 : : Datum result;
518 : :
519 : : /*
520 : : * pg_convert expects a bytea as its first argument. We're passing it a
521 : : * text argument here, relying on the fact that they are both in fact
522 : : * varlena types, and thus structurally identical.
523 : : */
524 : 272 : result = DirectFunctionCall3(pg_convert, string,
525 : : src_encoding_name, dest_encoding_name);
526 : :
6597 527 : 268 : PG_RETURN_DATUM(result);
528 : : }
529 : :
530 : : /*
531 : : * Convert string from encoding encoding_name. The destination
532 : : * encoding is the DB encoding.
533 : : *
534 : : * TEXT convert_from(BYTEA string, NAME encoding_name)
535 : : */
536 : : Datum
6804 andrew@dunslane.net 537 : 396 : pg_convert_from(PG_FUNCTION_ARGS)
538 : : {
539 : 396 : Datum string = PG_GETARG_DATUM(0);
540 : 396 : Datum src_encoding_name = PG_GETARG_DATUM(1);
6691 tgl@sss.pgh.pa.us 541 : 396 : Datum dest_encoding_name = DirectFunctionCall1(namein,
542 : : CStringGetDatum(DatabaseEncoding->name));
543 : : Datum result;
544 : :
545 : 396 : result = DirectFunctionCall3(pg_convert, string,
546 : : src_encoding_name, dest_encoding_name);
547 : :
548 : : /*
549 : : * pg_convert returns a bytea, which we in turn return as text, relying on
550 : : * the fact that they are both in fact varlena types, and thus
551 : : * structurally identical. Although not all bytea values are valid text,
552 : : * in this case it will be because we've told pg_convert to return one
553 : : * that is valid as text in the current database encoding.
554 : : */
6597 555 : 392 : PG_RETURN_DATUM(result);
556 : : }
557 : :
558 : : /*
559 : : * Convert string between two arbitrary encodings.
560 : : *
561 : : * BYTEA convert(BYTEA string, NAME src_encoding_name, NAME dest_encoding_name)
562 : : */
563 : : Datum
6804 andrew@dunslane.net 564 : 1060 : pg_convert(PG_FUNCTION_ARGS)
565 : : {
5632 itagaki.takahiro@gma 566 : 1060 : bytea *string = PG_GETARG_BYTEA_PP(0);
8958 bruce@momjian.us 567 : 1060 : char *src_encoding_name = NameStr(*PG_GETARG_NAME(1));
568 : 1060 : int src_encoding = pg_char_to_encoding(src_encoding_name);
569 : 1060 : char *dest_encoding_name = NameStr(*PG_GETARG_NAME(2));
570 : 1060 : int dest_encoding = pg_char_to_encoding(dest_encoding_name);
571 : : const char *src_str;
572 : : char *dest_str;
573 : : bytea *retval;
574 : : int len;
575 : :
9029 ishii@postgresql.org 576 [ - + ]: 1060 : if (src_encoding < 0)
8320 tgl@sss.pgh.pa.us 577 [ # # ]:UBC 0 : ereport(ERROR,
578 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
579 : : errmsg("invalid source encoding name \"%s\"",
580 : : src_encoding_name)));
9029 ishii@postgresql.org 581 [ - + ]:CBC 1060 : if (dest_encoding < 0)
8320 tgl@sss.pgh.pa.us 582 [ # # ]:UBC 0 : ereport(ERROR,
583 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
584 : : errmsg("invalid destination encoding name \"%s\"",
585 : : dest_encoding_name)));
586 : :
587 : : /* make sure that source string is valid */
5632 itagaki.takahiro@gma 588 [ - + - - :CBC 1060 : len = VARSIZE_ANY_EXHDR(string);
- - - - +
+ ]
589 [ + + ]: 1060 : src_str = VARDATA_ANY(string);
1923 heikki.linnakangas@i 590 : 1060 : (void) pg_verify_mbstr(src_encoding, src_str, len, false);
591 : :
592 : : /* perform conversion */
2653 peter@eisentraut.org 593 : 1052 : dest_str = (char *) pg_do_encoding_conversion((unsigned char *) unconstify(char *, src_str),
594 : : len,
595 : : src_encoding,
596 : : dest_encoding);
597 : :
598 : :
599 : : /* return source string if no conversion happened */
883 nathan@postgresql.or 600 [ + + ]: 1052 : if (dest_str == src_str)
601 : 652 : PG_RETURN_BYTEA_P(string);
602 : :
603 : : /*
604 : : * build bytea data type structure.
605 : : */
606 : 400 : len = strlen(dest_str);
5632 itagaki.takahiro@gma 607 : 400 : retval = (bytea *) palloc(len + VARHDRSZ);
608 : 400 : SET_VARSIZE(retval, len + VARHDRSZ);
609 : 400 : memcpy(VARDATA(retval), dest_str, len);
883 nathan@postgresql.or 610 : 400 : pfree(dest_str);
611 : :
612 : : /* free memory if allocated by the toaster */
9029 ishii@postgresql.org 613 [ - + ]: 400 : PG_FREE_IF_COPY(string, 0);
614 : :
6804 andrew@dunslane.net 615 : 400 : PG_RETURN_BYTEA_P(retval);
616 : : }
617 : :
618 : : /*
619 : : * get the length of the string considered as text in the specified
620 : : * encoding. Raises an error if the data is not valid in that
621 : : * encoding.
622 : : *
623 : : * INT4 length (BYTEA string, NAME src_encoding_name)
624 : : */
625 : : Datum
6804 andrew@dunslane.net 626 :UBC 0 : length_in_encoding(PG_FUNCTION_ARGS)
627 : : {
4454 tgl@sss.pgh.pa.us 628 : 0 : bytea *string = PG_GETARG_BYTEA_PP(0);
6804 andrew@dunslane.net 629 : 0 : char *src_encoding_name = NameStr(*PG_GETARG_NAME(1));
630 : 0 : int src_encoding = pg_char_to_encoding(src_encoding_name);
631 : : const char *src_str;
632 : : int len;
633 : : int retval;
634 : :
6779 tgl@sss.pgh.pa.us 635 [ # # ]: 0 : if (src_encoding < 0)
636 [ # # ]: 0 : ereport(ERROR,
637 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
638 : : errmsg("invalid encoding name \"%s\"",
639 : : src_encoding_name)));
640 : :
4454 641 [ # # # # : 0 : len = VARSIZE_ANY_EXHDR(string);
# # # # #
# ]
642 [ # # ]: 0 : src_str = VARDATA_ANY(string);
643 : :
644 : 0 : retval = pg_verify_mbstr_len(src_encoding, src_str, len, false);
645 : :
646 : 0 : PG_RETURN_INT32(retval);
647 : : }
648 : :
649 : : /*
650 : : * Get maximum multibyte character length in the specified encoding.
651 : : *
652 : : * Note encoding is specified numerically, not by name as above.
653 : : */
654 : : Datum
6146 peter_e@gmx.net 655 : 0 : pg_encoding_max_length_sql(PG_FUNCTION_ARGS)
656 : : {
5912 bruce@momjian.us 657 : 0 : int encoding = PG_GETARG_INT32(0);
658 : :
6146 peter_e@gmx.net 659 [ # # # # : 0 : if (PG_VALID_ENCODING(encoding))
# # ]
tgl@sss.pgh.pa.us 660 : 0 : PG_RETURN_INT32(pg_wchar_table[encoding].maxmblen);
661 : : else
peter_e@gmx.net 662 : 0 : PG_RETURN_NULL();
663 : : }
664 : :
665 : : /*
666 : : * Convert client encoding to server encoding.
667 : : *
668 : : * See the notes about string conversion functions at the top of this file.
669 : : */
670 : : char *
7528 tgl@sss.pgh.pa.us 671 :CBC 498913 : pg_client_to_server(const char *s, int len)
672 : : {
5552 itagaki.takahiro@gma 673 : 498913 : return pg_any_to_server(s, len, ClientEncoding->encoding);
674 : : }
675 : :
676 : : /*
677 : : * Convert any encoding to server encoding.
678 : : *
679 : : * See the notes about string conversion functions at the top of this file.
680 : : *
681 : : * Unlike the other string conversion functions, this will apply validation
682 : : * even if encoding == DatabaseEncoding->encoding. This is because this is
683 : : * used to process data coming in from outside the database, and we never
684 : : * want to just assume validity.
685 : : */
686 : : char *
687 : 547259 : pg_any_to_server(const char *s, int len, int encoding)
688 : : {
7289 tgl@sss.pgh.pa.us 689 [ + + ]: 547259 : if (len <= 0)
2540 690 : 36910 : return unconstify(char *, s); /* empty string is always valid */
691 : :
5552 itagaki.takahiro@gma 692 [ + + + + ]: 510349 : if (encoding == DatabaseEncoding->encoding ||
693 : : encoding == PG_SQL_ASCII)
694 : : {
695 : : /*
696 : : * No conversion is needed, but we must still validate the data.
697 : : */
7289 tgl@sss.pgh.pa.us 698 : 510152 : (void) pg_verify_mbstr(DatabaseEncoding->encoding, s, len, false);
2653 peter@eisentraut.org 699 : 510151 : return unconstify(char *, s);
700 : : }
701 : :
7289 tgl@sss.pgh.pa.us 702 [ + + ]: 197 : if (DatabaseEncoding->encoding == PG_SQL_ASCII)
703 : : {
704 : : /*
705 : : * No conversion is possible, but we must still validate the data,
706 : : * because the client-side code might have done string escaping using
707 : : * the selected client_encoding. If the client encoding is ASCII-safe
708 : : * then we just do a straight validation under that encoding. For an
709 : : * ASCII-unsafe encoding we have a problem: we dare not pass such data
710 : : * to the parser but we have no way to convert it. We compromise by
711 : : * rejecting the data if it contains any non-ASCII characters.
712 : : */
5552 itagaki.takahiro@gma 713 [ + - + + : 163 : if (PG_VALID_BE_ENCODING(encoding))
+ - ]
714 : 133 : (void) pg_verify_mbstr(encoding, s, len, false);
715 : : else
716 : : {
717 : : int i;
718 : :
7289 tgl@sss.pgh.pa.us 719 [ + + ]: 950 : for (i = 0; i < len; i++)
720 : : {
721 [ + - - + ]: 920 : if (s[i] == '\0' || IS_HIGHBIT_SET(s[i]))
7289 tgl@sss.pgh.pa.us 722 [ # # ]:UBC 0 : ereport(ERROR,
723 : : (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
724 : : errmsg("invalid byte value for encoding \"%s\": 0x%02x",
725 : : pg_enc2name_tbl[PG_SQL_ASCII].name,
726 : : (unsigned char) s[i])));
727 : : }
728 : : }
2653 peter@eisentraut.org 729 :CBC 163 : return unconstify(char *, s);
730 : : }
731 : :
732 : : /* Fast path if we can use cached conversion function */
4454 tgl@sss.pgh.pa.us 733 [ + - ]: 34 : if (encoding == ClientEncoding->encoding)
5552 itagaki.takahiro@gma 734 : 34 : return perform_default_encoding_conversion(s, len, true);
735 : :
736 : : /* General case ... will not work outside transactions */
2653 peter@eisentraut.org 737 :UBC 0 : return (char *) pg_do_encoding_conversion((unsigned char *) unconstify(char *, s),
738 : : len,
739 : : encoding,
4454 tgl@sss.pgh.pa.us 740 : 0 : DatabaseEncoding->encoding);
741 : : }
742 : :
743 : : /*
744 : : * Convert server encoding to client encoding.
745 : : *
746 : : * See the notes about string conversion functions at the top of this file.
747 : : */
748 : : char *
7528 tgl@sss.pgh.pa.us 749 :CBC 25153905 : pg_server_to_client(const char *s, int len)
750 : : {
5552 itagaki.takahiro@gma 751 : 25153905 : return pg_server_to_any(s, len, ClientEncoding->encoding);
752 : : }
753 : :
754 : : /*
755 : : * Convert server encoding to any encoding.
756 : : *
757 : : * See the notes about string conversion functions at the top of this file.
758 : : */
759 : : char *
760 : 25176693 : pg_server_to_any(const char *s, int len, int encoding)
761 : : {
7289 tgl@sss.pgh.pa.us 762 [ + + ]: 25176693 : if (len <= 0)
2540 763 : 146090 : return unconstify(char *, s); /* empty string is always valid */
764 : :
5552 itagaki.takahiro@gma 765 [ + + + + ]: 25030603 : if (encoding == DatabaseEncoding->encoding ||
766 : : encoding == PG_SQL_ASCII)
2540 tgl@sss.pgh.pa.us 767 : 25030303 : return unconstify(char *, s); /* assume data is valid */
768 : :
4454 769 [ + + ]: 300 : if (DatabaseEncoding->encoding == PG_SQL_ASCII)
770 : : {
771 : : /* No conversion is possible, but we must validate the result */
772 : 82 : (void) pg_verify_mbstr(encoding, s, len, false);
2653 peter@eisentraut.org 773 : 82 : return unconstify(char *, s);
774 : : }
775 : :
776 : : /* Fast path if we can use cached conversion function */
4454 tgl@sss.pgh.pa.us 777 [ + + ]: 218 : if (encoding == ClientEncoding->encoding)
5552 itagaki.takahiro@gma 778 : 206 : return perform_default_encoding_conversion(s, len, false);
779 : :
780 : : /* General case ... will not work outside transactions */
2653 peter@eisentraut.org 781 :GBC 12 : return (char *) pg_do_encoding_conversion((unsigned char *) unconstify(char *, s),
782 : : len,
4454 tgl@sss.pgh.pa.us 783 : 12 : DatabaseEncoding->encoding,
784 : : encoding);
785 : : }
786 : :
787 : : /*
788 : : * Perform default encoding conversion using cached FmgrInfo. Since
789 : : * this function does not access database at all, it is safe to call
790 : : * outside transactions. If the conversion has not been set up by
791 : : * SetClientEncoding(), no conversion is performed.
792 : : */
793 : : static char *
4454 tgl@sss.pgh.pa.us 794 :CBC 240 : perform_default_encoding_conversion(const char *src, int len,
795 : : bool is_client_to_server)
796 : : {
797 : : char *result;
798 : : int src_encoding,
799 : : dest_encoding;
800 : : FmgrInfo *flinfo;
801 : :
8671 ishii@postgresql.org 802 [ + + ]: 240 : if (is_client_to_server)
803 : : {
804 : 34 : src_encoding = ClientEncoding->encoding;
805 : 34 : dest_encoding = DatabaseEncoding->encoding;
8585 tgl@sss.pgh.pa.us 806 : 34 : flinfo = ToServerConvProc;
807 : : }
808 : : else
809 : : {
8671 ishii@postgresql.org 810 : 206 : src_encoding = DatabaseEncoding->encoding;
811 : 206 : dest_encoding = ClientEncoding->encoding;
8585 tgl@sss.pgh.pa.us 812 : 206 : flinfo = ToClientConvProc;
813 : : }
814 : :
8671 ishii@postgresql.org 815 [ - + ]: 240 : if (flinfo == NULL)
2653 peter@eisentraut.org 816 :UBC 0 : return unconstify(char *, src);
817 : :
818 : : /*
819 : : * Allocate space for conversion result, being wary of integer overflow.
820 : : * See comments in pg_do_encoding_conversion.
821 : : */
2406 tgl@sss.pgh.pa.us 822 [ - + ]:CBC 240 : if ((Size) len >= (MaxAllocHugeSize / (Size) MAX_CONVERSION_GROWTH))
6917 tgl@sss.pgh.pa.us 823 [ # # ]:UBC 0 : ereport(ERROR,
824 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
825 : : errmsg("out of memory"),
826 : : errdetail("String of %d bytes is too long for encoding conversion.",
827 : : len)));
828 : :
829 : : result = (char *)
2406 tgl@sss.pgh.pa.us 830 :CBC 240 : MemoryContextAllocHuge(CurrentMemoryContext,
831 : 240 : (Size) len * MAX_CONVERSION_GROWTH + 1);
832 : :
1860 heikki.linnakangas@i 833 : 240 : FunctionCall6(flinfo,
834 : : Int32GetDatum(src_encoding),
835 : : Int32GetDatum(dest_encoding),
836 : : CStringGetDatum(src),
837 : : CStringGetDatum(result),
838 : : Int32GetDatum(len),
839 : : BoolGetDatum(false));
840 : :
841 : : /*
842 : : * Release extra space if there might be a lot --- see comments in
843 : : * pg_do_encoding_conversion.
844 : : */
2406 tgl@sss.pgh.pa.us 845 [ - + ]: 240 : if (len > 1000000)
846 : : {
2406 tgl@sss.pgh.pa.us 847 :UBC 0 : Size resultlen = strlen(result);
848 : :
849 [ # # ]: 0 : if (resultlen >= MaxAllocSize)
850 [ # # ]: 0 : ereport(ERROR,
851 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
852 : : errmsg("out of memory"),
853 : : errdetail("String of %d bytes is too long for encoding conversion.",
854 : : len)));
855 : :
856 : 0 : result = (char *) repalloc(result, resultlen + 1);
857 : : }
858 : :
8671 ishii@postgresql.org 859 :CBC 240 : return result;
860 : : }
861 : :
862 : : /*
863 : : * Convert a single Unicode code point into a string in the server encoding.
864 : : *
865 : : * The code point given by "c" is converted and stored at *s, which must
866 : : * have at least MAX_UNICODE_EQUIVALENT_STRING+1 bytes available.
867 : : * The output will have a trailing '\0'. Throws error if the conversion
868 : : * cannot be performed.
869 : : *
870 : : * Note that this relies on having previously looked up any required
871 : : * conversion function. That's partly for speed but mostly because the parser
872 : : * may call this outside any transaction, or in an aborted transaction.
873 : : */
874 : : void
188 jdavis@postgresql.or 875 :GNC 679 : pg_unicode_to_server(char32_t c, unsigned char *s)
876 : : {
877 : : unsigned char c_as_utf8[MAX_MULTIBYTE_CHAR_LEN + 1];
878 : : int c_as_utf8_len;
879 : : int server_encoding;
880 : :
881 : : /*
882 : : * Complain if invalid Unicode code point. The choice of errcode here is
883 : : * debatable, but really our caller should have checked this anyway.
884 : : */
2251 tgl@sss.pgh.pa.us 885 [ - + ]:CBC 679 : if (!is_valid_unicode_codepoint(c))
2251 tgl@sss.pgh.pa.us 886 [ # # ]:UBC 0 : ereport(ERROR,
887 : : (errcode(ERRCODE_SYNTAX_ERROR),
888 : : errmsg("invalid Unicode code point")));
889 : :
890 : : /* Otherwise, if it's in ASCII range, conversion is trivial */
2251 tgl@sss.pgh.pa.us 891 [ + + ]:CBC 679 : if (c <= 0x7F)
892 : : {
893 : 226 : s[0] = (unsigned char) c;
894 : 226 : s[1] = '\0';
895 : 679 : return;
896 : : }
897 : :
898 : : /* If the server encoding is UTF-8, we just need to reformat the code */
899 : 453 : server_encoding = GetDatabaseEncoding();
900 [ + - ]: 453 : if (server_encoding == PG_UTF8)
901 : : {
902 : 453 : unicode_to_utf8(c, s);
903 : 453 : s[pg_utf_mblen(s)] = '\0';
904 : 453 : return;
905 : : }
906 : :
907 : : /* For all other cases, we must have a conversion function available */
2251 tgl@sss.pgh.pa.us 908 [ # # ]:UBC 0 : if (Utf8ToServerConvProc == NULL)
909 [ # # ]: 0 : ereport(ERROR,
910 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
911 : : errmsg("conversion between %s and %s is not supported",
912 : : pg_enc2name_tbl[PG_UTF8].name,
913 : : GetDatabaseEncodingName())));
914 : :
915 : : /* Construct UTF-8 source string */
916 : 0 : unicode_to_utf8(c, c_as_utf8);
917 : 0 : c_as_utf8_len = pg_utf_mblen(c_as_utf8);
918 : 0 : c_as_utf8[c_as_utf8_len] = '\0';
919 : :
920 : : /* Convert, or throw error if we can't */
1860 heikki.linnakangas@i 921 : 0 : FunctionCall6(Utf8ToServerConvProc,
922 : : Int32GetDatum(PG_UTF8),
923 : : Int32GetDatum(server_encoding),
924 : : CStringGetDatum((char *) c_as_utf8),
925 : : CStringGetDatum((char *) s),
926 : : Int32GetDatum(c_as_utf8_len),
927 : : BoolGetDatum(false));
928 : : }
929 : :
930 : : /*
931 : : * Convert a single Unicode code point into a string in the server encoding.
932 : : *
933 : : * Same as pg_unicode_to_server(), except that we don't throw errors,
934 : : * but simply return false on conversion failure.
935 : : */
936 : : bool
188 jdavis@postgresql.or 937 :GNC 60 : pg_unicode_to_server_noerror(char32_t c, unsigned char *s)
938 : : {
939 : : unsigned char c_as_utf8[MAX_MULTIBYTE_CHAR_LEN + 1];
940 : : int c_as_utf8_len;
941 : : int converted_len;
942 : : int server_encoding;
943 : :
944 : : /* Fail if invalid Unicode code point */
1241 tgl@sss.pgh.pa.us 945 [ - + ]:CBC 60 : if (!is_valid_unicode_codepoint(c))
1241 tgl@sss.pgh.pa.us 946 :UBC 0 : return false;
947 : :
948 : : /* Otherwise, if it's in ASCII range, conversion is trivial */
1241 tgl@sss.pgh.pa.us 949 [ + + ]:CBC 60 : if (c <= 0x7F)
950 : : {
951 : 17 : s[0] = (unsigned char) c;
952 : 17 : s[1] = '\0';
953 : 17 : return true;
954 : : }
955 : :
956 : : /* If the server encoding is UTF-8, we just need to reformat the code */
957 : 43 : server_encoding = GetDatabaseEncoding();
958 [ + - ]: 43 : if (server_encoding == PG_UTF8)
959 : : {
960 : 43 : unicode_to_utf8(c, s);
961 : 43 : s[pg_utf_mblen(s)] = '\0';
962 : 43 : return true;
963 : : }
964 : :
965 : : /* For all other cases, we must have a conversion function available */
1241 tgl@sss.pgh.pa.us 966 [ # # ]:UBC 0 : if (Utf8ToServerConvProc == NULL)
967 : 0 : return false;
968 : :
969 : : /* Construct UTF-8 source string */
970 : 0 : unicode_to_utf8(c, c_as_utf8);
971 : 0 : c_as_utf8_len = pg_utf_mblen(c_as_utf8);
972 : 0 : c_as_utf8[c_as_utf8_len] = '\0';
973 : :
974 : : /* Convert, but without throwing error if we can't */
975 : 0 : converted_len = DatumGetInt32(FunctionCall6(Utf8ToServerConvProc,
976 : : Int32GetDatum(PG_UTF8),
977 : : Int32GetDatum(server_encoding),
978 : : CStringGetDatum((char *) c_as_utf8),
979 : : CStringGetDatum((char *) s),
980 : : Int32GetDatum(c_as_utf8_len),
981 : : BoolGetDatum(true)));
982 : :
983 : : /* Conversion was successful iff it consumed the whole input */
984 : 0 : return (converted_len == c_as_utf8_len);
985 : : }
986 : :
987 : :
988 : : /* convert a multibyte string to a wchar */
989 : : int
7528 990 : 0 : pg_mb2wchar(const char *from, pg_wchar *to)
991 : : {
3162 peter_e@gmx.net 992 : 0 : return pg_wchar_table[DatabaseEncoding->encoding].mb2wchar_with_len((const unsigned char *) from, to, strlen(from));
993 : : }
994 : :
995 : : /* convert a multibyte string to a wchar with a limited length */
996 : : int
7528 tgl@sss.pgh.pa.us 997 :CBC 6730289 : pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
998 : : {
3162 peter_e@gmx.net 999 : 6730289 : return pg_wchar_table[DatabaseEncoding->encoding].mb2wchar_with_len((const unsigned char *) from, to, len);
1000 : : }
1001 : :
1002 : : /* same, with any encoding */
1003 : : int
7072 tgl@sss.pgh.pa.us 1004 : 12373 : pg_encoding_mb2wchar_with_len(int encoding,
1005 : : const char *from, pg_wchar *to, int len)
1006 : : {
3162 peter_e@gmx.net 1007 : 12373 : return pg_wchar_table[encoding].mb2wchar_with_len((const unsigned char *) from, to, len);
1008 : : }
1009 : :
1010 : : /* convert a wchar string to a multibyte */
1011 : : int
5053 rhaas@postgresql.org 1012 :UBC 0 : pg_wchar2mb(const pg_wchar *from, char *to)
1013 : : {
3162 peter_e@gmx.net 1014 : 0 : return pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len(from, (unsigned char *) to, pg_wchar_strlen(from));
1015 : : }
1016 : :
1017 : : /* convert a wchar string to a multibyte with a limited length */
1018 : : int
5053 rhaas@postgresql.org 1019 :CBC 579771 : pg_wchar2mb_with_len(const pg_wchar *from, char *to, int len)
1020 : : {
3162 peter_e@gmx.net 1021 : 579771 : return pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len(from, (unsigned char *) to, len);
1022 : : }
1023 : :
1024 : : /* same, with any encoding */
1025 : : int
5053 rhaas@postgresql.org 1026 : 116 : pg_encoding_wchar2mb_with_len(int encoding,
1027 : : const pg_wchar *from, char *to, int len)
1028 : : {
3162 peter_e@gmx.net 1029 : 116 : return pg_wchar_table[encoding].wchar2mb_with_len(from, (unsigned char *) to, len);
1030 : : }
1031 : :
1032 : : /*
1033 : : * Returns the byte length of a multibyte character sequence in a
1034 : : * null-terminated string. Raises an illegal byte sequence error if the
1035 : : * sequence would hit a null terminator.
1036 : : *
1037 : : * The caller is expected to have checked for a terminator at *mbstr == 0
1038 : : * before calling, but some callers want 1 in that case, so this function
1039 : : * continues that tradition.
1040 : : *
1041 : : * This must only be used for strings that have a null-terminator to enable
1042 : : * bounds detection.
1043 : : */
1044 : : int
118 tmunro@postgresql.or 1045 : 2306247 : pg_mblen_cstr(const char *mbstr)
1046 : : {
1047 : 2306247 : int length = pg_wchar_table[DatabaseEncoding->encoding].mblen((const unsigned char *) mbstr);
1048 : :
1049 : : /*
1050 : : * The .mblen functions return 1 when given a pointer to a terminator.
1051 : : * Some callers depend on that, so we tolerate it for now. Well-behaved
1052 : : * callers check the leading byte for a terminator *before* calling.
1053 : : */
1054 [ + + ]: 2318671 : for (int i = 1; i < length; ++i)
1055 [ + + ]: 12428 : if (unlikely(mbstr[i] == 0))
1056 : 4 : report_invalid_encoding_db(mbstr, length, i);
1057 : :
1058 : : /*
1059 : : * String should be NUL-terminated, but checking that would make typical
1060 : : * callers O(N^2), tripling Valgrind check-world time. Unless
1061 : : * VALGRIND_EXPENSIVE, check 1 byte after each actual character. (If we
1062 : : * found a character, not a terminator, the next byte must be a terminator
1063 : : * or the start of the next character.) If the caller iterates the whole
1064 : : * string, the last call will diagnose a missing terminator.
1065 : : */
1066 : 2306243 : if (mbstr[0] != '\0')
1067 : : {
1068 : : #ifdef VALGRIND_EXPENSIVE
1069 : : VALGRIND_CHECK_MEM_IS_DEFINED(mbstr, strlen(mbstr));
1070 : : #else
1071 : : VALGRIND_CHECK_MEM_IS_DEFINED(mbstr + length, 1);
1072 : : #endif
1073 : : }
1074 : :
1075 : 2306243 : return length;
1076 : : }
1077 : :
1078 : : /*
1079 : : * Returns the byte length of a multibyte character sequence bounded by a range
1080 : : * [mbstr, end) of at least one byte in size. Raises an illegal byte sequence
1081 : : * error if the sequence would exceed the range.
1082 : : */
1083 : : int
1084 : 3487245 : pg_mblen_range(const char *mbstr, const char *end)
1085 : : {
1086 : 3487245 : int length = pg_wchar_table[DatabaseEncoding->encoding].mblen((const unsigned char *) mbstr);
1087 : :
1088 [ - + ]: 3487245 : Assert(end > mbstr);
1089 : :
80 noah@leadboat.com 1090 [ + + ]: 3487245 : if (unlikely(mbstr + length > end))
1091 : 8 : report_invalid_encoding_db(mbstr, length, end - mbstr);
1092 : :
1093 : : #ifdef VALGRIND_EXPENSIVE
1094 : : VALGRIND_CHECK_MEM_IS_DEFINED(mbstr, end - mbstr);
1095 : : #else
1096 : : VALGRIND_CHECK_MEM_IS_DEFINED(mbstr, length);
1097 : : #endif
1098 : :
118 tmunro@postgresql.or 1099 : 3487237 : return length;
1100 : : }
1101 : :
1102 : : /*
1103 : : * Returns the byte length of a multibyte character sequence bounded by a range
1104 : : * extending for 'limit' bytes, which must be at least one. Raises an illegal
1105 : : * byte sequence error if the sequence would exceed the range.
1106 : : */
1107 : : int
1108 : 38110132 : pg_mblen_with_len(const char *mbstr, int limit)
1109 : : {
1110 : 38110132 : int length = pg_wchar_table[DatabaseEncoding->encoding].mblen((const unsigned char *) mbstr);
1111 : :
1112 [ - + ]: 38110132 : Assert(limit >= 1);
1113 : :
80 noah@leadboat.com 1114 [ + + ]: 38110132 : if (unlikely(length > limit))
1115 : 16 : report_invalid_encoding_db(mbstr, length, limit);
1116 : :
1117 : : #ifdef VALGRIND_EXPENSIVE
1118 : : VALGRIND_CHECK_MEM_IS_DEFINED(mbstr, limit);
1119 : : #else
1120 : : VALGRIND_CHECK_MEM_IS_DEFINED(mbstr, length);
1121 : : #endif
1122 : :
118 tmunro@postgresql.or 1123 : 38110116 : return length;
1124 : : }
1125 : :
1126 : :
1127 : : /*
1128 : : * Returns the length of a multibyte character sequence, without any
1129 : : * validation of bounds.
1130 : : *
1131 : : * PLEASE NOTE: This function can only be used safely if the caller has
1132 : : * already verified the input string, since otherwise there is a risk of
1133 : : * overrunning the buffer if the string is invalid. A prior call to a
1134 : : * pg_mbstrlen* function suffices.
1135 : : */
1136 : : int
1137 : 12799116 : pg_mblen_unbounded(const char *mbstr)
1138 : : {
1139 : 12799116 : int length = pg_wchar_table[DatabaseEncoding->encoding].mblen((const unsigned char *) mbstr);
1140 : :
1141 : : VALGRIND_CHECK_MEM_IS_DEFINED(mbstr, length);
1142 : :
1143 : 12799116 : return length;
1144 : : }
1145 : :
1146 : : /*
1147 : : * Historical name for pg_mblen_unbounded(). Should not be used and will be
1148 : : * removed in a later version.
1149 : : */
1150 : : int
7528 tgl@sss.pgh.pa.us 1151 :UBC 0 : pg_mblen(const char *mbstr)
1152 : : {
118 tmunro@postgresql.or 1153 : 0 : return pg_mblen_unbounded(mbstr);
1154 : : }
1155 : :
1156 : : /* returns the display length of a multibyte character */
1157 : : int
7528 tgl@sss.pgh.pa.us 1158 :CBC 7179 : pg_dsplen(const char *mbstr)
1159 : : {
3162 peter_e@gmx.net 1160 : 7179 : return pg_wchar_table[DatabaseEncoding->encoding].dsplen((const unsigned char *) mbstr);
1161 : : }
1162 : :
1163 : : /* returns the length (counted in wchars) of a multibyte string */
1164 : : int
7528 tgl@sss.pgh.pa.us 1165 : 76 : pg_mbstrlen(const char *mbstr)
1166 : : {
10108 bruce@momjian.us 1167 : 76 : int len = 0;
1168 : :
1169 : : /* optimization for single byte encoding */
8650 ishii@postgresql.org 1170 [ - + ]: 76 : if (pg_database_encoding_max_length() == 1)
7528 tgl@sss.pgh.pa.us 1171 :UBC 0 : return strlen(mbstr);
1172 : :
10108 bruce@momjian.us 1173 [ + + ]:CBC 300 : while (*mbstr)
1174 : : {
118 tmunro@postgresql.or 1175 : 224 : mbstr += pg_mblen_cstr(mbstr);
10108 bruce@momjian.us 1176 : 224 : len++;
1177 : : }
7419 neilc@samurai.com 1178 : 76 : return len;
1179 : : }
1180 : :
1181 : : /* returns the length (counted in wchars) of a multibyte string
1182 : : * (stops at the first of "limit" or a NUL)
1183 : : */
1184 : : int
7528 tgl@sss.pgh.pa.us 1185 : 533162 : pg_mbstrlen_with_len(const char *mbstr, int limit)
1186 : : {
10108 bruce@momjian.us 1187 : 533162 : int len = 0;
1188 : :
1189 : : /* optimization for single byte encoding */
7604 tgl@sss.pgh.pa.us 1190 [ + + ]: 533162 : if (pg_database_encoding_max_length() == 1)
1191 : 200007 : return limit;
1192 : :
9189 1193 [ + + + + ]: 30326122 : while (limit > 0 && *mbstr)
1194 : : {
118 tmunro@postgresql.or 1195 : 29992971 : int l = pg_mblen_with_len(mbstr, limit);
1196 : :
10108 bruce@momjian.us 1197 : 29992967 : limit -= l;
1198 : 29992967 : mbstr += l;
1199 : 29992967 : len++;
1200 : : }
7419 neilc@samurai.com 1201 : 333151 : return len;
1202 : : }
1203 : :
1204 : : /*
1205 : : * returns the byte length of a multibyte string
1206 : : * (not necessarily NULL terminated)
1207 : : * that is no longer than limit.
1208 : : * this function does not break multibyte character boundary.
1209 : : */
1210 : : int
7528 tgl@sss.pgh.pa.us 1211 : 195796 : pg_mbcliplen(const char *mbstr, int len, int limit)
1212 : : {
6330 1213 : 195796 : return pg_encoding_mbcliplen(DatabaseEncoding->encoding, mbstr,
1214 : : len, limit);
1215 : : }
1216 : :
1217 : : /*
1218 : : * pg_mbcliplen with specified encoding; string must be valid in encoding
1219 : : */
1220 : : int
1221 : 195796 : pg_encoding_mbcliplen(int encoding, const char *mbstr,
1222 : : int len, int limit)
1223 : : {
1224 : : mblen_converter mblen_fn;
10084 bruce@momjian.us 1225 : 195796 : int clen = 0;
1226 : : int l;
1227 : :
1228 : : /* optimization for single byte encoding */
6330 tgl@sss.pgh.pa.us 1229 [ + + ]: 195796 : if (pg_encoding_max_length(encoding) == 1)
8650 ishii@postgresql.org 1230 : 21035 : return cliplen(mbstr, len, limit);
1231 : :
6330 tgl@sss.pgh.pa.us 1232 : 174761 : mblen_fn = pg_wchar_table[encoding].mblen;
1233 : :
9189 1234 [ + + + - ]: 1845236 : while (len > 0 && *mbstr)
1235 : : {
6330 1236 : 1762526 : l = (*mblen_fn) ((const unsigned char *) mbstr);
9842 bruce@momjian.us 1237 [ + + ]: 1762526 : if ((clen + l) > limit)
10084 1238 : 71 : break;
1239 : 1762455 : clen += l;
9842 1240 [ + + ]: 1762455 : if (clen == limit)
10084 1241 : 91980 : break;
1242 : 1670475 : len -= l;
1243 : 1670475 : mbstr += l;
1244 : : }
7419 neilc@samurai.com 1245 : 174761 : return clen;
1246 : : }
1247 : :
1248 : : /*
1249 : : * Similar to pg_mbcliplen except the limit parameter specifies the
1250 : : * character length, not the byte length.
1251 : : */
1252 : : int
7528 tgl@sss.pgh.pa.us 1253 : 360 : pg_mbcharcliplen(const char *mbstr, int len, int limit)
1254 : : {
9060 ishii@postgresql.org 1255 : 360 : int clen = 0;
1256 : 360 : int nch = 0;
1257 : : int l;
1258 : :
1259 : : /* optimization for single byte encoding */
8650 1260 [ - + ]: 360 : if (pg_database_encoding_max_length() == 1)
8650 ishii@postgresql.org 1261 :UBC 0 : return cliplen(mbstr, len, limit);
1262 : :
9060 ishii@postgresql.org 1263 [ + + + - ]:CBC 1587 : while (len > 0 && *mbstr)
1264 : : {
118 tmunro@postgresql.or 1265 : 1575 : l = pg_mblen_with_len(mbstr, len);
9060 ishii@postgresql.org 1266 : 1575 : nch++;
1267 [ + + ]: 1575 : if (nch > limit)
1268 : 348 : break;
1269 : 1227 : clen += l;
1270 : 1227 : len -= l;
1271 : 1227 : mbstr += l;
1272 : : }
7419 neilc@samurai.com 1273 : 360 : return clen;
1274 : : }
1275 : :
1276 : : /* mbcliplen for any single-byte encoding */
1277 : : static int
6330 tgl@sss.pgh.pa.us 1278 : 21035 : cliplen(const char *str, int len, int limit)
1279 : : {
1280 : 21035 : int l = 0;
1281 : :
1282 : 21035 : len = Min(len, limit);
1283 [ + + + - ]: 166534 : while (l < len && str[l])
1284 : 145499 : l++;
1285 : 21035 : return l;
1286 : : }
1287 : :
1288 : : void
10147 scrappy@hub.org 1289 : 16888 : SetDatabaseEncoding(int encoding)
1290 : : {
9007 ishii@postgresql.org 1291 [ + - + - : 16888 : if (!PG_VALID_BE_ENCODING(encoding))
- + ]
7075 peter_e@gmx.net 1292 [ # # ]:UBC 0 : elog(ERROR, "invalid database encoding: %d", encoding);
1293 : :
8958 bruce@momjian.us 1294 :CBC 16888 : DatabaseEncoding = &pg_enc2name_tbl[encoding];
9007 ishii@postgresql.org 1295 [ - + ]: 16888 : Assert(DatabaseEncoding->encoding == encoding);
6267 alvherre@alvh.no-ip. 1296 : 16888 : }
1297 : :
1298 : : void
4696 noah@leadboat.com 1299 : 19052 : SetMessageEncoding(int encoding)
1300 : : {
1301 : : /* Some calls happen before we can elog()! */
1302 [ + - + - : 19052 : Assert(PG_VALID_ENCODING(encoding));
- + ]
1303 : :
1304 : 19052 : MessageEncoding = &pg_enc2name_tbl[encoding];
1305 [ - + ]: 19052 : Assert(MessageEncoding->encoding == encoding);
1306 : 19052 : }
1307 : :
1308 : : #ifdef ENABLE_NLS
1309 : : /*
1310 : : * Make one bind_textdomain_codeset() call, translating a pg_enc to a gettext
1311 : : * codeset. Can fail for gettext-internal causes like out-of-memory.
1312 : : */
1313 : : static bool
1314 : 1653 : raw_pg_bind_textdomain_codeset(const char *domainname, int encoding)
1315 : : {
1316 : 1653 : bool elog_ok = (CurrentMemoryContext != NULL);
1317 : :
795 michael@paquier.xyz 1318 [ + - + - : 1653 : if (!PG_VALID_ENCODING(encoding) || pg_enc2gettext_tbl[encoding] == NULL)
+ - - + ]
795 michael@paquier.xyz 1319 :UBC 0 : return false;
1320 : :
795 michael@paquier.xyz 1321 [ + - ]:CBC 1653 : if (bind_textdomain_codeset(domainname,
1322 : : pg_enc2gettext_tbl[encoding]) != NULL)
1323 : 1653 : return true;
1324 : :
795 michael@paquier.xyz 1325 [ # # ]:UBC 0 : if (elog_ok)
1326 [ # # ]: 0 : elog(LOG, "bind_textdomain_codeset failed");
1327 : : else
1328 : 0 : write_stderr("bind_textdomain_codeset failed");
1329 : :
4696 noah@leadboat.com 1330 : 0 : return false;
1331 : : }
1332 : :
1333 : : /*
1334 : : * Bind a gettext message domain to the codeset corresponding to the database
1335 : : * encoding. For SQL_ASCII, instead bind to the codeset implied by LC_CTYPE.
1336 : : * Return the MessageEncoding implied by the new settings.
1337 : : *
1338 : : * On most platforms, gettext defaults to the codeset implied by LC_CTYPE.
1339 : : * When that matches the database encoding, we don't need to do anything. In
1340 : : * CREATE DATABASE, we enforce or trust that the locale's codeset matches the
1341 : : * database encoding, except for the C locale. (On Windows, we also permit a
1342 : : * discrepancy under the UTF8 encoding.) For the C locale, explicitly bind
1343 : : * gettext to the right codeset.
1344 : : *
1345 : : * On Windows, gettext defaults to the Windows ANSI code page. This is a
1346 : : * convenient departure for software that passes the strings to Windows ANSI
1347 : : * APIs, but we don't do that. Compel gettext to use database encoding or,
1348 : : * failing that, the LC_CTYPE encoding as it would on other platforms.
1349 : : *
1350 : : * This function is called before elog() and palloc() are usable.
1351 : : */
1352 : : int
4696 noah@leadboat.com 1353 :CBC 21540 : pg_bind_textdomain_codeset(const char *domainname)
1354 : : {
1355 : 21540 : bool elog_ok = (CurrentMemoryContext != NULL);
1356 : 21540 : int encoding = GetDatabaseEncoding();
1357 : : int new_msgenc;
1358 : :
1359 : : #ifndef WIN32
1360 : 21540 : const char *ctype = setlocale(LC_CTYPE, NULL);
1361 : :
1362 [ + + - + ]: 21540 : if (pg_strcasecmp(ctype, "C") == 0 || pg_strcasecmp(ctype, "POSIX") == 0)
1363 : : #endif
1364 [ + + + - ]: 3701 : if (encoding != PG_SQL_ASCII &&
1365 : 1653 : raw_pg_bind_textdomain_codeset(domainname, encoding))
1366 : 1653 : return encoding;
1367 : :
1368 : 19887 : new_msgenc = pg_get_encoding_from_locale(NULL, elog_ok);
1369 [ - + ]: 19887 : if (new_msgenc < 0)
4696 noah@leadboat.com 1370 :UBC 0 : new_msgenc = PG_SQL_ASCII;
1371 : :
1372 : : #ifdef WIN32
1373 : : if (!raw_pg_bind_textdomain_codeset(domainname, new_msgenc))
1374 : : /* On failure, the old message encoding remains valid. */
1375 : : return GetMessageEncoding();
1376 : : #endif
1377 : :
4696 noah@leadboat.com 1378 :CBC 19887 : return new_msgenc;
1379 : : }
1380 : : #endif
1381 : :
1382 : : /*
1383 : : * The database encoding, also called the server encoding, represents the
1384 : : * encoding of data stored in text-like data types. Affected types include
1385 : : * cstring, text, varchar, name, xml, and json.
1386 : : */
1387 : : int
8992 tgl@sss.pgh.pa.us 1388 : 5567734 : GetDatabaseEncoding(void)
1389 : : {
7419 neilc@samurai.com 1390 : 5567734 : return DatabaseEncoding->encoding;
1391 : : }
1392 : :
1393 : : const char *
8992 tgl@sss.pgh.pa.us 1394 : 35623 : GetDatabaseEncodingName(void)
1395 : : {
7419 neilc@samurai.com 1396 : 35623 : return DatabaseEncoding->name;
1397 : : }
1398 : :
1399 : : Datum
9457 tgl@sss.pgh.pa.us 1400 : 6154 : getdatabaseencoding(PG_FUNCTION_ARGS)
1401 : : {
9007 ishii@postgresql.org 1402 : 6154 : return DirectFunctionCall1(namein, CStringGetDatum(DatabaseEncoding->name));
1403 : : }
1404 : :
1405 : : Datum
8971 ishii@postgresql.org 1406 :UBC 0 : pg_client_encoding(PG_FUNCTION_ARGS)
1407 : : {
1408 : 0 : return DirectFunctionCall1(namein, CStringGetDatum(ClientEncoding->name));
1409 : : }
1410 : :
1411 : : Datum
2301 tgl@sss.pgh.pa.us 1412 :CBC 6110 : PG_char_to_encoding(PG_FUNCTION_ARGS)
1413 : : {
1414 : 6110 : Name s = PG_GETARG_NAME(0);
1415 : :
1416 : 6110 : PG_RETURN_INT32(pg_char_to_encoding(NameStr(*s)));
1417 : : }
1418 : :
1419 : : Datum
1420 : 2382 : PG_encoding_to_char(PG_FUNCTION_ARGS)
1421 : : {
1422 : 2382 : int32 encoding = PG_GETARG_INT32(0);
1423 : 2382 : const char *encoding_name = pg_encoding_to_char(encoding);
1424 : :
1425 : 2382 : return DirectFunctionCall1(namein, CStringGetDatum(encoding_name));
1426 : : }
1427 : :
1428 : : /*
1429 : : * gettext() returns messages in this encoding. This often matches the
1430 : : * database encoding, but it differs for SQL_ASCII databases, for processes
1431 : : * not attached to a database.
1432 : : */
1433 : : int
4696 noah@leadboat.com 1434 :UBC 0 : GetMessageEncoding(void)
1435 : : {
1436 : 0 : return MessageEncoding->encoding;
1437 : : }
1438 : :
1439 : :
1440 : : /*
1441 : : * Generic character incrementer function.
1442 : : *
1443 : : * Not knowing anything about the properties of the encoding in use, we just
1444 : : * keep incrementing the last byte until we get a validly-encoded result,
1445 : : * or we run out of values to try. We don't bother to try incrementing
1446 : : * higher-order bytes, so there's no growth in runtime for wider characters.
1447 : : * (If we did try to do that, we'd need to consider the likelihood that 255
1448 : : * is not a valid final byte in the encoding.)
1449 : : */
1450 : : static bool
2301 tgl@sss.pgh.pa.us 1451 :CBC 48 : pg_generic_charinc(unsigned char *charptr, int len)
1452 : : {
1453 : 48 : unsigned char *lastbyte = charptr + len - 1;
1454 : : mbchar_verifier mbverify;
1455 : :
1456 : : /* We can just invoke the character verifier directly. */
1923 heikki.linnakangas@i 1457 : 48 : mbverify = pg_wchar_table[GetDatabaseEncoding()].mbverifychar;
1458 : :
2301 tgl@sss.pgh.pa.us 1459 [ + - ]: 48 : while (*lastbyte < (unsigned char) 255)
1460 : : {
1461 : 48 : (*lastbyte)++;
1462 [ + - ]: 48 : if ((*mbverify) (charptr, len) == len)
1463 : 48 : return true;
1464 : : }
1465 : :
2301 tgl@sss.pgh.pa.us 1466 :UBC 0 : return false;
1467 : : }
1468 : :
1469 : : /*
1470 : : * UTF-8 character incrementer function.
1471 : : *
1472 : : * For a one-byte character less than 0x7F, we just increment the byte.
1473 : : *
1474 : : * For a multibyte character, every byte but the first must fall between 0x80
1475 : : * and 0xBF; and the first byte must be between 0xC0 and 0xF4. We increment
1476 : : * the last byte that's not already at its maximum value. If we can't find a
1477 : : * byte that's less than the maximum allowable value, we simply fail. We also
1478 : : * need some special-case logic to skip regions used for surrogate pair
1479 : : * handling, as those should not occur in valid UTF-8.
1480 : : *
1481 : : * Note that we don't reset lower-order bytes back to their minimums, since
1482 : : * we can't afford to make an exhaustive search (see make_greater_string).
1483 : : */
1484 : : static bool
2301 tgl@sss.pgh.pa.us 1485 :CBC 2370 : pg_utf8_increment(unsigned char *charptr, int length)
1486 : : {
1487 : : unsigned char a;
1488 : : unsigned char limit;
1489 : :
1490 [ - - - - : 2370 : switch (length)
+ ]
1491 : : {
2301 tgl@sss.pgh.pa.us 1492 :UBC 0 : default:
1493 : : /* reject lengths 5 and 6 for now */
1494 : 0 : return false;
1495 : 0 : case 4:
1496 : 0 : a = charptr[3];
1497 [ # # ]: 0 : if (a < 0xBF)
1498 : : {
1499 : 0 : charptr[3]++;
1500 : 0 : break;
1501 : : }
1502 : : pg_fallthrough;
1503 : : case 3:
1504 : 0 : a = charptr[2];
1505 [ # # ]: 0 : if (a < 0xBF)
1506 : : {
1507 : 0 : charptr[2]++;
1508 : 0 : break;
1509 : : }
1510 : : pg_fallthrough;
1511 : : case 2:
1512 : 0 : a = charptr[1];
1513 [ # # # ]: 0 : switch (*charptr)
1514 : : {
1515 : 0 : case 0xED:
1516 : 0 : limit = 0x9F;
1517 : 0 : break;
1518 : 0 : case 0xF4:
1519 : 0 : limit = 0x8F;
1520 : 0 : break;
1521 : 0 : default:
1522 : 0 : limit = 0xBF;
1523 : 0 : break;
1524 : : }
1525 [ # # ]: 0 : if (a < limit)
1526 : : {
1527 : 0 : charptr[1]++;
1528 : 0 : break;
1529 : : }
1530 : : pg_fallthrough;
1531 : : case 1:
2301 tgl@sss.pgh.pa.us 1532 :CBC 2370 : a = *charptr;
1533 [ + - + - : 2370 : if (a == 0x7F || a == 0xDF || a == 0xEF || a == 0xF4)
+ - - + ]
2301 tgl@sss.pgh.pa.us 1534 :UBC 0 : return false;
2301 tgl@sss.pgh.pa.us 1535 :CBC 2370 : charptr[0]++;
1536 : 2370 : break;
1537 : : }
1538 : :
1539 : 2370 : return true;
1540 : : }
1541 : :
1542 : : /*
1543 : : * EUC-JP character incrementer function.
1544 : : *
1545 : : * If the sequence starts with SS2 (0x8e), it must be a two-byte sequence
1546 : : * representing JIS X 0201 characters with the second byte ranging between
1547 : : * 0xa1 and 0xdf. We just increment the last byte if it's less than 0xdf,
1548 : : * and otherwise rewrite the whole sequence to 0xa1 0xa1.
1549 : : *
1550 : : * If the sequence starts with SS3 (0x8f), it must be a three-byte sequence
1551 : : * in which the last two bytes range between 0xa1 and 0xfe. The last byte
1552 : : * is incremented if possible, otherwise the second-to-last byte.
1553 : : *
1554 : : * If the sequence starts with a value other than the above and its MSB
1555 : : * is set, it must be a two-byte sequence representing JIS X 0208 characters
1556 : : * with both bytes ranging between 0xa1 and 0xfe. The last byte is
1557 : : * incremented if possible, otherwise the second-to-last byte.
1558 : : *
1559 : : * Otherwise, the sequence is a single-byte ASCII character. It is
1560 : : * incremented up to 0x7f.
1561 : : */
1562 : : static bool
2301 tgl@sss.pgh.pa.us 1563 :UBC 0 : pg_eucjp_increment(unsigned char *charptr, int length)
1564 : : {
1565 : : unsigned char c1,
1566 : : c2;
1567 : : int i;
1568 : :
1569 : 0 : c1 = *charptr;
1570 : :
1571 [ # # # ]: 0 : switch (c1)
1572 : : {
1573 : 0 : case SS2: /* JIS X 0201 */
1574 [ # # ]: 0 : if (length != 2)
1575 : 0 : return false;
1576 : :
1577 : 0 : c2 = charptr[1];
1578 : :
1579 [ # # ]: 0 : if (c2 >= 0xdf)
1580 : 0 : charptr[0] = charptr[1] = 0xa1;
1581 [ # # ]: 0 : else if (c2 < 0xa1)
1582 : 0 : charptr[1] = 0xa1;
1583 : : else
1584 : 0 : charptr[1]++;
1585 : 0 : break;
1586 : :
1587 : 0 : case SS3: /* JIS X 0212 */
1588 [ # # ]: 0 : if (length != 3)
1589 : 0 : return false;
1590 : :
1591 [ # # ]: 0 : for (i = 2; i > 0; i--)
1592 : : {
1593 : 0 : c2 = charptr[i];
1594 [ # # ]: 0 : if (c2 < 0xa1)
1595 : : {
1596 : 0 : charptr[i] = 0xa1;
1597 : 0 : return true;
1598 : : }
1599 [ # # ]: 0 : else if (c2 < 0xfe)
1600 : : {
1601 : 0 : charptr[i]++;
1602 : 0 : return true;
1603 : : }
1604 : : }
1605 : :
1606 : : /* Out of 3-byte code region */
1607 : 0 : return false;
1608 : :
1609 : 0 : default:
1610 [ # # ]: 0 : if (IS_HIGHBIT_SET(c1)) /* JIS X 0208? */
1611 : : {
1612 [ # # ]: 0 : if (length != 2)
1613 : 0 : return false;
1614 : :
1615 [ # # ]: 0 : for (i = 1; i >= 0; i--)
1616 : : {
1617 : 0 : c2 = charptr[i];
1618 [ # # ]: 0 : if (c2 < 0xa1)
1619 : : {
1620 : 0 : charptr[i] = 0xa1;
1621 : 0 : return true;
1622 : : }
1623 [ # # ]: 0 : else if (c2 < 0xfe)
1624 : : {
1625 : 0 : charptr[i]++;
1626 : 0 : return true;
1627 : : }
1628 : : }
1629 : :
1630 : : /* Out of 2 byte code region */
1631 : 0 : return false;
1632 : : }
1633 : : else
1634 : : { /* ASCII, single byte */
1635 [ # # ]: 0 : if (c1 > 0x7e)
1636 : 0 : return false;
1637 : 0 : (*charptr)++;
1638 : : }
1639 : 0 : break;
1640 : : }
1641 : :
1642 : 0 : return true;
1643 : : }
1644 : :
1645 : : /*
1646 : : * get the character incrementer for the encoding for the current database
1647 : : */
1648 : : mbcharacter_incrementer
2301 tgl@sss.pgh.pa.us 1649 :CBC 2418 : pg_database_encoding_character_incrementer(void)
1650 : : {
1651 : : /*
1652 : : * Eventually it might be best to add a field to pg_wchar_table[], but for
1653 : : * now we just use a switch.
1654 : : */
1655 [ + - + ]: 2418 : switch (GetDatabaseEncoding())
1656 : : {
1657 : 2370 : case PG_UTF8:
1658 : 2370 : return pg_utf8_increment;
1659 : :
2301 tgl@sss.pgh.pa.us 1660 :UBC 0 : case PG_EUC_JP:
1661 : 0 : return pg_eucjp_increment;
1662 : :
2301 tgl@sss.pgh.pa.us 1663 :CBC 48 : default:
1664 : 48 : return pg_generic_charinc;
1665 : : }
1666 : : }
1667 : :
1668 : : /*
1669 : : * fetch maximum length of the encoding for the current database
1670 : : */
1671 : : int
1672 : 3595959 : pg_database_encoding_max_length(void)
1673 : : {
1674 : 3595959 : return pg_wchar_table[GetDatabaseEncoding()].maxmblen;
1675 : : }
1676 : :
1677 : : /*
1678 : : * Verify mbstr to make sure that it is validly encoded in the current
1679 : : * database encoding. Otherwise same as pg_verify_mbstr().
1680 : : */
1681 : : bool
1682 : 153663 : pg_verifymbstr(const char *mbstr, int len, bool noError)
1683 : : {
1923 heikki.linnakangas@i 1684 : 153663 : return pg_verify_mbstr(GetDatabaseEncoding(), mbstr, len, noError);
1685 : : }
1686 : :
1687 : : /*
1688 : : * Verify mbstr to make sure that it is validly encoded in the specified
1689 : : * encoding.
1690 : : */
1691 : : bool
2301 tgl@sss.pgh.pa.us 1692 : 1006395 : pg_verify_mbstr(int encoding, const char *mbstr, int len, bool noError)
1693 : : {
1694 : : int oklen;
1695 : :
1923 heikki.linnakangas@i 1696 [ + - + - : 1006395 : Assert(PG_VALID_ENCODING(encoding));
- + ]
1697 : :
1698 : 1006395 : oklen = pg_wchar_table[encoding].mbverifystr((const unsigned char *) mbstr, len);
1699 [ + + ]: 1006395 : if (oklen != len)
1700 : : {
1701 [ - + ]: 10 : if (noError)
1923 heikki.linnakangas@i 1702 :UBC 0 : return false;
1923 heikki.linnakangas@i 1703 :CBC 10 : report_invalid_encoding(encoding, mbstr + oklen, len - oklen);
1704 : : }
1705 : 1006385 : return true;
1706 : : }
1707 : :
1708 : : /*
1709 : : * Verify mbstr to make sure that it is validly encoded in the specified
1710 : : * encoding.
1711 : : *
1712 : : * mbstr is not necessarily zero terminated; length of mbstr is
1713 : : * specified by len.
1714 : : *
1715 : : * If OK, return length of string in the encoding.
1716 : : * If a problem is found, return -1 when noError is
1717 : : * true; when noError is false, ereport() a descriptive message.
1718 : : *
1719 : : * Note: We cannot use the faster encoding-specific mbverifystr() function
1720 : : * here, because we need to count the number of characters in the string.
1721 : : */
1722 : : int
2301 tgl@sss.pgh.pa.us 1723 :UBC 0 : pg_verify_mbstr_len(int encoding, const char *mbstr, int len, bool noError)
1724 : : {
1725 : : mbchar_verifier mbverifychar;
1726 : : int mb_len;
1727 : :
1728 [ # # # # : 0 : Assert(PG_VALID_ENCODING(encoding));
# # ]
1729 : :
1730 : : /*
1731 : : * In single-byte encodings, we need only reject nulls (\0).
1732 : : */
1733 [ # # ]: 0 : if (pg_encoding_max_length(encoding) <= 1)
1734 : : {
1735 : 0 : const char *nullpos = memchr(mbstr, 0, len);
1736 : :
1737 [ # # ]: 0 : if (nullpos == NULL)
1738 : 0 : return len;
1739 [ # # ]: 0 : if (noError)
1740 : 0 : return -1;
1741 : 0 : report_invalid_encoding(encoding, nullpos, 1);
1742 : : }
1743 : :
1744 : : /* fetch function pointer just once */
1923 heikki.linnakangas@i 1745 : 0 : mbverifychar = pg_wchar_table[encoding].mbverifychar;
1746 : :
2301 tgl@sss.pgh.pa.us 1747 : 0 : mb_len = 0;
1748 : :
1749 [ # # ]: 0 : while (len > 0)
1750 : : {
1751 : : int l;
1752 : :
1753 : : /* fast path for ASCII-subset characters */
1754 [ # # ]: 0 : if (!IS_HIGHBIT_SET(*mbstr))
1755 : : {
1756 [ # # ]: 0 : if (*mbstr != '\0')
1757 : : {
1758 : 0 : mb_len++;
1759 : 0 : mbstr++;
1760 : 0 : len--;
1761 : 0 : continue;
1762 : : }
1763 [ # # ]: 0 : if (noError)
1764 : 0 : return -1;
1765 : 0 : report_invalid_encoding(encoding, mbstr, len);
1766 : : }
1767 : :
1923 heikki.linnakangas@i 1768 : 0 : l = (*mbverifychar) ((const unsigned char *) mbstr, len);
1769 : :
2301 tgl@sss.pgh.pa.us 1770 [ # # ]: 0 : if (l < 0)
1771 : : {
1772 [ # # ]: 0 : if (noError)
1773 : 0 : return -1;
1774 : 0 : report_invalid_encoding(encoding, mbstr, len);
1775 : : }
1776 : :
1777 : 0 : mbstr += l;
1778 : 0 : len -= l;
1779 : 0 : mb_len++;
1780 : : }
1781 : 0 : return mb_len;
1782 : : }
1783 : :
1784 : : /*
1785 : : * check_encoding_conversion_args: check arguments of a conversion function
1786 : : *
1787 : : * "expected" arguments can be either an encoding ID or -1 to indicate that
1788 : : * the caller will check whether it accepts the ID.
1789 : : *
1790 : : * Note: the errors here are not really user-facing, so elog instead of
1791 : : * ereport seems sufficient. Also, we trust that the "expected" encoding
1792 : : * arguments are valid encoding IDs, but we don't trust the actuals.
1793 : : */
1794 : : void
2301 tgl@sss.pgh.pa.us 1795 :CBC 3314 : check_encoding_conversion_args(int src_encoding,
1796 : : int dest_encoding,
1797 : : int len,
1798 : : int expected_src_encoding,
1799 : : int expected_dest_encoding)
1800 : : {
1801 [ + - + - : 3314 : if (!PG_VALID_ENCODING(src_encoding))
- + ]
2301 tgl@sss.pgh.pa.us 1802 [ # # ]:UBC 0 : elog(ERROR, "invalid source encoding ID: %d", src_encoding);
2301 tgl@sss.pgh.pa.us 1803 [ + + - + ]:CBC 3314 : if (src_encoding != expected_src_encoding && expected_src_encoding >= 0)
2301 tgl@sss.pgh.pa.us 1804 [ # # ]:UBC 0 : elog(ERROR, "expected source encoding \"%s\", but got \"%s\"",
1805 : : pg_enc2name_tbl[expected_src_encoding].name,
1806 : : pg_enc2name_tbl[src_encoding].name);
2301 tgl@sss.pgh.pa.us 1807 [ + - + - :CBC 3314 : if (!PG_VALID_ENCODING(dest_encoding))
- + ]
2301 tgl@sss.pgh.pa.us 1808 [ # # ]:UBC 0 : elog(ERROR, "invalid destination encoding ID: %d", dest_encoding);
2301 tgl@sss.pgh.pa.us 1809 [ + + - + ]:CBC 3314 : if (dest_encoding != expected_dest_encoding && expected_dest_encoding >= 0)
2301 tgl@sss.pgh.pa.us 1810 [ # # ]:UBC 0 : elog(ERROR, "expected destination encoding \"%s\", but got \"%s\"",
1811 : : pg_enc2name_tbl[expected_dest_encoding].name,
1812 : : pg_enc2name_tbl[dest_encoding].name);
2301 tgl@sss.pgh.pa.us 1813 [ - + ]:CBC 3314 : if (len < 0)
2301 tgl@sss.pgh.pa.us 1814 [ # # ]:UBC 0 : elog(ERROR, "encoding conversion length must not be negative");
2301 tgl@sss.pgh.pa.us 1815 :CBC 3314 : }
1816 : :
1817 : : /*
1818 : : * report_invalid_encoding: complain about invalid multibyte character
1819 : : *
1820 : : * note: len is remaining length of string, not length of character;
1821 : : * len must be greater than zero (or we'd neglect initializing "buf").
1822 : : */
1823 : : void
1824 : 1626 : report_invalid_encoding(int encoding, const char *mbstr, int len)
1825 : : {
365 noah@leadboat.com 1826 : 1626 : int l = pg_encoding_mblen_or_incomplete(encoding, mbstr, len);
1827 : :
118 tmunro@postgresql.or 1828 : 1626 : report_invalid_encoding_int(encoding, mbstr, l, len);
1829 : : }
1830 : :
1831 : : static void
1832 : 1654 : report_invalid_encoding_int(int encoding, const char *mbstr, int mblen, int len)
1833 : : {
1834 : : char buf[8 * 5 + 1];
2301 tgl@sss.pgh.pa.us 1835 : 1654 : char *p = buf;
1836 : : int j,
1837 : : jlimit;
1838 : :
118 tmunro@postgresql.or 1839 : 1654 : jlimit = Min(mblen, len);
2301 tgl@sss.pgh.pa.us 1840 : 1654 : jlimit = Min(jlimit, 8); /* prevent buffer overrun */
1841 : :
1842 [ + + ]: 5180 : for (j = 0; j < jlimit; j++)
1843 : : {
1844 : 3526 : p += sprintf(p, "0x%02x", (unsigned char) mbstr[j]);
1845 [ + + ]: 3526 : if (j < jlimit - 1)
1846 : 1872 : p += sprintf(p, " ");
1847 : : }
1848 : :
1849 [ + - ]: 1654 : ereport(ERROR,
1850 : : (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
1851 : : errmsg("invalid byte sequence for encoding \"%s\": %s",
1852 : : pg_enc2name_tbl[encoding].name,
1853 : : buf)));
1854 : : }
1855 : :
1856 : : static void
118 tmunro@postgresql.or 1857 : 28 : report_invalid_encoding_db(const char *mbstr, int mblen, int len)
1858 : : {
1859 : 28 : report_invalid_encoding_int(GetDatabaseEncoding(), mbstr, mblen, len);
1860 : : }
1861 : :
1862 : : /*
1863 : : * report_untranslatable_char: complain about untranslatable character
1864 : : *
1865 : : * note: len is remaining length of string, not length of character;
1866 : : * len must be greater than zero (or we'd neglect initializing "buf").
1867 : : */
1868 : : void
2301 tgl@sss.pgh.pa.us 1869 : 384 : report_untranslatable_char(int src_encoding, int dest_encoding,
1870 : : const char *mbstr, int len)
1871 : : {
1872 : : int l;
1873 : : char buf[8 * 5 + 1];
1874 : 384 : char *p = buf;
1875 : : int j,
1876 : : jlimit;
1877 : :
1878 : : /*
1879 : : * We probably could use plain pg_encoding_mblen(), because
1880 : : * gb18030_to_utf8() verifies before it converts. All conversions should.
1881 : : * For src_encoding!=GB18030, len>0 meets pg_encoding_mblen() needs. Even
1882 : : * so, be defensive, since a buggy conversion might pass invalid data.
1883 : : * This is not a performance-critical path.
1884 : : */
365 noah@leadboat.com 1885 : 384 : l = pg_encoding_mblen_or_incomplete(src_encoding, mbstr, len);
2301 tgl@sss.pgh.pa.us 1886 : 384 : jlimit = Min(l, len);
1887 : 384 : jlimit = Min(jlimit, 8); /* prevent buffer overrun */
1888 : :
1889 [ + + ]: 1488 : for (j = 0; j < jlimit; j++)
1890 : : {
1891 : 1104 : p += sprintf(p, "0x%02x", (unsigned char) mbstr[j]);
1892 [ + + ]: 1104 : if (j < jlimit - 1)
1893 : 720 : p += sprintf(p, " ");
1894 : : }
1895 : :
1896 [ + - ]: 384 : ereport(ERROR,
1897 : : (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
1898 : : errmsg("character with byte sequence %s in encoding \"%s\" has no equivalent in encoding \"%s\"",
1899 : : buf,
1900 : : pg_enc2name_tbl[src_encoding].name,
1901 : : pg_enc2name_tbl[dest_encoding].name)));
1902 : : }
1903 : :
1904 : :
1905 : : #ifdef WIN32
1906 : : /*
1907 : : * Convert from MessageEncoding to a palloc'ed, null-terminated utf16
1908 : : * string. The character length is also passed to utf16len if not
1909 : : * null. Returns NULL iff failed. Before MessageEncoding initialization, "str"
1910 : : * should be ASCII-only; this will function as though MessageEncoding is UTF8.
1911 : : */
1912 : : WCHAR *
1913 : : pgwin32_message_to_UTF16(const char *str, int len, int *utf16len)
1914 : : {
1915 : : int msgenc = GetMessageEncoding();
1916 : : WCHAR *utf16;
1917 : : int dstlen;
1918 : : UINT codepage;
1919 : :
1920 : : if (msgenc == PG_SQL_ASCII)
1921 : : /* No conversion is possible, and SQL_ASCII is never utf16. */
1922 : : return NULL;
1923 : :
1924 : : codepage = pg_enc2name_tbl[msgenc].codepage;
1925 : :
1926 : : /*
1927 : : * Use MultiByteToWideChar directly if there is a corresponding codepage,
1928 : : * or double conversion through UTF8 if not. Double conversion is needed,
1929 : : * for example, in an ENCODING=LATIN8, LC_CTYPE=C database.
1930 : : */
1931 : : if (codepage != 0)
1932 : : {
1933 : : utf16 = palloc_array(WCHAR, len + 1);
1934 : : dstlen = MultiByteToWideChar(codepage, 0, str, len, utf16, len);
1935 : : utf16[dstlen] = (WCHAR) 0;
1936 : : }
1937 : : else
1938 : : {
1939 : : char *utf8;
1940 : :
1941 : : /*
1942 : : * XXX pg_do_encoding_conversion() requires a transaction. In the
1943 : : * absence of one, hope for the input to be valid UTF8.
1944 : : */
1945 : : if (IsTransactionState())
1946 : : {
1947 : : utf8 = (char *) pg_do_encoding_conversion((unsigned char *) str,
1948 : : len,
1949 : : msgenc,
1950 : : PG_UTF8);
1951 : : if (utf8 != str)
1952 : : len = strlen(utf8);
1953 : : }
1954 : : else
1955 : : utf8 = (char *) str;
1956 : :
1957 : : utf16 = palloc_array(WCHAR, len + 1);
1958 : : dstlen = MultiByteToWideChar(CP_UTF8, 0, utf8, len, utf16, len);
1959 : : utf16[dstlen] = (WCHAR) 0;
1960 : :
1961 : : if (utf8 != str)
1962 : : pfree(utf8);
1963 : : }
1964 : :
1965 : : if (dstlen == 0 && len > 0)
1966 : : {
1967 : : pfree(utf16);
1968 : : return NULL; /* error */
1969 : : }
1970 : :
1971 : : if (utf16len)
1972 : : *utf16len = dstlen;
1973 : : return utf16;
1974 : : }
1975 : :
1976 : : #endif /* WIN32 */
|
