From: Tom Lane Date: Mon, 2 Mar 2009 21:19:05 +0000 (+0000) Subject: When we are in error recursion trouble, arrange to suppress translation and X-Git-Url: http://git.postgresql.org/gitweb/?a=commitdiff_plain;h=68aa0700b7566aa38a2b67be8a687d0d2da75aac;p=users%2Fbernd%2Fpostgres.git When we are in error recursion trouble, arrange to suppress translation and encoding conversion of any elog/ereport message being sent to the frontend. This generalizes a patch that I put in last October, which suppressed translation of only specific messages known to be associated with recursive can't-translate-the-message behavior. As shown in bug #4680, we need a more general answer in order to have some hope of coping with broken encoding conversion setups. This approach seems a good deal less klugy anyway. Patch in all supported branches. --- diff --git a/src/backend/libpq/pqformat.c b/src/backend/libpq/pqformat.c index 17c0a4807b..7a6b374c8e 100644 --- a/src/backend/libpq/pqformat.c +++ b/src/backend/libpq/pqformat.c @@ -41,6 +41,7 @@ * pq_sendcountedtext - append a counted text string (with character set conversion) * pq_sendtext - append a text string (with conversion) * pq_sendstring - append a null-terminated text string (with conversion) + * pq_send_ascii_string - append a null-terminated text string (without conversion) * pq_endmessage - send the completed message to the frontend * Note: it is also possible to append data to the StringInfo buffer using * the regular StringInfo routines, but this is discouraged since required @@ -188,7 +189,6 @@ void pq_sendstring(StringInfo buf, const char *str) { int slen = strlen(str); - char *p; p = pg_server_to_client(str, slen); @@ -202,6 +202,35 @@ pq_sendstring(StringInfo buf, const char *str) appendBinaryStringInfo(buf, str, slen + 1); } +/* -------------------------------- + * pq_send_ascii_string - append a null-terminated text string (without conversion) + * + * This function intentionally bypasses encoding conversion, instead just + * silently replacing any non-7-bit-ASCII characters with question marks. + * It is used only when we are having trouble sending an error message to + * the client with normal localization and encoding conversion. The caller + * should already have taken measures to ensure the string is just ASCII; + * the extra work here is just to make certain we don't send a badly encoded + * string to the client (which might or might not be robust about that). + * + * NB: passed text string must be null-terminated, and so is the data + * sent to the frontend. + * -------------------------------- + */ +void +pq_send_ascii_string(StringInfo buf, const char *str) +{ + while (*str) + { + char ch = *str++; + + if (IS_HIGHBIT_SET(ch)) + ch = '?'; + appendStringInfoCharMacro(buf, ch); + } + appendStringInfoChar(buf, '\0'); +} + /* -------------------------------- * pq_sendint - append a binary integer to a StringInfo buffer * -------------------------------- diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c index 953186d183..30bea499d7 100644 --- a/src/backend/utils/error/elog.c +++ b/src/backend/utils/error/elog.c @@ -70,6 +70,9 @@ #include "utils/ps_status.h" +#undef _ +#define _(x) err_gettext(x) + /* Global variables */ ErrorContextCallback *error_context_stack = NULL; @@ -139,6 +142,25 @@ in_error_recursion_trouble(void) return (recursion_depth > 2); } +/* + * One of those fallback steps is to stop trying to localize the error + * message, since there's a significant probability that that's exactly + * what's causing the recursion. + */ +static inline const char * +err_gettext(const char *str) +{ +#ifdef ENABLE_NLS + if (in_error_recursion_trouble()) + return str; + else + return gettext(str); +#else + return str; +#endif +} + + /* * errstart --- begin an error-reporting cycle * @@ -620,7 +642,7 @@ errcode_for_socket_access(void) char *fmtbuf; \ StringInfoData buf; \ /* Internationalize the error format string */ \ - if (translateit) \ + if (translateit && !in_error_recursion_trouble()) \ fmt = _(fmt); \ /* Expand %m in format string */ \ fmtbuf = expand_fmt_string(fmt, edata); \ @@ -1792,6 +1814,26 @@ write_pipe_chunks(int fd, char *data, int len) } +/* + * Append a text string to the error report being built for the client. + * + * This is ordinarily identical to pq_sendstring(), but if we are in + * error recursion trouble we skip encoding conversion, because of the + * possibility that the problem is a failure in the encoding conversion + * subsystem itself. Code elsewhere should ensure that the passed-in + * strings will be plain 7-bit ASCII, and thus not in need of conversion, + * in such cases. (In particular, we disable localization of error messages + * to help ensure that's true.) + */ +static void +err_sendstring(StringInfo buf, const char *str) +{ + if (in_error_recursion_trouble()) + pq_send_ascii_string(buf, str); + else + pq_sendstring(buf, str); +} + /* * Write error report to client */ @@ -1811,7 +1853,7 @@ send_message_to_frontend(ErrorData *edata) int i; pq_sendbyte(&msgbuf, PG_DIAG_SEVERITY); - pq_sendstring(&msgbuf, error_severity(edata->elevel)); + err_sendstring(&msgbuf, error_severity(edata->elevel)); /* unpack MAKE_SQLSTATE code */ ssval = edata->sqlerrcode; @@ -1823,70 +1865,70 @@ send_message_to_frontend(ErrorData *edata) tbuf[i] = '\0'; pq_sendbyte(&msgbuf, PG_DIAG_SQLSTATE); - pq_sendstring(&msgbuf, tbuf); + err_sendstring(&msgbuf, tbuf); /* M field is required per protocol, so always send something */ pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_PRIMARY); if (edata->message) - pq_sendstring(&msgbuf, edata->message); + err_sendstring(&msgbuf, edata->message); else - pq_sendstring(&msgbuf, _("missing error text")); + err_sendstring(&msgbuf, _("missing error text")); if (edata->detail) { pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_DETAIL); - pq_sendstring(&msgbuf, edata->detail); + err_sendstring(&msgbuf, edata->detail); } if (edata->hint) { pq_sendbyte(&msgbuf, PG_DIAG_MESSAGE_HINT); - pq_sendstring(&msgbuf, edata->hint); + err_sendstring(&msgbuf, edata->hint); } if (edata->context) { pq_sendbyte(&msgbuf, PG_DIAG_CONTEXT); - pq_sendstring(&msgbuf, edata->context); + err_sendstring(&msgbuf, edata->context); } if (edata->cursorpos > 0) { snprintf(tbuf, sizeof(tbuf), "%d", edata->cursorpos); pq_sendbyte(&msgbuf, PG_DIAG_STATEMENT_POSITION); - pq_sendstring(&msgbuf, tbuf); + err_sendstring(&msgbuf, tbuf); } if (edata->internalpos > 0) { snprintf(tbuf, sizeof(tbuf), "%d", edata->internalpos); pq_sendbyte(&msgbuf, PG_DIAG_INTERNAL_POSITION); - pq_sendstring(&msgbuf, tbuf); + err_sendstring(&msgbuf, tbuf); } if (edata->internalquery) { pq_sendbyte(&msgbuf, PG_DIAG_INTERNAL_QUERY); - pq_sendstring(&msgbuf, edata->internalquery); + err_sendstring(&msgbuf, edata->internalquery); } if (edata->filename) { pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_FILE); - pq_sendstring(&msgbuf, edata->filename); + err_sendstring(&msgbuf, edata->filename); } if (edata->lineno > 0) { snprintf(tbuf, sizeof(tbuf), "%d", edata->lineno); pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_LINE); - pq_sendstring(&msgbuf, tbuf); + err_sendstring(&msgbuf, tbuf); } if (edata->funcname) { pq_sendbyte(&msgbuf, PG_DIAG_SOURCE_FUNCTION); - pq_sendstring(&msgbuf, edata->funcname); + err_sendstring(&msgbuf, edata->funcname); } pq_sendbyte(&msgbuf, '\0'); /* terminator */ @@ -1917,7 +1959,7 @@ send_message_to_frontend(ErrorData *edata) appendStringInfoChar(&buf, '\n'); - pq_sendstring(&msgbuf, buf.data); + err_sendstring(&msgbuf, buf.data); pfree(buf.data); } @@ -2032,10 +2074,6 @@ useful_strerror(int errnum) /* * error_severity --- get localized string representing elevel - * - * Note: in an error recursion situation, we stop localizing the tags - * for ERROR and above. This is necessary because the problem might be - * failure to convert one of these strings to the client encoding. */ static const char * error_severity(int elevel) @@ -2065,22 +2103,13 @@ error_severity(int elevel) prefix = _("WARNING"); break; case ERROR: - if (in_error_recursion_trouble()) - prefix = "ERROR"; - else - prefix = _("ERROR"); + prefix = _("ERROR"); break; case FATAL: - if (in_error_recursion_trouble()) - prefix = "FATAL"; - else - prefix = _("FATAL"); + prefix = _("FATAL"); break; case PANIC: - if (in_error_recursion_trouble()) - prefix = "PANIC"; - else - prefix = _("PANIC"); + prefix = _("PANIC"); break; default: prefix = "???"; diff --git a/src/backend/utils/mb/wchar.c b/src/backend/utils/mb/wchar.c index 793d5d6e65..40af527949 100644 --- a/src/backend/utils/mb/wchar.c +++ b/src/backend/utils/mb/wchar.c @@ -1412,20 +1412,7 @@ report_untranslatable_char(int src_encoding, int dest_encoding, for (j = 0; j < jlimit; j++) p += sprintf(p, "%02x", (unsigned char) mbstr[j]); - /* - * In an error recursion situation, don't try to translate the message. - * This gets us out of trouble if the problem is failure to convert - * this very message (after translation) to the client encoding. - */ - if (in_error_recursion_trouble()) - ereport(ERROR, - (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER), - errmsg_internal("character 0x%s of encoding \"%s\" has no equivalent in \"%s\"", - buf, - pg_enc2name_tbl[src_encoding].name, - pg_enc2name_tbl[dest_encoding].name))); - else - ereport(ERROR, + ereport(ERROR, (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER), errmsg("character 0x%s of encoding \"%s\" has no equivalent in \"%s\"", buf, diff --git a/src/include/libpq/pqformat.h b/src/include/libpq/pqformat.h index aee111ee7d..4e83deb1f7 100644 --- a/src/include/libpq/pqformat.h +++ b/src/include/libpq/pqformat.h @@ -22,6 +22,7 @@ extern void pq_sendcountedtext(StringInfo buf, const char *str, int slen, bool countincludesself); extern void pq_sendtext(StringInfo buf, const char *str, int slen); extern void pq_sendstring(StringInfo buf, const char *str); +extern void pq_send_ascii_string(StringInfo buf, const char *str); extern void pq_sendint(StringInfo buf, int i, int b); extern void pq_sendint64(StringInfo buf, int64 i); extern void pq_sendfloat4(StringInfo buf, float4 f);