Chiebot-Mirror
/
boringssl
mirror of https://gitee.com/mirrors/boringssl.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remove fillins/fillins_string_util.[cc|h]

Browse Source 
We move the last piece of used stuff here into the library
string_utils.

Bug: 668
Change-Id: Idde14a497204a3b40a602ed6c03a5859eee80811
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/64167
Auto-Submit: Bob Beck <bbe@google.com>
Commit-Queue: Adam Langley <agl@google.com>
Reviewed-by: Adam Langley <agl@google.com>
Commit-Queue: Bob Beck <bbe@google.com>
chromium-stable
Bob Beck 12 months ago committed by Boringssl LUCI CQ
parent 698aa894c9
commit 410247096a
6 changed files with 51 additions and 134 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 89
      pki/fillins/fillins_string_util.cc
  2. 41
      pki/fillins/fillins_string_util.h
  3. 4
      pki/pem.cc
  4. 45
      pki/string_util.cc
  5. 5
      pki/string_util.h
  6. 1
      sources.cmake

89
pki/fillins/fillins_string_util.cc
Unescape View File

@ -1,89 +0,0 @@
// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "fillins_string_util.h"
#include <string>
#include <string_view>
#include "../string_util.h"
namespace bssl {
namespace fillins {
// TODO(bbe): get rid of this
std::string HexEncode(const void *bytes, size_t size) {
return bssl::string_util::HexEncode((const uint8_t *)bytes, size);
}
static bool IsUnicodeWhitespace(char c) {
return c == 9 || c == 10 || c == 11 || c == 12 || c == 13 || c == ' ';
}
std::string CollapseWhitespaceASCII(std::string_view text,
bool trim_sequences_with_line_breaks) {
std::string result;
result.resize(text.size());
// Set flags to pretend we're already in a trimmed whitespace sequence, so we
// will trim any leading whitespace.
bool in_whitespace = true;
bool already_trimmed = true;
int chars_written = 0;
for (auto i = text.begin(); i != text.end(); ++i) {
if (IsUnicodeWhitespace(*i)) {
if (!in_whitespace) {
// Reduce all whitespace sequences to a single space.
in_whitespace = true;
result[chars_written++] = L' ';
}
if (trim_sequences_with_line_breaks && !already_trimmed &&
((*i == '\n') || (*i == '\r'))) {
// Whitespace sequences containing CR or LF are eliminated entirely.
already_trimmed = true;
--chars_written;
}
} else {
// Non-whitespace chracters are copied straight across.
in_whitespace = false;
already_trimmed = false;
result[chars_written++] = *i;
}
}
if (in_whitespace && !already_trimmed) {
// Any trailing whitespace is eliminated.
--chars_written;
}
result.resize(chars_written);
return result;
}
// TODO(bbe): get rid of this (used to be strcasecmp in google3, which
// causes windows pain because msvc and strings.h)
bool EqualsCaseInsensitiveASCII(std::string_view a, std::string_view b) {
return bssl::string_util::IsEqualNoCase(a, b);
}
bool IsAsciiAlpha(char c) {
return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}
bool IsAsciiDigit(char c) { return c >= '0' && c <= '9'; }
void ReplaceSubstringsAfterOffset(std::string *s, size_t offset,
std::string_view find,
std::string_view replace) {
std::string_view prefix(s->data(), offset);
std::string suffix =
bssl::string_util::FindAndReplace(s->substr(offset), find, replace);
*s = std::string(prefix) + suffix;
};
} // namespace fillins
} // namespace bssl

41
pki/fillins/fillins_string_util.h
Unescape View File

@ -1,41 +0,0 @@
// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BSSL_FILLINS_STRING_UTIL_H
#define BSSL_FILLINS_STRING_UTIL_H
#include <openssl/base.h>
#include <string.h>
#include <cassert>
#include <string>
#include <string_view>
namespace bssl {
namespace fillins {
OPENSSL_EXPORT std::string HexEncode(const void *bytes, size_t size);
OPENSSL_EXPORT std::string CollapseWhitespaceASCII(
std::string_view text, bool trim_sequences_with_line_breaks);
OPENSSL_EXPORT bool EqualsCaseInsensitiveASCII(std::string_view a,
std::string_view b);
OPENSSL_EXPORT bool IsAsciiAlpha(char c);
OPENSSL_EXPORT bool IsAsciiDigit(char c);
OPENSSL_EXPORT void ReplaceSubstringsAfterOffset(std::string *s, size_t offset,
std::string_view find,
std::string_view replace);
OPENSSL_EXPORT std::string HexDecode(std::string_view hex);
} // namespace fillins
} // namespace bssl
#endif // BSSL_FILLINS_STRING_UTIL_H

4
pki/pem.cc
Unescape View File

@ -8,8 +8,6 @@
#include <string_view>
#include "fillins/fillins_base64.h"
#include "fillins/fillins_string_util.h"
namespace {
constexpr std::string_view kPEMHeaderBeginBlock = "-----BEGIN ";
@ -66,7 +64,7 @@ bool PEMTokenizer::GetNext() {
std::string_view encoded =
str_.substr(data_begin, footer_pos - data_begin);
if (!fillins::Base64Decode(
fillins::CollapseWhitespaceASCII(encoded, true), &data_)) {
string_util::CollapseWhitespaceASCII(encoded, true), &data_)) {
// The most likely cause for a decode failure is a datatype that
// includes PEM headers, which are not supported.
break;

45
pki/string_util.cc
Unescape View File

@ -113,4 +113,49 @@ std::vector<std::string_view> SplitString(std::string_view str,
return out;
}
static bool IsUnicodeWhitespace(char c) {
return c == 9 || c == 10 || c == 11 || c == 12 || c == 13 || c == ' ';
}
std::string CollapseWhitespaceASCII(std::string_view text,
bool trim_sequences_with_line_breaks) {
std::string result;
result.resize(text.size());
// Set flags to pretend we're already in a trimmed whitespace sequence, so we
// will trim any leading whitespace.
bool in_whitespace = true;
bool already_trimmed = true;
int chars_written = 0;
for (auto i = text.begin(); i != text.end(); ++i) {
if (IsUnicodeWhitespace(*i)) {
if (!in_whitespace) {
// Reduce all whitespace sequences to a single space.
in_whitespace = true;
result[chars_written++] = L' ';
}
if (trim_sequences_with_line_breaks && !already_trimmed &&
((*i == '\n') || (*i == '\r'))) {
// Whitespace sequences containing CR or LF are eliminated entirely.
already_trimmed = true;
--chars_written;
}
} else {
// Non-whitespace chracters are copied straight across.
in_whitespace = false;
already_trimmed = false;
result[chars_written++] = *i;
}
}
if (in_whitespace && !already_trimmed) {
// Any trailing whitespace is eliminated.
--chars_written;
}
result.resize(chars_written);
return result;
}
} // namespace bssl::string_util

5
pki/string_util.h
Unescape View File

@ -57,6 +57,11 @@ OPENSSL_EXPORT std::string NumberToDecimalString(int i);
OPENSSL_EXPORT std::vector<std::string_view> SplitString(std::string_view str,
char split_char);
// Collapess whitespace in |text| to a single space and returns the result.
OPENSSL_EXPORT std::string CollapseWhitespaceASCII(
std::string_view text, bool trim_sequences_with_line_breaks);
} // namespace bssl::string_util
#endif // BSSL_PKI_STRING_UTIL_H_

1
sources.cmake
Unescape View File

@ -360,7 +360,6 @@ set(
pki/extended_key_usage.cc
pki/fillins/fillins_base64.cc
pki/fillins/openssl_util.cc
pki/fillins/fillins_string_util.cc
pki/general_names.cc
pki/input.cc
pki/ip_util.cc

Write Preview
Loading…
Cancel
Save