commit 9e58f1b2690cca0823cbf258584df93fbbfef71f
author Tom Cherry <tomcherry@google.com> Wed Aug 22 14:38:02 2018 -0700
committer Tom Cherry <tomcherry@google.com> Wed Aug 22 15:02:57 2018 -0700
tree e8bda6a0f3daf9b092ae6aef022cbe4820c4f34f
parent 16e29cfa2d41616146f03ea9f9911ee219635621

Fix two ParseInt edge cases

1) ParseInt and ParseUint accept strings that have spaces followed by
   a valid number, however the base check for determining hex numbers
   does not take this into account currently, but now does this this
   change.
2) ParseUint rejects negative numbers except in the case that the
   template argument is unsigned long long.  That is a mistake; it
   should reject negative numbers in all cases and this change does
   that by rejecting any string with a - prefix.

Bug: 112668205
Test: new (and old) unit tests
Change-Id: I0179b42e50adc1b169cf0e6d830283b71210a029

include/android-base/parseint.h

diff --git a/include/android-base/parseint.h b/include/android-base/parseint.h
index 55f1ed3..5bfa47e 100644
--- a/include/android-base/parseint.h
+++ b/include/android-base/parseint.h
@@ -33,6 +33,14 @@
 template <typename T>
 bool ParseUint(const char* s, T* out, T max = std::numeric_limits<T>::max(),
                bool allow_suffixes = false) {
+  while (isspace(*s)) {
+    s++;
+  }
+
+  if (s[0] == '-') {
+    return false;
+  }
+
   int base = (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) ? 16 : 10;
   errno = 0;
   char* end;
@@ -79,6 +87,10 @@
 bool ParseInt(const char* s, T* out,
               T min = std::numeric_limits<T>::min(),
               T max = std::numeric_limits<T>::max()) {
+  while (isspace(*s)) {
+    s++;
+  }
+
   int base = (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) ? 16 : 10;
   errno = 0;
   char* end;

parseint_test.cpp

diff --git a/parseint_test.cpp b/parseint_test.cpp
index 8f9ed77..4afa32e 100644
--- a/parseint_test.cpp
+++ b/parseint_test.cpp
@@ -25,8 +25,14 @@
 
   ASSERT_TRUE(android::base::ParseInt("123", &i));
   ASSERT_EQ(123, i);
+  i = 0;
+  EXPECT_TRUE(android::base::ParseInt("  123", &i));
+  EXPECT_EQ(123, i);
   ASSERT_TRUE(android::base::ParseInt("-123", &i));
   ASSERT_EQ(-123, i);
+  i = 0;
+  EXPECT_TRUE(android::base::ParseInt("  -123", &i));
+  EXPECT_EQ(-123, i);
 
   short s = 0;
   ASSERT_TRUE(android::base::ParseInt("1234", &s));
@@ -49,7 +55,11 @@
 
   ASSERT_TRUE(android::base::ParseUint("123", &i));
   ASSERT_EQ(123u, i);
+  i = 0u;
+  EXPECT_TRUE(android::base::ParseUint("  123", &i));
+  EXPECT_EQ(123u, i);
   ASSERT_FALSE(android::base::ParseUint("-123", &i));
+  EXPECT_FALSE(android::base::ParseUint("  -123", &i));
 
   unsigned short s = 0u;
   ASSERT_TRUE(android::base::ParseUint("1234", &s));
@@ -63,6 +73,10 @@
   ASSERT_FALSE(android::base::ParseUint<unsigned short>("x", nullptr));
   ASSERT_FALSE(android::base::ParseUint<unsigned short>("123x", nullptr));
   ASSERT_TRUE(android::base::ParseUint<unsigned short>("1234", nullptr));
+
+  unsigned long long int lli;
+  EXPECT_FALSE(android::base::ParseUint("-123", &lli));
+  EXPECT_FALSE(android::base::ParseUint("  -123", &lli));
 }
 
 TEST(parseint, no_implicit_octal) {
@@ -79,10 +93,16 @@
   int i = 0;
   ASSERT_TRUE(android::base::ParseInt("0x123", &i));
   ASSERT_EQ(0x123, i);
+  i = 0;
+  EXPECT_TRUE(android::base::ParseInt("  0x123", &i));
+  EXPECT_EQ(0x123, i);
 
   unsigned int u = 0u;
   ASSERT_TRUE(android::base::ParseUint("0x123", &u));
   ASSERT_EQ(0x123u, u);
+  u = 0u;
+  EXPECT_TRUE(android::base::ParseUint("  0x123", &u));
+  EXPECT_EQ(0x123u, u);
 }
 
 TEST(parseint, string) {