* [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01
@ 2023-06-02 17:33 Eric Blake
2023-06-02 17:33 ` [PULL v2 06/21] test-cutils: Test more integer corner cases Eric Blake
` (2 more replies)
0 siblings, 3 replies; 4+ messages in thread
From: Eric Blake @ 2023-06-02 17:33 UTC (permalink / raw)
To: qemu-devel
The following changes since commit a86d7b9ec0adb2f1efce8ab30d9ed2b72db0236e:
Merge tag 'migration-20230601-pull-request' of https://gitlab.com/juan.quintela/qemu into staging (2023-06-01 20:59:28 -0700)
are available in the Git repository at:
https://repo.or.cz/qemu/ericb.git tags/pull-nbd-2023-06-01-v2
for you to fetch changes up to 42cc08d13ab8e68f76882b216da0b28d06f29e11:
cutils: Improve qemu_strtosz handling of fractions (2023-06-02 12:29:27 -0500)
In v2:
- fix build failure on mingw [CI, via Richard]
- drop dead comparisons to UINT64_MAX [Markus]
only the changed patches are re-posted
----------------------------------------------------------------
nbd and misc patches for 2023-06-01
- Eric Blake: Fix iotest 104 for NBD
- Eric Blake: Improve qcow2 spec on padding bytes
- Eric Blake: Fix read-beyond-bounds bug in qemu_strtosz
----------------------------------------------------------------
Eric Blake (21):
iotests: Fix test 104 under NBD
qcow2: Explicit mention of padding bytes
test-cutils: Avoid g_assert in unit tests
test-cutils: Use g_assert_cmpuint where appropriate
test-cutils: Test integral qemu_strto* value on failures
test-cutils: Test more integer corner cases
cutils: Fix wraparound parsing in qemu_strtoui
cutils: Document differences between parse_uint and qemu_strtou64
cutils: Adjust signature of parse_uint[_full]
cutils: Allow NULL endptr in parse_uint()
test-cutils: Add coverage of qemu_strtod
test-cutils: Prepare for upcoming semantic change in qemu_strtosz
test-cutils: Refactor qemu_strtosz tests for less boilerplate
cutils: Allow NULL str in qemu_strtosz
numa: Check for qemu_strtosz_MiB error
test-cutils: Add more coverage to qemu_strtosz
cutils: Set value in all qemu_strtosz* error paths
cutils: Set value in all integral qemu_strto* error paths
cutils: Use parse_uint in qemu_strtosz for negative rejection
cutils: Improve qemu_strtod* error paths
cutils: Improve qemu_strtosz handling of fractions
docs/interop/qcow2.txt | 1 +
include/qemu/cutils.h | 5 +-
audio/audio_legacy.c | 4 +-
block/gluster.c | 4 +-
block/nfs.c | 4 +-
blockdev.c | 4 +-
contrib/ivshmem-server/main.c | 4 +-
hw/core/numa.c | 11 +-
qapi/opts-visitor.c | 12 +-
tests/unit/test-cutils.c | 2469 ++++++++++++++++++++++++++++----------
ui/vnc.c | 4 +-
util/cutils.c | 263 ++--
util/guest-random.c | 4 +-
util/qemu-sockets.c | 10 +-
tests/qemu-iotests/common.filter | 4 +-
tests/qemu-iotests/common.rc | 3 +-
tests/qemu-iotests/049.out | 7 +-
tests/qemu-iotests/178.out.qcow2 | 3 +-
tests/qemu-iotests/178.out.raw | 3 +-
19 files changed, 2036 insertions(+), 783 deletions(-)
--
2.40.1
^ permalink raw reply [flat|nested] 4+ messages in thread
* [PULL v2 06/21] test-cutils: Test more integer corner cases
2023-06-02 17:33 [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01 Eric Blake
@ 2023-06-02 17:33 ` Eric Blake
2023-06-02 17:33 ` [PULL v2 09/21] cutils: Adjust signature of parse_uint[_full] Eric Blake
2023-06-03 0:33 ` [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01 Richard Henderson
2 siblings, 0 replies; 4+ messages in thread
From: Eric Blake @ 2023-06-02 17:33 UTC (permalink / raw)
To: qemu-devel; +Cc: Hanna Czenczek
We have quite a few undertested and underdocumented integer parsing
corner cases. To ensure that any changes we make in the code are
intentional rather than accidental semantic changes, it is time to add
more unit tests of existing behavior.
In particular, this demonstrates that parse_uint() and qemu_strtou64()
behave differently. For "-0", it's hard to argue why parse_uint needs
to reject it (it's not a negative integer), but the documentation sort
of mentions it; but it is intentional that all other negative values
are treated as ERANGE with value 0 (compared to qemu_strtou64()
treating "-2" as success and UINT64_MAX-1, for example).
Also, when mixing overflow/underflow with a check for no trailing
junk, parse_uint_full favors ERANGE over EINVAL, while qemu_strto[iu]*
favor EINVAL. This behavior is outside the C standard, so we can pick
whatever we want, but it would be nice to be consistent.
Note that C requires that "9223372036854775808" fail strtoll() with
ERANGE/INT64_MAX, but "-9223372036854775808" pass with INT64_MIN; we
weren't testing this. For strtol(), the behavior depends on whether
long is 32- or 64-bits (the cutoff point either being the same as
strtoll() or at "-2147483648"). Meanwhile, C is clear that
"-18446744073709551615" pass stroull() (but not strtoll) with value 1,
even though we want it to fail parse_uint(). And although
qemu_strtoui() has no C counterpart, it makes more sense if we design
it like 32-bit strtoul() (that is, where "-4294967296" be an alternate
acceptable spelling for "1", but "-0xffffffff00000001" should be
treated as overflow and return 0xffffffff rather than 1). We aren't
there yet, so some of the tests added in this patch have FIXME
comments.
However, note that C2x will (likely) be adding a SILENT semantic
change, where C17 strtol("0b1", &ep, 2) returns 0 with ep="b1", but
C2x will have it return 1 with ep="". I did not feel like adding
testing for those corner cases, in part because the next version of C
is not standard and libc support for binary parsing is not yet
wide-spread (as of this patch, glibc.git still misparses bare "0b":
https://sourceware.org/bugzilla/show_bug.cgi?id=30371).
Message-Id: <20230522190441.64278-5-eblake@redhat.com>
[eblake: fix a few typos spotted by Hanna]
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
[eblake: fix typo on platforms with 32-bit long]
Signed-off-by: Eric Blake <eblake@redhat.com>
---
tests/unit/test-cutils.c | 929 ++++++++++++++++++++++++++++++++++++---
1 file changed, 864 insertions(+), 65 deletions(-)
diff --git a/tests/unit/test-cutils.c b/tests/unit/test-cutils.c
index 1eeaf21ae22..30cb5f122c7 100644
--- a/tests/unit/test-cutils.c
+++ b/tests/unit/test-cutils.c
@@ -150,7 +150,6 @@ static void test_parse_uint_decimal(void)
g_assert_true(endptr == str + strlen(str));
}
-
static void test_parse_uint_llong_max(void)
{
unsigned long long i = 999;
@@ -168,27 +167,87 @@ static void test_parse_uint_llong_max(void)
g_free(str);
}
+static void test_parse_uint_max(void)
+{
+ unsigned long long i = 999;
+ char f = 'X';
+ char *endptr = &f;
+ char *str = g_strdup_printf("%llu", ULLONG_MAX);
+ int r;
+
+ r = parse_uint(str, &i, &endptr, 0);
+
+ g_assert_cmpint(r, ==, 0);
+ g_assert_cmpuint(i, ==, ULLONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ g_free(str);
+}
+
static void test_parse_uint_overflow(void)
{
- unsigned long long i = 999;
+ unsigned long long i;
char f = 'X';
- char *endptr = &f;
- const char *str = "99999999999999999999999999999999999999";
+ char *endptr;
+ const char *str;
int r;
+ i = 999;
+ endptr = &f;
+ str = "99999999999999999999999999999999999999";
r = parse_uint(str, &i, &endptr, 0);
+ g_assert_cmpint(r, ==, -ERANGE);
+ g_assert_cmpuint(i, ==, ULLONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ i = 999;
+ endptr = &f;
+ str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
+ r = parse_uint(str, &i, &endptr, 0);
+ g_assert_cmpint(r, ==, -ERANGE);
+ g_assert_cmpuint(i, ==, ULLONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ i = 999;
+ endptr = &f;
+ str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
+ r = parse_uint(str, &i, &endptr, 0);
g_assert_cmpint(r, ==, -ERANGE);
g_assert_cmpuint(i, ==, ULLONG_MAX);
g_assert_true(endptr == str + strlen(str));
}
static void test_parse_uint_negative(void)
+{
+ unsigned long long i;
+ char f = 'X';
+ char *endptr;
+ const char *str;
+ int r;
+
+ i = 999;
+ endptr = &f;
+ str = " \t -321";
+ r = parse_uint(str, &i, &endptr, 0);
+ g_assert_cmpint(r, ==, -ERANGE);
+ g_assert_cmpuint(i, ==, 0);
+ g_assert_true(endptr == str + strlen(str));
+
+ i = 999;
+ endptr = &f;
+ str = "-0xffffffff00000001";
+ r = parse_uint(str, &i, &endptr, 0);
+ g_assert_cmpint(r, ==, -ERANGE);
+ g_assert_cmpuint(i, ==, 0);
+ g_assert_true(endptr == str + strlen(str));
+}
+
+static void test_parse_uint_negzero(void)
{
unsigned long long i = 999;
char f = 'X';
char *endptr = &f;
- const char *str = " \t -321";
+ const char *str = " -0";
int r;
r = parse_uint(str, &i, &endptr, 0);
@@ -198,7 +257,6 @@ static void test_parse_uint_negative(void)
g_assert_true(endptr == str + strlen(str));
}
-
static void test_parse_uint_full_trailing(void)
{
unsigned long long i = 999;
@@ -223,6 +281,19 @@ static void test_parse_uint_full_correct(void)
g_assert_cmpuint(i, ==, 123);
}
+static void test_parse_uint_full_erange_junk(void)
+{
+ /* FIXME - inconsistent with qemu_strto* which favors EINVAL */
+ unsigned long long i = 999;
+ const char *str = "-2junk";
+ int r;
+
+ r = parse_uint_full(str, &i, 0);
+
+ g_assert_cmpint(r, ==, -ERANGE /* FIXME -EINVAL */);
+ g_assert_cmpuint(i, ==, 0);
+}
+
static void test_qemu_strtoi_correct(void)
{
const char *str = "12345 foo";
@@ -410,7 +481,55 @@ static void test_qemu_strtoi_max(void)
static void test_qemu_strtoi_overflow(void)
{
- char *str = g_strdup_printf("%lld", (long long)INT_MAX + 1ll);
+ const char *str;
+ const char *endptr;
+ int res;
+ int err;
+
+ str = "2147483648"; /* INT_MAX + 1ll */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x7fffffffffffffff"; /* LLONG_MAX */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x8000000000000000"; /* (uint64_t)LLONG_MIN */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x18000000080000000"; /* 65 bits, 32-bit sign bit set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+}
+
+static void test_qemu_strtoi_min(void)
+{
+ char *str = g_strdup_printf("%d", INT_MIN);
char f = 'X';
const char *endptr = &f;
int res = 999;
@@ -418,31 +537,95 @@ static void test_qemu_strtoi_overflow(void)
err = qemu_strtoi(str, &endptr, 0, &res);
- g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmpint(res, ==, INT_MAX);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, INT_MIN);
g_assert_true(endptr == str + strlen(str));
g_free(str);
}
static void test_qemu_strtoi_underflow(void)
{
- char *str = g_strdup_printf("%lld", (long long)INT_MIN - 1ll);
- char f = 'X';
- const char *endptr = &f;
- int res = 999;
+ const char *str;
+ const char *endptr;
+ int res;
int err;
+ str = "-2147483649"; /* INT_MIN - 1ll */
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MIN);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x7fffffffffffffff"; /* -LLONG_MAX */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MIN);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x8000000000000000"; /* (uint64_t)LLONG_MIN */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MIN);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-18446744073709551615"; /* -UINT64_MAX (not 1) */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MIN);
+ g_assert_true(endptr == str + strlen(str));
+ str = "-0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT_MIN);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x18000000080000000"; /* 65 bits, 32-bit sign bit set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
g_assert_cmpint(res, ==, INT_MIN);
g_assert_true(endptr == str + strlen(str));
- g_free(str);
}
static void test_qemu_strtoi_negative(void)
{
- const char *str = " \t -321";
+ const char *str;
+ const char *endptr;
+ int res;
+ int err;
+
+ str = " \t -321";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, -321);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-2147483648"; /* INT_MIN */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, INT_MIN);
+ g_assert_true(endptr == str + strlen(str));
+}
+
+static void test_qemu_strtoi_negzero(void)
+{
+ const char *str = " -0";
char f = 'X';
const char *endptr = &f;
int res = 999;
@@ -451,7 +634,7 @@ static void test_qemu_strtoi_negative(void)
err = qemu_strtoi(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, 0);
- g_assert_cmpint(res, ==, -321);
+ g_assert_cmpint(res, ==, 0);
g_assert_true(endptr == str + strlen(str));
}
@@ -505,6 +688,18 @@ static void test_qemu_strtoi_full_negative(void)
g_assert_cmpint(res, ==, -321);
}
+static void test_qemu_strtoi_full_negzero(void)
+{
+ const char *str = " -0";
+ int res = 999;
+ int err;
+
+ err = qemu_strtoi(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, 0);
+}
+
static void test_qemu_strtoi_full_trailing(void)
{
const char *str = "123xxx";
@@ -530,6 +725,19 @@ static void test_qemu_strtoi_full_max(void)
g_free(str);
}
+static void test_qemu_strtoi_full_erange_junk(void)
+{
+ /* EINVAL has priority over ERANGE */
+ const char *str = "-9999999999junk";
+ int res = 999;
+ int err;
+
+ err = qemu_strtoi(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpint(res, ==, INT_MIN);
+}
+
static void test_qemu_strtoui_correct(void)
{
const char *str = "12345 foo";
@@ -699,6 +907,22 @@ static void test_qemu_strtoui_hex(void)
g_assert_true(endptr == str + 1);
}
+static void test_qemu_strtoui_wrap(void)
+{
+ /* FIXME - wraparound should be consistent with 32-bit strtoul */
+ const char *str = "-4294967295"; /* 1 mod 2^32 */
+ char f = 'X';
+ const char *endptr = &f;
+ unsigned int res = 999;
+ int err;
+
+ err = qemu_strtoui(str, &endptr, 0, &res);
+
+ g_assert_cmpint(err, ==, -ERANGE /* FIXME 0 */);
+ g_assert_cmphex(res, ==, UINT_MAX /* FIXME 1 */);
+ g_assert_true(endptr == str + strlen(str));
+}
+
static void test_qemu_strtoui_max(void)
{
char *str = g_strdup_printf("%u", UINT_MAX);
@@ -717,34 +941,116 @@ static void test_qemu_strtoui_max(void)
static void test_qemu_strtoui_overflow(void)
{
- char *str = g_strdup_printf("%lld", (long long)UINT_MAX + 1ll);
- char f = 'X';
- const char *endptr = &f;
- unsigned int res = 999;
+ const char *str;
+ const char *endptr;
+ unsigned int res;
int err;
+ str = "4294967296"; /* UINT_MAX + 1ll */
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x7fffffffffffffff"; /* LLONG_MAX */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x8000000000000000"; /* (uint64_t)LLONG_MIN */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0xffffffff00000001"; /* ULLONG_MAX - UINT_MAX + 1 (not 1) */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ /* FIXME - overflow should be consistent with 32-bit strtoul */
+ str = "0xfffffffffffffffe"; /* ULLONG_MAX - 1 (not UINT_MAX - 1) */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, 0 /* FIXME -ERANGE */);
+ g_assert_cmpuint(res, ==, UINT_MAX - 1 /* FIXME UINT_MAX */);
+ g_assert_true(endptr == str + strlen(str));
+ str = "0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x18000000080000000"; /* 65 bits, 32-bit sign bit set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmphex(res, ==, UINT_MAX);
+ g_assert_cmpuint(res, ==, UINT_MAX);
g_assert_true(endptr == str + strlen(str));
- g_free(str);
}
static void test_qemu_strtoui_underflow(void)
{
- char *str = g_strdup_printf("%lld", (long long)INT_MIN - 1ll);
- char f = 'X';
- const char *endptr = &f;
- unsigned int res = 999;
+ const char *str;
+ const char *endptr;
+ unsigned int res;
int err;
+ str = "-4294967296"; /* -(long long)UINT_MAX - 1ll */
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ /* FIXME - overflow should be consistent with 32-bit strtoul */
+ str = "-18446744073709551615"; /* -UINT64_MAX (not -(-1)) */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, 0 /* FIXME -ERANGE */);
+ g_assert_cmpuint(res, ==, 1 /* FIXME UINT_MAX */);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0xffffffff00000002";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, 0 /* FIXME -ERANGE */);
+ g_assert_cmpuint(res, ==, UINT_MAX - 1 /* FIXME UINT_MAX */);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x18000000080000000"; /* 65 bits, 32-bit sign bit set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoui(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmpuint(res, ==, (unsigned int)-1);
+ g_assert_cmpuint(res, ==, UINT_MAX);
g_assert_true(endptr == str + strlen(str));
- g_free(str);
}
static void test_qemu_strtoui_negative(void)
@@ -762,6 +1068,21 @@ static void test_qemu_strtoui_negative(void)
g_assert_true(endptr == str + strlen(str));
}
+static void test_qemu_strtoui_negzero(void)
+{
+ const char *str = " -0";
+ char f = 'X';
+ const char *endptr = &f;
+ unsigned int res = 999;
+ int err;
+
+ err = qemu_strtoui(str, &endptr, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpuint(res, ==, 0);
+ g_assert_true(endptr == str + strlen(str));
+}
+
static void test_qemu_strtoui_full_correct(void)
{
const char *str = "123";
@@ -808,6 +1129,17 @@ static void test_qemu_strtoui_full_negative(void)
g_assert_cmpuint(res, ==, (unsigned int)-321);
}
+static void test_qemu_strtoui_full_negzero(void)
+{
+ const char *str = " -0";
+ unsigned int res = 999;
+ int err;
+
+ err = qemu_strtoui(str, NULL, 0, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpuint(res, ==, 0);
+}
+
static void test_qemu_strtoui_full_trailing(void)
{
const char *str = "123xxx";
@@ -833,6 +1165,19 @@ static void test_qemu_strtoui_full_max(void)
g_free(str);
}
+static void test_qemu_strtoui_full_erange_junk(void)
+{
+ /* EINVAL has priority over ERANGE */
+ const char *str = "-9999999999junk";
+ unsigned int res = 999;
+ int err;
+
+ err = qemu_strtoui(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpuint(res, ==, UINT_MAX);
+}
+
static void test_qemu_strtol_correct(void)
{
const char *str = "12345 foo";
@@ -1020,7 +1365,50 @@ static void test_qemu_strtol_max(void)
static void test_qemu_strtol_overflow(void)
{
- const char *str = "99999999999999999999999999999999999999999999";
+ const char *str;
+ const char *endptr;
+ long res;
+ int err;
+
+ /* 1 more than LONG_MAX */
+ str = LONG_MAX == INT_MAX ? "2147483648" : "9223372036854775808";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtol(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, LONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ if (LONG_MAX == INT_MAX) {
+ str = "0xffffffff00000001"; /* ULLONG_MAX - UINT_MAX + 1 (not 1) */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtol(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, LONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ }
+
+ str = "0x10000000000000000"; /* 65 bits, either sign bit position clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtol(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, LONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x18000000080000000"; /* 65 bits, either sign bit position set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtol(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, LONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+}
+
+static void test_qemu_strtol_min(void)
+{
+ char *str = g_strdup_printf("%ld", LONG_MIN);
char f = 'X';
const char *endptr = &f;
long res = 999;
@@ -1028,21 +1416,50 @@ static void test_qemu_strtol_overflow(void)
err = qemu_strtol(str, &endptr, 0, &res);
- g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmpint(res, ==, LONG_MAX);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, LONG_MIN);
g_assert_true(endptr == str + strlen(str));
+ g_free(str);
}
static void test_qemu_strtol_underflow(void)
{
- const char *str = "-99999999999999999999999999999999999999999999";
- char f = 'X';
- const char *endptr = &f;
- long res = 999;
+ const char *str;
+ const char *endptr;
+ long res;
int err;
+ /* 1 less than LONG_MIN */
+ str = LONG_MIN == INT_MIN ? "-2147483649" : "-9223372036854775809";
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtol(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, LONG_MIN);
+ g_assert_true(endptr == str + strlen(str));
+ if (LONG_MAX == INT_MAX) {
+ str = "-18446744073709551615"; /* -UINT64_MAX (not 1) */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtol(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, LONG_MIN);
+ g_assert_true(endptr == str + strlen(str));
+ }
+
+ str = "-0x10000000000000000"; /* 65 bits, either sign bit position clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtol(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, LONG_MIN);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x18000000080000000"; /* 65 bits, either sign bit position set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtol(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
g_assert_cmpint(res, ==, LONG_MIN);
g_assert_true(endptr == str + strlen(str));
@@ -1063,6 +1480,21 @@ static void test_qemu_strtol_negative(void)
g_assert_true(endptr == str + strlen(str));
}
+static void test_qemu_strtol_negzero(void)
+{
+ const char *str = " -0";
+ char f = 'X';
+ const char *endptr = &f;
+ long res = 999;
+ int err;
+
+ err = qemu_strtol(str, &endptr, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, 0);
+ g_assert_true(endptr == str + strlen(str));
+}
+
static void test_qemu_strtol_full_correct(void)
{
const char *str = "123";
@@ -1113,6 +1545,18 @@ static void test_qemu_strtol_full_negative(void)
g_assert_cmpint(res, ==, -321);
}
+static void test_qemu_strtol_full_negzero(void)
+{
+ const char *str = " -0";
+ long res = 999;
+ int err;
+
+ err = qemu_strtol(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, 0);
+}
+
static void test_qemu_strtol_full_trailing(void)
{
const char *str = "123xxx";
@@ -1138,6 +1582,19 @@ static void test_qemu_strtol_full_max(void)
g_free(str);
}
+static void test_qemu_strtol_full_erange_junk(void)
+{
+ /* EINVAL has priority over ERANGE */
+ const char *str = "-99999999999999999999junk";
+ long res = 999;
+ int err;
+
+ err = qemu_strtol(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpint(res, ==, LONG_MIN);
+}
+
static void test_qemu_strtoul_correct(void)
{
const char *str = "12345 foo";
@@ -1307,6 +1764,23 @@ static void test_qemu_strtoul_hex(void)
g_assert_true(endptr == str + 1);
}
+static void test_qemu_strtoul_wrap(void)
+{
+ const char *str;
+ char f = 'X';
+ const char *endptr = &f;
+ unsigned long res = 999;
+ int err;
+
+ /* 1 mod 2^(sizeof(long)*8) */
+ str = LONG_MAX == INT_MAX ? "-4294967295" : "-18446744073709551615";
+ err = qemu_strtoul(str, &endptr, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmphex(res, ==, 1);
+ g_assert_true(endptr == str + strlen(str));
+}
+
static void test_qemu_strtoul_max(void)
{
char *str = g_strdup_printf("%lu", ULONG_MAX);
@@ -1325,31 +1799,87 @@ static void test_qemu_strtoul_max(void)
static void test_qemu_strtoul_overflow(void)
{
- const char *str = "99999999999999999999999999999999999999999999";
- char f = 'X';
- const char *endptr = &f;
- unsigned long res = 999;
+ const char *str;
+ const char *endptr;
+ unsigned long res;
int err;
+ /* 1 more than ULONG_MAX */
+ str = ULONG_MAX == UINT_MAX ? "4294967296" : "18446744073709551616";
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtoul(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ if (LONG_MAX == INT_MAX) {
+ str = "0xffffffff00000001"; /* UINT64_MAX - UINT_MAX + 1 (not 1) */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoul(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ }
+
+ str = "0x10000000000000000"; /* 65 bits, either sign bit position clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoul(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ str = "0x18000000080000000"; /* 65 bits, either sign bit position set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoul(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmphex(res, ==, ULONG_MAX);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
g_assert_true(endptr == str + strlen(str));
}
static void test_qemu_strtoul_underflow(void)
{
- const char *str = "-99999999999999999999999999999999999999999999";
- char f = 'X';
- const char *endptr = &f;
- unsigned long res = 999;
+ const char *str;
+ const char *endptr;
+ unsigned long res;
int err;
+ /* 1 less than -ULONG_MAX */
+ str = ULONG_MAX == UINT_MAX ? "-4294967296" : "-18446744073709551616";
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtoul(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ if (LONG_MAX == INT_MAX) {
+ str = "-0xffffffff00000002";
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoul(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ }
+
+ str = "-0x10000000000000000"; /* 65 bits, either sign bit position clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoul(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ str = "-0x18000000080000000"; /* 65 bits, either sign bit position set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoul(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmpuint(res, ==, -1ul);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
g_assert_true(endptr == str + strlen(str));
}
@@ -1368,6 +1898,21 @@ static void test_qemu_strtoul_negative(void)
g_assert_true(endptr == str + strlen(str));
}
+static void test_qemu_strtoul_negzero(void)
+{
+ const char *str = " -0";
+ char f = 'X';
+ const char *endptr = &f;
+ unsigned long res = 999;
+ int err;
+
+ err = qemu_strtoul(str, &endptr, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpuint(res, ==, 0);
+ g_assert_true(endptr == str + strlen(str));
+}
+
static void test_qemu_strtoul_full_correct(void)
{
const char *str = "123";
@@ -1414,6 +1959,17 @@ static void test_qemu_strtoul_full_negative(void)
g_assert_cmpuint(res, ==, -321ul);
}
+static void test_qemu_strtoul_full_negzero(void)
+{
+ const char *str = " -0";
+ unsigned long res = 999;
+ int err;
+
+ err = qemu_strtoul(str, NULL, 0, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpuint(res, ==, 0);
+}
+
static void test_qemu_strtoul_full_trailing(void)
{
const char *str = "123xxx";
@@ -1439,6 +1995,19 @@ static void test_qemu_strtoul_full_max(void)
g_free(str);
}
+static void test_qemu_strtoul_full_erange_junk(void)
+{
+ /* EINVAL has priority over ERANGE */
+ const char *str = "-99999999999999999999junk";
+ unsigned long res = 999;
+ int err;
+
+ err = qemu_strtoul(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpuint(res, ==, ULONG_MAX);
+}
+
static void test_qemu_strtoi64_correct(void)
{
const char *str = "12345 foo";
@@ -1626,22 +2195,39 @@ static void test_qemu_strtoi64_max(void)
static void test_qemu_strtoi64_overflow(void)
{
- const char *str = "99999999999999999999999999999999999999999999";
- char f = 'X';
- const char *endptr = &f;
- int64_t res = 999;
+ const char *str;
+ const char *endptr;
+ int64_t res;
int err;
+ str = "9223372036854775808"; /* 1 more than INT64_MAX */
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtoi64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT64_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT64_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi64(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmpint(res, ==, LLONG_MAX);
+ g_assert_cmpint(res, ==, INT64_MAX);
g_assert_true(endptr == str + strlen(str));
}
-static void test_qemu_strtoi64_underflow(void)
+static void test_qemu_strtoi64_min(void)
{
- const char *str = "-99999999999999999999999999999999999999999999";
+ char *str = g_strdup_printf("%lld", LLONG_MIN);
char f = 'X';
const char *endptr = &f;
int64_t res = 999;
@@ -1649,9 +2235,42 @@ static void test_qemu_strtoi64_underflow(void)
err = qemu_strtoi64(str, &endptr, 0, &res);
- g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, LLONG_MIN);
g_assert_true(endptr == str + strlen(str));
+ g_free(str);
+}
+
+static void test_qemu_strtoi64_underflow(void)
+{
+ const char *str;
+ const char *endptr;
+ int64_t res;
+ int err;
+
+ str = "-9223372036854775809"; /* 1 less than INT64_MIN */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT64_MIN);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT64_MIN);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtoi64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpint(res, ==, INT64_MIN);
+ g_assert_true(endptr == str + strlen(str));
}
static void test_qemu_strtoi64_negative(void)
@@ -1669,6 +2288,21 @@ static void test_qemu_strtoi64_negative(void)
g_assert_true(endptr == str + strlen(str));
}
+static void test_qemu_strtoi64_negzero(void)
+{
+ const char *str = " -0";
+ char f = 'X';
+ const char *endptr = &f;
+ int64_t res = 999;
+ int err;
+
+ err = qemu_strtoi64(str, &endptr, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, 0);
+ g_assert_true(endptr == str + strlen(str));
+}
+
static void test_qemu_strtoi64_full_correct(void)
{
const char *str = "123";
@@ -1716,6 +2350,18 @@ static void test_qemu_strtoi64_full_negative(void)
g_assert_cmpint(res, ==, -321);
}
+static void test_qemu_strtoi64_full_negzero(void)
+{
+ const char *str = " -0";
+ int64_t res = 999;
+ int err;
+
+ err = qemu_strtoi64(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpint(res, ==, 0);
+}
+
static void test_qemu_strtoi64_full_trailing(void)
{
const char *str = "123xxx";
@@ -1742,6 +2388,19 @@ static void test_qemu_strtoi64_full_max(void)
g_free(str);
}
+static void test_qemu_strtoi64_full_erange_junk(void)
+{
+ /* EINVAL has priority over ERANGE */
+ const char *str = "-99999999999999999999junk";
+ int64_t res = 999;
+ int err;
+
+ err = qemu_strtoi64(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpint(res, ==, INT64_MIN);
+}
+
static void test_qemu_strtou64_correct(void)
{
const char *str = "12345 foo";
@@ -1911,6 +2570,21 @@ static void test_qemu_strtou64_hex(void)
g_assert_true(endptr == str + 1);
}
+static void test_qemu_strtou64_wrap(void)
+{
+ const char *str = "-18446744073709551615"; /* 1 mod 2^64 */
+ char f = 'X';
+ const char *endptr = &f;
+ uint64_t res = 999;
+ int err;
+
+ err = qemu_strtou64(str, &endptr, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpuint(res, ==, 1);
+ g_assert_true(endptr == str + strlen(str));
+}
+
static void test_qemu_strtou64_max(void)
{
char *str = g_strdup_printf("%llu", ULLONG_MAX);
@@ -1929,31 +2603,65 @@ static void test_qemu_strtou64_max(void)
static void test_qemu_strtou64_overflow(void)
{
- const char *str = "99999999999999999999999999999999999999999999";
- char f = 'X';
- const char *endptr = &f;
- uint64_t res = 999;
+ const char *str;
+ const char *endptr;
+ uint64_t res;
int err;
+ str = "18446744073709551616"; /* 1 more than UINT64_MAX */
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtou64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT64_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtou64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT64_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtou64(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmphex(res, ==, ULLONG_MAX);
+ g_assert_cmpuint(res, ==, UINT64_MAX);
g_assert_true(endptr == str + strlen(str));
}
static void test_qemu_strtou64_underflow(void)
{
- const char *str = "-99999999999999999999999999999999999999999999";
- char f = 'X';
- const char *endptr = &f;
- uint64_t res = 999;
+ const char *str;
+ const char *endptr;
+ uint64_t res;
int err;
+ str = "-99999999999999999999999999999999999999999999";
+ endptr = "somewhere";
+ res = 999;
err = qemu_strtou64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT64_MAX);
+ g_assert_true(endptr == str + strlen(str));
+ str = "-0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtou64(str, &endptr, 0, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpuint(res, ==, UINT64_MAX);
+ g_assert_true(endptr == str + strlen(str));
+
+ str = "-0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
+ endptr = "somewhere";
+ res = 999;
+ err = qemu_strtou64(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
- g_assert_cmphex(res, ==, -1ull);
+ g_assert_cmpuint(res, ==, UINT64_MAX);
g_assert_true(endptr == str + strlen(str));
}
@@ -1972,6 +2680,21 @@ static void test_qemu_strtou64_negative(void)
g_assert_true(endptr == str + strlen(str));
}
+static void test_qemu_strtou64_negzero(void)
+{
+ const char *str = " -0";
+ char f = 'X';
+ const char *endptr = &f;
+ uint64_t res = 999;
+ int err;
+
+ err = qemu_strtou64(str, &endptr, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpuint(res, ==, 0);
+ g_assert_true(endptr == str + strlen(str));
+}
+
static void test_qemu_strtou64_full_correct(void)
{
const char *str = "18446744073709551614";
@@ -2019,6 +2742,18 @@ static void test_qemu_strtou64_full_negative(void)
g_assert_cmpuint(res, ==, -321ull);
}
+static void test_qemu_strtou64_full_negzero(void)
+{
+ const char *str = " -0";
+ uint64_t res = 999;
+ int err;
+
+ err = qemu_strtou64(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpuint(res, ==, 0);
+}
+
static void test_qemu_strtou64_full_trailing(void)
{
const char *str = "18446744073709551614xxxxxx";
@@ -2044,6 +2779,19 @@ static void test_qemu_strtou64_full_max(void)
g_free(str);
}
+static void test_qemu_strtou64_full_erange_junk(void)
+{
+ /* EINVAL has priority over ERANGE */
+ const char *str = "-99999999999999999999junk";
+ uint64_t res = 999;
+ int err;
+
+ err = qemu_strtou64(str, NULL, 0, &res);
+
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpuint(res, ==, UINT64_MAX);
+}
+
static void test_qemu_strtosz_simple(void)
{
const char *str;
@@ -2585,12 +3333,16 @@ int main(int argc, char **argv)
g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal);
g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal);
g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max);
+ g_test_add_func("/cutils/parse_uint/max", test_parse_uint_max);
g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow);
g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative);
+ g_test_add_func("/cutils/parse_uint/negzero", test_parse_uint_negzero);
g_test_add_func("/cutils/parse_uint_full/trailing",
test_parse_uint_full_trailing);
g_test_add_func("/cutils/parse_uint_full/correct",
test_parse_uint_full_correct);
+ g_test_add_func("/cutils/parse_uint_full/erange_junk",
+ test_parse_uint_full_erange_junk);
/* qemu_strtoi() tests */
g_test_add_func("/cutils/qemu_strtoi/correct",
@@ -2615,10 +3367,14 @@ int main(int argc, char **argv)
test_qemu_strtoi_max);
g_test_add_func("/cutils/qemu_strtoi/overflow",
test_qemu_strtoi_overflow);
+ g_test_add_func("/cutils/qemu_strtoi/min",
+ test_qemu_strtoi_min);
g_test_add_func("/cutils/qemu_strtoi/underflow",
test_qemu_strtoi_underflow);
g_test_add_func("/cutils/qemu_strtoi/negative",
test_qemu_strtoi_negative);
+ g_test_add_func("/cutils/qemu_strtoi/negzero",
+ test_qemu_strtoi_negzero);
g_test_add_func("/cutils/qemu_strtoi_full/correct",
test_qemu_strtoi_full_correct);
g_test_add_func("/cutils/qemu_strtoi_full/null",
@@ -2627,10 +3383,14 @@ int main(int argc, char **argv)
test_qemu_strtoi_full_empty);
g_test_add_func("/cutils/qemu_strtoi_full/negative",
test_qemu_strtoi_full_negative);
+ g_test_add_func("/cutils/qemu_strtoi_full/negzero",
+ test_qemu_strtoi_full_negzero);
g_test_add_func("/cutils/qemu_strtoi_full/trailing",
test_qemu_strtoi_full_trailing);
g_test_add_func("/cutils/qemu_strtoi_full/max",
test_qemu_strtoi_full_max);
+ g_test_add_func("/cutils/qemu_strtoi_full/erange_junk",
+ test_qemu_strtoi_full_erange_junk);
/* qemu_strtoui() tests */
g_test_add_func("/cutils/qemu_strtoui/correct",
@@ -2651,6 +3411,8 @@ int main(int argc, char **argv)
test_qemu_strtoui_decimal);
g_test_add_func("/cutils/qemu_strtoui/hex",
test_qemu_strtoui_hex);
+ g_test_add_func("/cutils/qemu_strtoui/wrap",
+ test_qemu_strtoui_wrap);
g_test_add_func("/cutils/qemu_strtoui/max",
test_qemu_strtoui_max);
g_test_add_func("/cutils/qemu_strtoui/overflow",
@@ -2659,6 +3421,8 @@ int main(int argc, char **argv)
test_qemu_strtoui_underflow);
g_test_add_func("/cutils/qemu_strtoui/negative",
test_qemu_strtoui_negative);
+ g_test_add_func("/cutils/qemu_strtoui/negzero",
+ test_qemu_strtoui_negzero);
g_test_add_func("/cutils/qemu_strtoui_full/correct",
test_qemu_strtoui_full_correct);
g_test_add_func("/cutils/qemu_strtoui_full/null",
@@ -2667,10 +3431,14 @@ int main(int argc, char **argv)
test_qemu_strtoui_full_empty);
g_test_add_func("/cutils/qemu_strtoui_full/negative",
test_qemu_strtoui_full_negative);
+ g_test_add_func("/cutils/qemu_strtoui_full/negzero",
+ test_qemu_strtoui_full_negzero);
g_test_add_func("/cutils/qemu_strtoui_full/trailing",
test_qemu_strtoui_full_trailing);
g_test_add_func("/cutils/qemu_strtoui_full/max",
test_qemu_strtoui_full_max);
+ g_test_add_func("/cutils/qemu_strtoui_full/erange_junk",
+ test_qemu_strtoui_full_erange_junk);
/* qemu_strtol() tests */
g_test_add_func("/cutils/qemu_strtol/correct",
@@ -2695,10 +3463,14 @@ int main(int argc, char **argv)
test_qemu_strtol_max);
g_test_add_func("/cutils/qemu_strtol/overflow",
test_qemu_strtol_overflow);
+ g_test_add_func("/cutils/qemu_strtol/min",
+ test_qemu_strtol_min);
g_test_add_func("/cutils/qemu_strtol/underflow",
test_qemu_strtol_underflow);
g_test_add_func("/cutils/qemu_strtol/negative",
test_qemu_strtol_negative);
+ g_test_add_func("/cutils/qemu_strtol/negzero",
+ test_qemu_strtol_negzero);
g_test_add_func("/cutils/qemu_strtol_full/correct",
test_qemu_strtol_full_correct);
g_test_add_func("/cutils/qemu_strtol_full/null",
@@ -2707,10 +3479,14 @@ int main(int argc, char **argv)
test_qemu_strtol_full_empty);
g_test_add_func("/cutils/qemu_strtol_full/negative",
test_qemu_strtol_full_negative);
+ g_test_add_func("/cutils/qemu_strtol_full/negzero",
+ test_qemu_strtol_full_negzero);
g_test_add_func("/cutils/qemu_strtol_full/trailing",
test_qemu_strtol_full_trailing);
g_test_add_func("/cutils/qemu_strtol_full/max",
test_qemu_strtol_full_max);
+ g_test_add_func("/cutils/qemu_strtol_full/erange_junk",
+ test_qemu_strtol_full_erange_junk);
/* qemu_strtoul() tests */
g_test_add_func("/cutils/qemu_strtoul/correct",
@@ -2731,6 +3507,8 @@ int main(int argc, char **argv)
test_qemu_strtoul_decimal);
g_test_add_func("/cutils/qemu_strtoul/hex",
test_qemu_strtoul_hex);
+ g_test_add_func("/cutils/qemu_strtoul/wrap",
+ test_qemu_strtoul_wrap);
g_test_add_func("/cutils/qemu_strtoul/max",
test_qemu_strtoul_max);
g_test_add_func("/cutils/qemu_strtoul/overflow",
@@ -2739,6 +3517,8 @@ int main(int argc, char **argv)
test_qemu_strtoul_underflow);
g_test_add_func("/cutils/qemu_strtoul/negative",
test_qemu_strtoul_negative);
+ g_test_add_func("/cutils/qemu_strtoul/negzero",
+ test_qemu_strtoul_negzero);
g_test_add_func("/cutils/qemu_strtoul_full/correct",
test_qemu_strtoul_full_correct);
g_test_add_func("/cutils/qemu_strtoul_full/null",
@@ -2747,10 +3527,14 @@ int main(int argc, char **argv)
test_qemu_strtoul_full_empty);
g_test_add_func("/cutils/qemu_strtoul_full/negative",
test_qemu_strtoul_full_negative);
+ g_test_add_func("/cutils/qemu_strtoul_full/negzero",
+ test_qemu_strtoul_full_negzero);
g_test_add_func("/cutils/qemu_strtoul_full/trailing",
test_qemu_strtoul_full_trailing);
g_test_add_func("/cutils/qemu_strtoul_full/max",
test_qemu_strtoul_full_max);
+ g_test_add_func("/cutils/qemu_strtoul_full/erange_junk",
+ test_qemu_strtoul_full_erange_junk);
/* qemu_strtoi64() tests */
g_test_add_func("/cutils/qemu_strtoi64/correct",
@@ -2761,8 +3545,7 @@ int main(int argc, char **argv)
test_qemu_strtoi64_empty);
g_test_add_func("/cutils/qemu_strtoi64/whitespace",
test_qemu_strtoi64_whitespace);
- g_test_add_func("/cutils/qemu_strtoi64/invalid"
- ,
+ g_test_add_func("/cutils/qemu_strtoi64/invalid",
test_qemu_strtoi64_invalid);
g_test_add_func("/cutils/qemu_strtoi64/trailing",
test_qemu_strtoi64_trailing);
@@ -2776,10 +3559,14 @@ int main(int argc, char **argv)
test_qemu_strtoi64_max);
g_test_add_func("/cutils/qemu_strtoi64/overflow",
test_qemu_strtoi64_overflow);
+ g_test_add_func("/cutils/qemu_strtoi64/min",
+ test_qemu_strtoi64_min);
g_test_add_func("/cutils/qemu_strtoi64/underflow",
test_qemu_strtoi64_underflow);
g_test_add_func("/cutils/qemu_strtoi64/negative",
test_qemu_strtoi64_negative);
+ g_test_add_func("/cutils/qemu_strtoi64/negzero",
+ test_qemu_strtoi64_negzero);
g_test_add_func("/cutils/qemu_strtoi64_full/correct",
test_qemu_strtoi64_full_correct);
g_test_add_func("/cutils/qemu_strtoi64_full/null",
@@ -2788,10 +3575,14 @@ int main(int argc, char **argv)
test_qemu_strtoi64_full_empty);
g_test_add_func("/cutils/qemu_strtoi64_full/negative",
test_qemu_strtoi64_full_negative);
+ g_test_add_func("/cutils/qemu_strtoi64_full/negzero",
+ test_qemu_strtoi64_full_negzero);
g_test_add_func("/cutils/qemu_strtoi64_full/trailing",
test_qemu_strtoi64_full_trailing);
g_test_add_func("/cutils/qemu_strtoi64_full/max",
test_qemu_strtoi64_full_max);
+ g_test_add_func("/cutils/qemu_strtoi64_full/erange_junk",
+ test_qemu_strtoi64_full_erange_junk);
/* qemu_strtou64() tests */
g_test_add_func("/cutils/qemu_strtou64/correct",
@@ -2812,6 +3603,8 @@ int main(int argc, char **argv)
test_qemu_strtou64_decimal);
g_test_add_func("/cutils/qemu_strtou64/hex",
test_qemu_strtou64_hex);
+ g_test_add_func("/cutils/qemu_strtou64/wrap",
+ test_qemu_strtou64_wrap);
g_test_add_func("/cutils/qemu_strtou64/max",
test_qemu_strtou64_max);
g_test_add_func("/cutils/qemu_strtou64/overflow",
@@ -2820,6 +3613,8 @@ int main(int argc, char **argv)
test_qemu_strtou64_underflow);
g_test_add_func("/cutils/qemu_strtou64/negative",
test_qemu_strtou64_negative);
+ g_test_add_func("/cutils/qemu_strtou64/negzero",
+ test_qemu_strtou64_negzero);
g_test_add_func("/cutils/qemu_strtou64_full/correct",
test_qemu_strtou64_full_correct);
g_test_add_func("/cutils/qemu_strtou64_full/null",
@@ -2828,10 +3623,14 @@ int main(int argc, char **argv)
test_qemu_strtou64_full_empty);
g_test_add_func("/cutils/qemu_strtou64_full/negative",
test_qemu_strtou64_full_negative);
+ g_test_add_func("/cutils/qemu_strtou64_full/negzero",
+ test_qemu_strtou64_full_negzero);
g_test_add_func("/cutils/qemu_strtou64_full/trailing",
test_qemu_strtou64_full_trailing);
g_test_add_func("/cutils/qemu_strtou64_full/max",
test_qemu_strtou64_full_max);
+ g_test_add_func("/cutils/qemu_strtou64_full/erange_junk",
+ test_qemu_strtou64_full_erange_junk);
g_test_add_func("/cutils/strtosz/simple",
test_qemu_strtosz_simple);
--
2.40.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
* [PULL v2 09/21] cutils: Adjust signature of parse_uint[_full]
2023-06-02 17:33 [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01 Eric Blake
2023-06-02 17:33 ` [PULL v2 06/21] test-cutils: Test more integer corner cases Eric Blake
@ 2023-06-02 17:33 ` Eric Blake
2023-06-03 0:33 ` [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01 Richard Henderson
2 siblings, 0 replies; 4+ messages in thread
From: Eric Blake @ 2023-06-02 17:33 UTC (permalink / raw)
To: qemu-devel
Cc: Hanna Czenczek, Gerd Hoffmann, Marc-André Lureau, Kevin Wolf,
Peter Lieven, Markus Armbruster, Michael Roth,
Daniel P. Berrangé, open list:GLUSTER, open list:GLUSTER
It's already confusing that we have two very similar functions for
wrapping the parse of a 64-bit unsigned value, differing mainly on
whether they permit leading '-'. Adjust the signature of parse_uint()
and parse_uint_full() to be like all of qemu_strto*(): put the result
parameter last, use the same types (uint64_t and unsigned long long
have the same width, but are not always the same type), and mark
endptr const (this latter change only affects the rare caller of
parse_uint). Adjust all callers in the tree.
While at it, note that since cutils.c already includes:
QEMU_BUILD_BUG_ON(sizeof(int64_t) != sizeof(long long));
we are guaranteed that the result of parse_uint* cannot exceed
UINT64_MAX (or the build would have failed), so we can drop
pre-existing dead comparisons in opts-visitor.c that were never false.
Reviewed-by: Hanna Czenczek <hreitz@redhat.com>
Message-Id: <20230522190441.64278-8-eblake@redhat.com>
[eblake: Drop dead code spotted by Markus]
Signed-off-by: Eric Blake <eblake@redhat.com>
---
include/qemu/cutils.h | 5 +-
audio/audio_legacy.c | 4 +-
block/gluster.c | 4 +-
block/nfs.c | 4 +-
blockdev.c | 4 +-
contrib/ivshmem-server/main.c | 4 +-
qapi/opts-visitor.c | 12 ++--
tests/unit/test-cutils.c | 119 +++++++++++++++-------------------
ui/vnc.c | 4 +-
util/cutils.c | 13 ++--
util/guest-random.c | 4 +-
util/qemu-sockets.c | 10 +--
12 files changed, 86 insertions(+), 101 deletions(-)
diff --git a/include/qemu/cutils.h b/include/qemu/cutils.h
index 92c436d8c70..92c927a6a35 100644
--- a/include/qemu/cutils.h
+++ b/include/qemu/cutils.h
@@ -163,9 +163,8 @@ int qemu_strtou64(const char *nptr, const char **endptr, int base,
int qemu_strtod(const char *nptr, const char **endptr, double *result);
int qemu_strtod_finite(const char *nptr, const char **endptr, double *result);
-int parse_uint(const char *s, unsigned long long *value, char **endptr,
- int base);
-int parse_uint_full(const char *s, unsigned long long *value, int base);
+int parse_uint(const char *s, const char **endptr, int base, uint64_t *value);
+int parse_uint_full(const char *s, int base, uint64_t *value);
int qemu_strtosz(const char *nptr, const char **end, uint64_t *result);
int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result);
diff --git a/audio/audio_legacy.c b/audio/audio_legacy.c
index b848001ff70..dc72ba55e9a 100644
--- a/audio/audio_legacy.c
+++ b/audio/audio_legacy.c
@@ -35,8 +35,8 @@
static uint32_t toui32(const char *str)
{
- unsigned long long ret;
- if (parse_uint_full(str, &ret, 10) || ret > UINT32_MAX) {
+ uint64_t ret;
+ if (parse_uint_full(str, 10, &ret) || ret > UINT32_MAX) {
dolog("Invalid integer value `%s'\n", str);
exit(1);
}
diff --git a/block/gluster.c b/block/gluster.c
index 185a83e5e53..ad5fadbe793 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -424,7 +424,7 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
int ret;
int old_errno;
SocketAddressList *server;
- unsigned long long port;
+ uint64_t port;
glfs = glfs_find_preopened(gconf->volume);
if (glfs) {
@@ -445,7 +445,7 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
server->value->u.q_unix.path, 0);
break;
case SOCKET_ADDRESS_TYPE_INET:
- if (parse_uint_full(server->value->u.inet.port, &port, 10) < 0 ||
+ if (parse_uint_full(server->value->u.inet.port, 10, &port) < 0 ||
port > 65535) {
error_setg(errp, "'%s' is not a valid port number",
server->value->u.inet.port);
diff --git a/block/nfs.c b/block/nfs.c
index 8f89ece69fa..c24df49747d 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -114,13 +114,13 @@ static int nfs_parse_uri(const char *filename, QDict *options, Error **errp)
qdict_put_str(options, "path", uri->path);
for (i = 0; i < qp->n; i++) {
- unsigned long long val;
+ uint64_t val;
if (!qp->p[i].value) {
error_setg(errp, "Value for NFS parameter expected: %s",
qp->p[i].name);
goto out;
}
- if (parse_uint_full(qp->p[i].value, &val, 0)) {
+ if (parse_uint_full(qp->p[i].value, 0, &val)) {
error_setg(errp, "Illegal value for NFS parameter: %s",
qp->p[i].name);
goto out;
diff --git a/blockdev.c b/blockdev.c
index db2725fe741..e6eba61484a 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -341,10 +341,10 @@ static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals,
switch (qobject_type(entry->value)) {
case QTYPE_QSTRING: {
- unsigned long long length;
+ uint64_t length;
const char *str = qstring_get_str(qobject_to(QString,
entry->value));
- if (parse_uint_full(str, &length, 10) == 0 &&
+ if (parse_uint_full(str, 10, &length) == 0 &&
length > 0 && length <= UINT_MAX) {
block_acct_add_interval(stats, (unsigned) length);
} else {
diff --git a/contrib/ivshmem-server/main.c b/contrib/ivshmem-server/main.c
index 224dbeb547e..5901f17707e 100644
--- a/contrib/ivshmem-server/main.c
+++ b/contrib/ivshmem-server/main.c
@@ -69,7 +69,7 @@ static void
ivshmem_server_parse_args(IvshmemServerArgs *args, int argc, char *argv[])
{
int c;
- unsigned long long v;
+ uint64_t v;
Error *err = NULL;
while ((c = getopt(argc, argv, "hvFp:S:m:M:l:n:")) != -1) {
@@ -112,7 +112,7 @@ ivshmem_server_parse_args(IvshmemServerArgs *args, int argc, char *argv[])
break;
case 'n': /* number of vectors */
- if (parse_uint_full(optarg, &v, 0) < 0) {
+ if (parse_uint_full(optarg, 0, &v) < 0) {
fprintf(stderr, "cannot parse n_vectors\n");
ivshmem_server_help(argv[0]);
exit(1);
diff --git a/qapi/opts-visitor.c b/qapi/opts-visitor.c
index 587f31baf6b..8f1efab8b9d 100644
--- a/qapi/opts-visitor.c
+++ b/qapi/opts-visitor.c
@@ -454,8 +454,8 @@ opts_type_uint64(Visitor *v, const char *name, uint64_t *obj, Error **errp)
OptsVisitor *ov = to_ov(v);
const QemuOpt *opt;
const char *str;
- unsigned long long val;
- char *endptr;
+ uint64_t val;
+ const char *endptr;
if (ov->list_mode == LM_UNSIGNED_INTERVAL) {
*obj = ov->range_next.u;
@@ -471,18 +471,18 @@ opts_type_uint64(Visitor *v, const char *name, uint64_t *obj, Error **errp)
/* we've gotten past lookup_scalar() */
assert(ov->list_mode == LM_NONE || ov->list_mode == LM_IN_PROGRESS);
- if (parse_uint(str, &val, &endptr, 0) == 0 && val <= UINT64_MAX) {
+ if (parse_uint(str, &endptr, 0, &val) == 0) {
if (*endptr == '\0') {
*obj = val;
processed(ov, name);
return true;
}
if (*endptr == '-' && ov->list_mode == LM_IN_PROGRESS) {
- unsigned long long val2;
+ uint64_t val2;
str = endptr + 1;
- if (parse_uint_full(str, &val2, 0) == 0 &&
- val2 <= UINT64_MAX && val <= val2 &&
+ if (parse_uint_full(str, 0, &val2) == 0 &&
+ val <= val2 &&
val2 - val < OPTS_VISITOR_RANGE_MAX) {
ov->range_next.u = val;
ov->range_limit.u = val2;
diff --git a/tests/unit/test-cutils.c b/tests/unit/test-cutils.c
index 8d2e057bdaa..3664b4fffc5 100644
--- a/tests/unit/test-cutils.c
+++ b/tests/unit/test-cutils.c
@@ -31,12 +31,11 @@
static void test_parse_uint_null(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
int r;
- r = parse_uint(NULL, &i, &endptr, 0);
+ r = parse_uint(NULL, &endptr, 0, &i);
g_assert_cmpint(r, ==, -EINVAL);
g_assert_cmpuint(i, ==, 0);
@@ -45,13 +44,12 @@ static void test_parse_uint_null(void)
static void test_parse_uint_empty(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
const char *str = "";
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -EINVAL);
g_assert_cmpuint(i, ==, 0);
@@ -60,13 +58,12 @@ static void test_parse_uint_empty(void)
static void test_parse_uint_whitespace(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
const char *str = " \t ";
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -EINVAL);
g_assert_cmpuint(i, ==, 0);
@@ -76,13 +73,12 @@ static void test_parse_uint_whitespace(void)
static void test_parse_uint_invalid(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
const char *str = " \t xxx";
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -EINVAL);
g_assert_cmpuint(i, ==, 0);
@@ -92,13 +88,12 @@ static void test_parse_uint_invalid(void)
static void test_parse_uint_trailing(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
const char *str = "123xxx";
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, 0);
g_assert_cmpuint(i, ==, 123);
@@ -107,13 +102,12 @@ static void test_parse_uint_trailing(void)
static void test_parse_uint_correct(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
const char *str = "123";
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, 0);
g_assert_cmpuint(i, ==, 123);
@@ -122,13 +116,12 @@ static void test_parse_uint_correct(void)
static void test_parse_uint_octal(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
const char *str = "0123";
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, 0);
g_assert_cmpuint(i, ==, 0123);
@@ -137,13 +130,12 @@ static void test_parse_uint_octal(void)
static void test_parse_uint_decimal(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
const char *str = "0123";
int r;
- r = parse_uint(str, &i, &endptr, 10);
+ r = parse_uint(str, &endptr, 10, &i);
g_assert_cmpint(r, ==, 0);
g_assert_cmpuint(i, ==, 123);
@@ -152,13 +144,12 @@ static void test_parse_uint_decimal(void)
static void test_parse_uint_llong_max(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1);
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, 0);
g_assert_cmpuint(i, ==, (unsigned long long)LLONG_MAX + 1);
@@ -169,13 +160,12 @@ static void test_parse_uint_llong_max(void)
static void test_parse_uint_max(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
char *str = g_strdup_printf("%llu", ULLONG_MAX);
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, 0);
g_assert_cmpuint(i, ==, ULLONG_MAX);
@@ -186,32 +176,31 @@ static void test_parse_uint_max(void)
static void test_parse_uint_overflow(void)
{
- unsigned long long i;
- char f = 'X';
- char *endptr;
+ uint64_t i;
+ const char *endptr;
const char *str;
int r;
i = 999;
- endptr = &f;
+ endptr = "somewhere";
str = "99999999999999999999999999999999999999";
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -ERANGE);
g_assert_cmpuint(i, ==, ULLONG_MAX);
g_assert_true(endptr == str + strlen(str));
i = 999;
- endptr = &f;
+ endptr = "somewhere";
str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -ERANGE);
g_assert_cmpuint(i, ==, ULLONG_MAX);
g_assert_true(endptr == str + strlen(str));
i = 999;
- endptr = &f;
+ endptr = "somewhere";
str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -ERANGE);
g_assert_cmpuint(i, ==, ULLONG_MAX);
g_assert_true(endptr == str + strlen(str));
@@ -219,24 +208,23 @@ static void test_parse_uint_overflow(void)
static void test_parse_uint_negative(void)
{
- unsigned long long i;
- char f = 'X';
- char *endptr;
+ uint64_t i;
+ const char *endptr;
const char *str;
int r;
i = 999;
- endptr = &f;
+ endptr = "somewhere";
str = " \t -321";
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -ERANGE);
g_assert_cmpuint(i, ==, 0);
g_assert_true(endptr == str + strlen(str));
i = 999;
- endptr = &f;
+ endptr = "somewhere";
str = "-0xffffffff00000001";
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -ERANGE);
g_assert_cmpuint(i, ==, 0);
g_assert_true(endptr == str + strlen(str));
@@ -244,13 +232,12 @@ static void test_parse_uint_negative(void)
static void test_parse_uint_negzero(void)
{
- unsigned long long i = 999;
- char f = 'X';
- char *endptr = &f;
+ uint64_t i = 999;
+ const char *endptr = "somewhere";
const char *str = " -0";
int r;
- r = parse_uint(str, &i, &endptr, 0);
+ r = parse_uint(str, &endptr, 0, &i);
g_assert_cmpint(r, ==, -ERANGE);
g_assert_cmpuint(i, ==, 0);
@@ -259,11 +246,11 @@ static void test_parse_uint_negzero(void)
static void test_parse_uint_full_trailing(void)
{
- unsigned long long i = 999;
+ uint64_t i = 999;
const char *str = "123xxx";
int r;
- r = parse_uint_full(str, &i, 0);
+ r = parse_uint_full(str, 0, &i);
g_assert_cmpint(r, ==, -EINVAL);
g_assert_cmpuint(i, ==, 0);
@@ -271,11 +258,11 @@ static void test_parse_uint_full_trailing(void)
static void test_parse_uint_full_correct(void)
{
- unsigned long long i = 999;
+ uint64_t i = 999;
const char *str = "123";
int r;
- r = parse_uint_full(str, &i, 0);
+ r = parse_uint_full(str, 0, &i);
g_assert_cmpint(r, ==, 0);
g_assert_cmpuint(i, ==, 123);
@@ -284,11 +271,11 @@ static void test_parse_uint_full_correct(void)
static void test_parse_uint_full_erange_junk(void)
{
/* FIXME - inconsistent with qemu_strto* which favors EINVAL */
- unsigned long long i = 999;
+ uint64_t i = 999;
const char *str = "-2junk";
int r;
- r = parse_uint_full(str, &i, 0);
+ r = parse_uint_full(str, 0, &i);
g_assert_cmpint(r, ==, -ERANGE /* FIXME -EINVAL */);
g_assert_cmpuint(i, ==, 0);
diff --git a/ui/vnc.c b/ui/vnc.c
index 9d8a24dd8a6..92964dcc0c0 100644
--- a/ui/vnc.c
+++ b/ui/vnc.c
@@ -3728,7 +3728,7 @@ static int vnc_display_get_address(const char *addrstr,
} else {
const char *port;
size_t hostlen;
- unsigned long long baseport = 0;
+ uint64_t baseport = 0;
InetSocketAddress *inet;
port = strrchr(addrstr, ':');
@@ -3776,7 +3776,7 @@ static int vnc_display_get_address(const char *addrstr,
}
} else {
int offset = reverse ? 0 : 5900;
- if (parse_uint_full(port, &baseport, 10) < 0) {
+ if (parse_uint_full(port, 10, &baseport) < 0) {
error_setg(errp, "can't convert to a number: %s", port);
goto cleanup;
}
diff --git a/util/cutils.c b/util/cutils.c
index 36c14b769fd..0e279a531aa 100644
--- a/util/cutils.c
+++ b/util/cutils.c
@@ -722,10 +722,10 @@ const char *qemu_strchrnul(const char *s, int c)
* parse_uint:
*
* @s: String to parse
- * @value: Destination for parsed integer value
* @endptr: Destination for pointer to first character not consumed, must
* not be %NULL
* @base: integer base, between 2 and 36 inclusive, or 0
+ * @value: Destination for parsed integer value
*
* Parse unsigned integer
*
@@ -748,8 +748,7 @@ const char *qemu_strchrnul(const char *s, int c)
*
* Else, set *@value to the parsed integer, and return 0.
*/
-int parse_uint(const char *s, unsigned long long *value, char **endptr,
- int base)
+int parse_uint(const char *s, const char **endptr, int base, uint64_t *value)
{
int r = 0;
char *endp = (char *)s;
@@ -793,8 +792,8 @@ out:
* parse_uint_full:
*
* @s: String to parse
- * @value: Destination for parsed integer value
* @base: integer base, between 2 and 36 inclusive, or 0
+ * @value: Destination for parsed integer value
*
* Parse unsigned integer from entire string
*
@@ -803,12 +802,12 @@ out:
* characters are present after a non-overflowing parsed number, the
* function will return -EINVAL, and *@v will be set to 0.
*/
-int parse_uint_full(const char *s, unsigned long long *value, int base)
+int parse_uint_full(const char *s, int base, uint64_t *value)
{
- char *endp;
+ const char *endp;
int r;
- r = parse_uint(s, value, &endp, base);
+ r = parse_uint(s, &endp, base, value);
if (r < 0) {
return r;
}
diff --git a/util/guest-random.c b/util/guest-random.c
index a24d27624c6..9465dda085d 100644
--- a/util/guest-random.c
+++ b/util/guest-random.c
@@ -89,8 +89,8 @@ void qemu_guest_random_seed_thread_part2(uint64_t seed)
int qemu_guest_random_seed_main(const char *optarg, Error **errp)
{
- unsigned long long seed;
- if (parse_uint_full(optarg, &seed, 0)) {
+ uint64_t seed;
+ if (parse_uint_full(optarg, 0, &seed)) {
error_setg(errp, "Invalid seed number: %s", optarg);
return -1;
} else {
diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c
index c06a4dce77c..892d33f5e6b 100644
--- a/util/qemu-sockets.c
+++ b/util/qemu-sockets.c
@@ -249,12 +249,12 @@ static int inet_listen_saddr(InetSocketAddress *saddr,
/* lookup */
if (port_offset) {
- unsigned long long baseport;
+ uint64_t baseport;
if (strlen(port) == 0) {
error_setg(errp, "port not specified");
return -1;
}
- if (parse_uint_full(port, &baseport, 10) < 0) {
+ if (parse_uint_full(port, 10, &baseport) < 0) {
error_setg(errp, "can't convert to a number: %s", port);
return -1;
}
@@ -732,19 +732,19 @@ static bool vsock_parse_vaddr_to_sockaddr(const VsockSocketAddress *vaddr,
struct sockaddr_vm *svm,
Error **errp)
{
- unsigned long long val;
+ uint64_t val;
memset(svm, 0, sizeof(*svm));
svm->svm_family = AF_VSOCK;
- if (parse_uint_full(vaddr->cid, &val, 10) < 0 ||
+ if (parse_uint_full(vaddr->cid, 10, &val) < 0 ||
val > UINT32_MAX) {
error_setg(errp, "Failed to parse cid '%s'", vaddr->cid);
return false;
}
svm->svm_cid = val;
- if (parse_uint_full(vaddr->port, &val, 10) < 0 ||
+ if (parse_uint_full(vaddr->port, 10, &val) < 0 ||
val > UINT32_MAX) {
error_setg(errp, "Failed to parse port '%s'", vaddr->port);
return false;
--
2.40.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01
2023-06-02 17:33 [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01 Eric Blake
2023-06-02 17:33 ` [PULL v2 06/21] test-cutils: Test more integer corner cases Eric Blake
2023-06-02 17:33 ` [PULL v2 09/21] cutils: Adjust signature of parse_uint[_full] Eric Blake
@ 2023-06-03 0:33 ` Richard Henderson
2 siblings, 0 replies; 4+ messages in thread
From: Richard Henderson @ 2023-06-03 0:33 UTC (permalink / raw)
To: Eric Blake, qemu-devel
On 6/2/23 10:33, Eric Blake wrote:
> The following changes since commit a86d7b9ec0adb2f1efce8ab30d9ed2b72db0236e:
>
> Merge tag 'migration-20230601-pull-request' ofhttps://gitlab.com/juan.quintela/qemu into staging (2023-06-01 20:59:28 -0700)
>
> are available in the Git repository at:
>
> https://repo.or.cz/qemu/ericb.git tags/pull-nbd-2023-06-01-v2
>
> for you to fetch changes up to 42cc08d13ab8e68f76882b216da0b28d06f29e11:
>
> cutils: Improve qemu_strtosz handling of fractions (2023-06-02 12:29:27 -0500)
>
> In v2:
> - fix build failure on mingw [CI, via Richard]
> - drop dead comparisons to UINT64_MAX [Markus]
>
> only the changed patches are re-posted
>
> ----------------------------------------------------------------
> nbd and misc patches for 2023-06-01
>
> - Eric Blake: Fix iotest 104 for NBD
> - Eric Blake: Improve qcow2 spec on padding bytes
> - Eric Blake: Fix read-beyond-bounds bug in qemu_strtosz
Applied, thanks. Please update https://wiki.qemu.org/ChangeLog/8.1 as appropriate.
r~
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2023-06-03 0:33 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2023-06-02 17:33 [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01 Eric Blake
2023-06-02 17:33 ` [PULL v2 06/21] test-cutils: Test more integer corner cases Eric Blake
2023-06-02 17:33 ` [PULL v2 09/21] cutils: Adjust signature of parse_uint[_full] Eric Blake
2023-06-03 0:33 ` [PULL v2 00/21] NBD and miscellaneous patches for 2023-06-01 Richard Henderson
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).