I started out with the idea that we needed to detect use of %m format specs
in contexts other than elog/ereport calls, because we couldn't rely on that
working in *printf calls. But a better answer is to fix things so that it
does work. Now that we're using snprintf.c all the time, we can implement
%m in that and we've fixed the problem.
This requires also adjusting our various printf-wrapping functions so that
they ensure "errno" is preserved when they call snprintf.c.
Remove elog.c's handmade implementation of %m, and let it rely on
snprintf to support the feature. That should provide some performance
gain, though I've not attempted to measure it.
There are a lot of places where we could now simplify 'printf("%s",
strerror(errno))' into 'printf("%m")', but I'm not in any big hurry
to make that happen.
Patch by me, reviewed by Michael Paquier
Discussion: https://postgr.es/m/2975.
1526862605@sss.pgh.pa.us
void
appendStringInfo(StringInfo str, const char *fmt,...)
{
+ int save_errno = errno;
+
for (;;)
{
va_list args;
int needed;
/* Try to format the data. */
+ errno = save_errno;
va_start(args, fmt);
needed = appendStringInfoVA(str, fmt, args);
va_end(args);
* pass the return value to enlargeStringInfo() before trying again; see
* appendStringInfo for standard usage pattern.
*
+ * Caution: callers must be sure to preserve their entry-time errno
+ * when looping, in case the fmt contains "%m".
+ *
* XXX This API is ugly, but there seems no alternative given the C spec's
* restrictions on what can portably be done with va_list arguments: you have
* to redo va_start before you can rescan the argument list, and we can't do
static void send_message_to_server_log(ErrorData *edata);
static void write_pipe_chunks(char *data, int len, int dest);
static void send_message_to_frontend(ErrorData *edata);
-static char *expand_fmt_string(const char *fmt, ErrorData *edata);
static const char *error_severity(int elevel);
static void append_with_tabs(StringInfo buf, const char *str);
static bool is_log_level_output(int elevel, int log_min_level);
*/
#define EVALUATE_MESSAGE(domain, targetfield, appendval, translateit) \
{ \
- char *fmtbuf; \
StringInfoData buf; \
/* Internationalize the error format string */ \
if ((translateit) && !in_error_recursion_trouble()) \
fmt = dgettext((domain), fmt); \
- /* Expand %m in format string */ \
- fmtbuf = expand_fmt_string(fmt, edata); \
initStringInfo(&buf); \
if ((appendval) && edata->targetfield) { \
appendStringInfoString(&buf, edata->targetfield); \
{ \
va_list args; \
int needed; \
+ errno = edata->saved_errno; \
va_start(args, fmt); \
- needed = appendStringInfoVA(&buf, fmtbuf, args); \
+ needed = appendStringInfoVA(&buf, fmt, args); \
va_end(args); \
if (needed == 0) \
break; \
enlargeStringInfo(&buf, needed); \
} \
- /* Done with expanded fmt */ \
- pfree(fmtbuf); \
/* Save the completed message into the stack item */ \
if (edata->targetfield) \
pfree(edata->targetfield); \
#define EVALUATE_MESSAGE_PLURAL(domain, targetfield, appendval) \
{ \
const char *fmt; \
- char *fmtbuf; \
StringInfoData buf; \
/* Internationalize the error format string */ \
if (!in_error_recursion_trouble()) \
fmt = dngettext((domain), fmt_singular, fmt_plural, n); \
else \
fmt = (n == 1 ? fmt_singular : fmt_plural); \
- /* Expand %m in format string */ \
- fmtbuf = expand_fmt_string(fmt, edata); \
initStringInfo(&buf); \
if ((appendval) && edata->targetfield) { \
appendStringInfoString(&buf, edata->targetfield); \
{ \
va_list args; \
int needed; \
+ errno = edata->saved_errno; \
va_start(args, n); \
- needed = appendStringInfoVA(&buf, fmtbuf, args); \
+ needed = appendStringInfoVA(&buf, fmt, args); \
va_end(args); \
if (needed == 0) \
break; \
enlargeStringInfo(&buf, needed); \
} \
- /* Done with expanded fmt */ \
- pfree(fmtbuf); \
/* Save the completed message into the stack item */ \
if (edata->targetfield) \
pfree(edata->targetfield); \
*/
-/*
- * expand_fmt_string --- process special format codes in a format string
- *
- * We must replace %m with the appropriate strerror string, since vsnprintf
- * won't know what to do with it.
- *
- * The result is a palloc'd string.
- */
-static char *
-expand_fmt_string(const char *fmt, ErrorData *edata)
-{
- StringInfoData buf;
- const char *cp;
-
- initStringInfo(&buf);
-
- for (cp = fmt; *cp; cp++)
- {
- if (cp[0] == '%' && cp[1] != '\0')
- {
- cp++;
- if (*cp == 'm')
- {
- /*
- * Replace %m by system error string. If there are any %'s in
- * the string, we'd better double them so that vsnprintf won't
- * misinterpret.
- */
- const char *cp2;
-
- cp2 = strerror(edata->saved_errno);
- for (; *cp2; cp2++)
- {
- if (*cp2 == '%')
- appendStringInfoCharMacro(&buf, '%');
- appendStringInfoCharMacro(&buf, *cp2);
- }
- }
- else
- {
- /* copy % and next char --- this avoids trouble with %%m */
- appendStringInfoCharMacro(&buf, '%');
- appendStringInfoCharMacro(&buf, *cp);
- }
- }
- else
- appendStringInfoCharMacro(&buf, *cp);
- }
-
- return buf.data;
-}
-
-
/*
* error_severity --- get string representing elevel
*
int
archprintf(Archive *AH, const char *fmt,...)
{
+ int save_errno = errno;
char *p;
size_t len = 128; /* initial assumption about buffer size */
size_t cnt;
p = (char *) pg_malloc(len);
/* Try to format the data. */
+ errno = save_errno;
va_start(args, fmt);
cnt = pvsnprintf(p, len, fmt, args);
va_end(args);
int
ahprintf(ArchiveHandle *AH, const char *fmt,...)
{
+ int save_errno = errno;
char *p;
size_t len = 128; /* initial assumption about buffer size */
size_t cnt;
p = (char *) pg_malloc(len);
/* Try to format the data. */
+ errno = save_errno;
va_start(args, fmt);
cnt = pvsnprintf(p, len, fmt, args);
va_end(args);
static int
tarPrintf(ArchiveHandle *AH, TAR_MEMBER *th, const char *fmt,...)
{
+ int save_errno = errno;
char *p;
size_t len = 128; /* initial assumption about buffer size */
size_t cnt;
p = (char *) pg_malloc(len);
/* Try to format the data. */
+ errno = save_errno;
va_start(args, fmt);
cnt = pvsnprintf(p, len, fmt, args);
va_end(args);
char *
psprintf(const char *fmt,...)
{
+ int save_errno = errno;
size_t len = 128; /* initial assumption about buffer size */
for (;;)
result = (char *) palloc(len);
/* Try to format the data. */
+ errno = save_errno;
va_start(args, fmt);
newlen = pvsnprintf(result, len, fmt, args);
va_end(args);
* Other error cases do not return, but exit via elog(ERROR) or exit().
* Hence, this shouldn't be used inside libpq.
*
+ * Caution: callers must be sure to preserve their entry-time errno
+ * when looping, in case the fmt contains "%m".
+ *
* Note that the semantics of the return value are not exactly C99's.
* First, we don't promise that the estimated buffer size is exactly right;
* callers must be prepared to loop multiple times to get the right size.
void
printfPQExpBuffer(PQExpBuffer str, const char *fmt,...)
{
+ int save_errno = errno;
va_list args;
bool done;
/* Loop in case we have to retry after enlarging the buffer. */
do
{
+ errno = save_errno;
va_start(args, fmt);
done = appendPQExpBufferVA(str, fmt, args);
va_end(args);
void
appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)
{
+ int save_errno = errno;
va_list args;
bool done;
/* Loop in case we have to retry after enlarging the buffer. */
do
{
+ errno = save_errno;
va_start(args, fmt);
done = appendPQExpBufferVA(str, fmt, args);
va_end(args);
* Shared guts of printfPQExpBuffer/appendPQExpBuffer.
* Attempt to format data and append it to str. Returns true if done
* (either successful or hard failure), false if need to retry.
+ *
+ * Caution: callers must be sure to preserve their entry-time errno
+ * when looping, in case the fmt contains "%m".
*/
static bool
appendPQExpBufferVA(PQExpBuffer str, const char *fmt, va_list args)
void
PLy_elog_impl(int elevel, const char *fmt,...)
{
+ int save_errno = errno;
char *xmsg;
char *tbmsg;
int tb_depth;
va_list ap;
int needed;
+ errno = save_errno;
va_start(ap, fmt);
needed = appendStringInfoVA(&emsg, dgettext(TEXTDOMAIN, fmt), ap);
va_end(ap);
*
* 5. Space and '#' flags are not implemented.
*
+ * In addition, we support some extensions over C99:
+ *
+ * 1. Argument order control through "%n$" and "*n$", as required by POSIX.
+ *
+ * 2. "%m" expands to the value of strerror(errno), where errno is the
+ * value that variable had at the start of the call. This is a glibc
+ * extension, but a very useful one.
+ *
*
* Historically the result values of sprintf/snprintf varied across platforms.
* This implementation now follows the C99 standard:
static void dopr(PrintfTarget *target, const char *format, va_list args);
+/*
+ * Externally visible entry points.
+ *
+ * All of these are just wrappers around dopr(). Note it's essential that
+ * they not change the value of "errno" before reaching dopr().
+ */
+
int
pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args)
{
/*
- * dopr(): poor man's version of doprintf
+ * dopr(): the guts of *printf for all cases.
*/
static void
dopr(PrintfTarget *target, const char *format, va_list args)
{
+ int save_errno = errno;
const char *format_start = format;
int ch;
bool have_dollar;
else
have_non_dollar = true;
break;
+ case 'm':
case '%':
break;
}
precision, pointflag,
target);
break;
+ case 'm':
+ {
+ char errbuf[PG_STRERROR_R_BUFLEN];
+ const char *errm = strerror_r(save_errno,
+ errbuf, sizeof(errbuf));
+
+ dostr(errm, strlen(errm), target);
+ }
+ break;
case '%':
dopr_outch('%', target);
break;
projects / postgresql.git / commitdiff