mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

config: use unsigned_mult_overflows to check for overflows

Browse Source 
parse_unit_factor() checks if a K, M or G is present after a number and
multiplies it by 2^10, 2^20 or 2^30, respectively.  One of its callers
checks if the result is smaller than the number alone to detect
overflows.  The other one passes 1 as the number and does multiplication
and overflow check itself in a similar manner.

This works, but is inconsistent, and it would break if we added support
for a bigger unit factor.  E.g. 16777217T is 2^64 + 2^40, i.e. too big
for a 64-bit number.  Modulo 2^64 we get 2^40 == 1TB, which is bigger
than the raw number 16777217 == 2^24 + 1, so the overflow would go
undetected by that method.

Let both callers pass 1 and handle overflow check and multiplication
themselves.  Do the check before the multiplication, using
unsigned_mult_overflows, which is simpler and can deal with larger unit
factors.

Signed-off-by: Rene Scharfe <l.s.r@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
René Scharfe
2019-06-22 12:03:30 +02:00
committed by Junio C Hamano
parent 9dae4fe79f
commit 3fb72c7b4d
1 changed files with 7 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
config.c
View File

@ -870,8 +870,8 @@ static int git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
return 0; return 0;
} }
uval = val < 0 ? -val : val; uval = val < 0 ? -val : val;
uval *= factor; if (unsigned_mult_overflows(factor, uval) ||
if (uval > max || (val < 0 ? -val : val) > uval) { factor * uval > max) {
errno = ERANGE; errno = ERANGE;
return 0; return 0;
} }
@ -888,21 +888,22 @@ static int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
if (value && *value) { if (value && *value) {
char *end; char *end;
uintmax_t val; uintmax_t val;
uintmax_t oldval; uintmax_t factor = 1;
errno = 0; errno = 0;
val = strtoumax(value, &end, 0); val = strtoumax(value, &end, 0);
if (errno == ERANGE) if (errno == ERANGE)
return 0; return 0;
oldval = val; if (!parse_unit_factor(end, &factor)) {
if (!parse_unit_factor(end, &val)) {
errno = EINVAL; errno = EINVAL;
return 0; return 0;
} }
if (val > max || oldval > val) { if (unsigned_mult_overflows(factor, val) ||
factor * val > max) {
errno = ERANGE; errno = ERANGE;
return 0; return 0;
} }
val *= factor;
*ret = val; *ret = val;
return 1; return 1;
} }