mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-12-01 01:36:09 +03:00
128 lines
4.3 KiB
C++
128 lines
4.3 KiB
C++
// Copyright 2016 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "net/base/parse_number.h"
|
|
|
|
#include "base/logging.h"
|
|
#include "base/strings/string_number_conversions.h"
|
|
#include "base/strings/string_util.h"
|
|
|
|
namespace net {
|
|
|
|
namespace {
|
|
|
|
// The string to number conversion functions in //base include the type in the
|
|
// name (like StringToInt64()). The following wrapper methods create a
|
|
// consistent interface to StringToXXX() that calls the appropriate //base
|
|
// version. This simplifies writing generic code with a template.
|
|
|
|
bool StringToNumber(const base::StringPiece& input, int32_t* output) {
|
|
// This assumes ints are 32-bits (will fail compile if that ever changes).
|
|
return base::StringToInt(input, output);
|
|
}
|
|
|
|
bool StringToNumber(const base::StringPiece& input, uint32_t* output) {
|
|
// This assumes ints are 32-bits (will fail compile if that ever changes).
|
|
return base::StringToUint(input, output);
|
|
}
|
|
|
|
bool StringToNumber(const base::StringPiece& input, int64_t* output) {
|
|
return base::StringToInt64(input, output);
|
|
}
|
|
|
|
bool StringToNumber(const base::StringPiece& input, uint64_t* output) {
|
|
return base::StringToUint64(input, output);
|
|
}
|
|
|
|
bool SetError(ParseIntError error, ParseIntError* optional_error) {
|
|
if (optional_error)
|
|
*optional_error = error;
|
|
return false;
|
|
}
|
|
|
|
template <typename T>
|
|
bool ParseIntHelper(const base::StringPiece& input,
|
|
ParseIntFormat format,
|
|
T* output,
|
|
ParseIntError* optional_error) {
|
|
// Check that the input matches the format before calling StringToNumber().
|
|
// Numbers must start with either a digit or a negative sign.
|
|
if (input.empty())
|
|
return SetError(ParseIntError::FAILED_PARSE, optional_error);
|
|
|
|
bool starts_with_negative = input[0] == '-';
|
|
bool starts_with_digit = base::IsAsciiDigit(input[0]);
|
|
|
|
if (!starts_with_digit) {
|
|
if (format == ParseIntFormat::NON_NEGATIVE || !starts_with_negative)
|
|
return SetError(ParseIntError::FAILED_PARSE, optional_error);
|
|
}
|
|
|
|
// Dispatch to the appropriate flavor of base::StringToXXX() by calling one of
|
|
// the type-specific overloads.
|
|
T result;
|
|
if (StringToNumber(input, &result)) {
|
|
*output = result;
|
|
return true;
|
|
}
|
|
|
|
// Optimization: If the error is not going to be inspected, don't bother
|
|
// calculating it.
|
|
if (!optional_error)
|
|
return false;
|
|
|
|
// Set an error that distinguishes between parsing/underflow/overflow errors.
|
|
//
|
|
// Note that the output set by base::StringToXXX() on failure cannot be used
|
|
// as it has ambiguity with parse errors.
|
|
|
|
// Strip any leading negative sign off the number.
|
|
base::StringPiece numeric_portion =
|
|
starts_with_negative ? input.substr(1) : input;
|
|
|
|
// Test if |numeric_portion| is a valid non-negative integer.
|
|
if (!numeric_portion.empty() &&
|
|
numeric_portion.find_first_not_of("0123456789") == std::string::npos) {
|
|
// If it was, the failure must have been due to underflow/overflow.
|
|
return SetError(starts_with_negative ? ParseIntError::FAILED_UNDERFLOW
|
|
: ParseIntError::FAILED_OVERFLOW,
|
|
optional_error);
|
|
}
|
|
|
|
// Otherwise it was a mundane parsing error.
|
|
return SetError(ParseIntError::FAILED_PARSE, optional_error);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool ParseInt32(const base::StringPiece& input,
|
|
ParseIntFormat format,
|
|
int32_t* output,
|
|
ParseIntError* optional_error) {
|
|
return ParseIntHelper(input, format, output, optional_error);
|
|
}
|
|
|
|
bool ParseInt64(const base::StringPiece& input,
|
|
ParseIntFormat format,
|
|
int64_t* output,
|
|
ParseIntError* optional_error) {
|
|
return ParseIntHelper(input, format, output, optional_error);
|
|
}
|
|
|
|
bool ParseUint32(const base::StringPiece& input,
|
|
uint32_t* output,
|
|
ParseIntError* optional_error) {
|
|
return ParseIntHelper(input, ParseIntFormat::NON_NEGATIVE, output,
|
|
optional_error);
|
|
}
|
|
|
|
bool ParseUint64(const base::StringPiece& input,
|
|
uint64_t* output,
|
|
ParseIntError* optional_error) {
|
|
return ParseIntHelper(input, ParseIntFormat::NON_NEGATIVE, output,
|
|
optional_error);
|
|
}
|
|
|
|
} // namespace net
|