Prevent integer overflows during units conversion when displaying a GUC

tglsfdc · tglsfdc · commit fbcc69c192a0 · 2008-07-06T19:48:45.000Z
variable that has units.  Per report from Stefan Kaltenbrunner.

Backport to 8.2.  I also backported my patch of 2007-06-21 that prevented
comparable overflows on the input side, since that now seems to have enough
field track record to be back-patched safely.  That patch included addition
of hints listing the available unit names, which I did not bother to strip
out of it --- this will make a little more work for the translators, but
they can copy the translation from 8.3, and anyway an untranslated hint
is better than no hint.
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
@@ -10,7 +10,7 @@
  * Written by Peter Eisentraut <peter_e@gmx.net>.
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.461 2008/07/01 21:07:33 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.462 2008/07/06 19:48:45 tgl Exp $
  *
  *--------------------------------------------------------------------
  */
@@ -6266,10 +6266,18 @@ _ShowOption(struct config_generic * record, bool use_units)
 					val = (*conf->show_hook) ();
 				else
 				{
-					char		unit[4];
-					int			result = *conf->variable;
+					/*
+					 * Use int64 arithmetic to avoid overflows in units
+					 * conversion.  If INT64_IS_BUSTED we might overflow
+					 * anyway and print bogus answers, but there are few
+					 * enough such machines that it doesn't seem worth
+					 * trying harder.
+					 */
+					int64		result = *conf->variable;
+					const char *unit;
 
-					if (use_units && result > 0 && (record->flags & GUC_UNIT_MEMORY))
+					if (use_units && result > 0 &&
+						(record->flags & GUC_UNIT_MEMORY))
 					{
 						switch (record->flags & GUC_UNIT_MEMORY)
 						{
@@ -6284,19 +6292,20 @@ _ShowOption(struct config_generic * record, bool use_units)
 						if (result % KB_PER_GB == 0)
 						{
 							result /= KB_PER_GB;
-							strcpy(unit, "GB");
+							unit = "GB";
 						}
 						else if (result % KB_PER_MB == 0)
 						{
 							result /= KB_PER_MB;
-							strcpy(unit, "MB");
+							unit = "MB";
 						}
 						else
 						{
-							strcpy(unit, "kB");
+							unit = "kB";
 						}
 					}
-					else if (use_units && result > 0 && (record->flags & GUC_UNIT_TIME))
+					else if (use_units && result > 0 &&
+							 (record->flags & GUC_UNIT_TIME))
 					{
 						switch (record->flags & GUC_UNIT_TIME)
 						{
@@ -6311,33 +6320,33 @@ _ShowOption(struct config_generic * record, bool use_units)
 						if (result % MS_PER_D == 0)
 						{
 							result /= MS_PER_D;
-							strcpy(unit, "d");
+							unit = "d";
 						}
 						else if (result % MS_PER_H == 0)
 						{
 							result /= MS_PER_H;
-							strcpy(unit, "h");
+							unit = "h";
 						}
 						else if (result % MS_PER_MIN == 0)
 						{
 							result /= MS_PER_MIN;
-							strcpy(unit, "min");
+							unit = "min";
 						}
 						else if (result % MS_PER_S == 0)
 						{
 							result /= MS_PER_S;
-							strcpy(unit, "s");
+							unit = "s";
 						}
 						else
 						{
-							strcpy(unit, "ms");
+							unit = "ms";
 						}
 					}
 					else
-						strcpy(unit, "");
+						unit = "";
 
-					snprintf(buffer, sizeof(buffer), "%d%s",
-							 (int) result, unit);
+					snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
+							 result, unit);
 					val = buffer;
 				}
 			}

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`* Written by Peter Eisentraut <peter_e@gmx.net>.`
`11`	`11`	`*`
`12`	`12`	`* IDENTIFICATION`
`13`		`- * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.461 2008/07/01 21:07:33 tgl Exp $`
	`13`	`+ * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.462 2008/07/06 19:48:45 tgl Exp $`
`14`	`14`	`*`
`15`	`15`	`*--------------------------------------------------------------------`
`16`	`16`	`*/`
`@@ -6266,10 +6266,18 @@ _ShowOption(struct config_generic * record, bool use_units)`
`6266`	`6266`	`val = (*conf->show_hook) ();`
`6267`	`6267`	`else`
`6268`	`6268`	`{`
`6269`		`- char unit[4];`
`6270`		`- int result = *conf->variable;`
	`6269`	`+ /*`
	`6270`	`+ * Use int64 arithmetic to avoid overflows in units`
	`6271`	`+ * conversion. If INT64_IS_BUSTED we might overflow`
	`6272`	`+ * anyway and print bogus answers, but there are few`
	`6273`	`+ * enough such machines that it doesn't seem worth`
	`6274`	`+ * trying harder.`
	`6275`	`+ */`
	`6276`	`+ int64 result = *conf->variable;`
	`6277`	`+ const char *unit;`
`6271`	`6278`
`6272`		`- if (use_units && result > 0 && (record->flags & GUC_UNIT_MEMORY))`
	`6279`	`+ if (use_units && result > 0 &&`
	`6280`	`+ (record->flags & GUC_UNIT_MEMORY))`
`6273`	`6281`	`{`
`6274`	`6282`	`switch (record->flags & GUC_UNIT_MEMORY)`
`6275`	`6283`	`{`
`@@ -6284,19 +6292,20 @@ _ShowOption(struct config_generic * record, bool use_units)`
`6284`	`6292`	`if (result % KB_PER_GB == 0)`
`6285`	`6293`	`{`
`6286`	`6294`	`result /= KB_PER_GB;`
`6287`		`- strcpy(unit, "GB");`
	`6295`	`+ unit = "GB";`
`6288`	`6296`	`}`
`6289`	`6297`	`else if (result % KB_PER_MB == 0)`
`6290`	`6298`	`{`
`6291`	`6299`	`result /= KB_PER_MB;`
`6292`		`- strcpy(unit, "MB");`
	`6300`	`+ unit = "MB";`
`6293`	`6301`	`}`
`6294`	`6302`	`else`
`6295`	`6303`	`{`
`6296`		`- strcpy(unit, "kB");`
	`6304`	`+ unit = "kB";`
`6297`	`6305`	`}`
`6298`	`6306`	`}`
`6299`		`- else if (use_units && result > 0 && (record->flags & GUC_UNIT_TIME))`
	`6307`	`+ else if (use_units && result > 0 &&`
	`6308`	`+ (record->flags & GUC_UNIT_TIME))`
`6300`	`6309`	`{`
`6301`	`6310`	`switch (record->flags & GUC_UNIT_TIME)`
`6302`	`6311`	`{`
`@@ -6311,33 +6320,33 @@ _ShowOption(struct config_generic * record, bool use_units)`
`6311`	`6320`	`if (result % MS_PER_D == 0)`
`6312`	`6321`	`{`
`6313`	`6322`	`result /= MS_PER_D;`
`6314`		`- strcpy(unit, "d");`
	`6323`	`+ unit = "d";`
`6315`	`6324`	`}`
`6316`	`6325`	`else if (result % MS_PER_H == 0)`
`6317`	`6326`	`{`
`6318`	`6327`	`result /= MS_PER_H;`
`6319`		`- strcpy(unit, "h");`
	`6328`	`+ unit = "h";`
`6320`	`6329`	`}`
`6321`	`6330`	`else if (result % MS_PER_MIN == 0)`
`6322`	`6331`	`{`
`6323`	`6332`	`result /= MS_PER_MIN;`
`6324`		`- strcpy(unit, "min");`
	`6333`	`+ unit = "min";`
`6325`	`6334`	`}`
`6326`	`6335`	`else if (result % MS_PER_S == 0)`
`6327`	`6336`	`{`
`6328`	`6337`	`result /= MS_PER_S;`
`6329`		`- strcpy(unit, "s");`
	`6338`	`+ unit = "s";`
`6330`	`6339`	`}`
`6331`	`6340`	`else`
`6332`	`6341`	`{`
`6333`		`- strcpy(unit, "ms");`
	`6342`	`+ unit = "ms";`
`6334`	`6343`	`}`
`6335`	`6344`	`}`
`6336`	`6345`	`else`
`6337`		`- strcpy(unit, "");`
	`6346`	`+ unit = "";`
`6338`	`6347`
`6339`		`- snprintf(buffer, sizeof(buffer), "%d%s",`
`6340`		`- (int) result, unit);`
	`6348`	`+ snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",`
	`6349`	`+ result, unit);`
`6341`	`6350`	`val = buffer;`
`6342`	`6351`	`}`
`6343`	`6352`	`}`