mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-29 00:32:35 +08:00
51b21d8874
This implements a non-stdio-based getline() equivalent. getline() is not in the Android NDK until API 21 (Android 5.0.0), while Chrome builds for 32-bit platforms with API 16 (Android 4.1.0). Although a getline() declaration could be provided in compat for use with older NDK headers, it’s desirable to move away from stdio entirely. The C++ DelimitedFileReader interface is also a bit more comfortable to use than getline(). A getdelim() equivalent is also provided, and is also used in the Linux/Android ProcessInfo implementation. Bug: crashpad:30 Test: crashpad_util_test FileLineReader.*:ProcessInfo.* Change-Id: Ic1664758a87cfe4953ab22bd3ae190761404b22c Reviewed-on: https://chromium-review.googlesource.com/455998 Reviewed-by: Joshua Peraza <jperaza@chromium.org> Commit-Queue: Mark Mentovai <mark@chromium.org>
110 lines
3.9 KiB
C++
110 lines
3.9 KiB
C++
// Copyright 2017 The Crashpad Authors. All rights reserved.
|
||
//
|
||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
// you may not use this file except in compliance with the License.
|
||
// You may obtain a copy of the License at
|
||
//
|
||
// http://www.apache.org/licenses/LICENSE-2.0
|
||
//
|
||
// Unless required by applicable law or agreed to in writing, software
|
||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
// See the License for the specific language governing permissions and
|
||
// limitations under the License.
|
||
|
||
#include "util/file/delimited_file_reader.h"
|
||
|
||
#include <sys/types.h>
|
||
|
||
#include <algorithm>
|
||
#include <limits>
|
||
|
||
#include "base/logging.h"
|
||
#include "base/numerics/safe_conversions.h"
|
||
|
||
namespace crashpad {
|
||
|
||
DelimitedFileReader::DelimitedFileReader(FileReaderInterface* file_reader)
|
||
: file_reader_(file_reader), buf_pos_(0), buf_len_(0), eof_(false) {
|
||
static_assert(sizeof(buf_) <= std::numeric_limits<decltype(buf_pos_)>::max(),
|
||
"buf_pos_ must cover buf_");
|
||
static_assert(sizeof(buf_) <= std::numeric_limits<decltype(buf_len_)>::max(),
|
||
"buf_len_ must cover buf_");
|
||
}
|
||
|
||
DelimitedFileReader::~DelimitedFileReader() {}
|
||
|
||
DelimitedFileReader::Result DelimitedFileReader::GetDelim(char delimiter,
|
||
std::string* field) {
|
||
if (eof_) {
|
||
DCHECK_EQ(buf_pos_, buf_len_);
|
||
|
||
// Allow subsequent calls to attempt to read more data from the file. If the
|
||
// file is still at EOF in the future, the read will return 0 and cause
|
||
// kEndOfFile to be returned anyway.
|
||
eof_ = false;
|
||
|
||
return Result::kEndOfFile;
|
||
}
|
||
|
||
std::string local_field;
|
||
while (true) {
|
||
if (buf_pos_ == buf_len_) {
|
||
// buf_ is empty. Refill it.
|
||
FileOperationResult read_result = file_reader_->Read(buf_, sizeof(buf_));
|
||
if (read_result < 0) {
|
||
return Result::kError;
|
||
} else if (read_result == 0) {
|
||
if (!local_field.empty()) {
|
||
// The file ended with a field that wasn’t terminated by a delimiter
|
||
// character.
|
||
//
|
||
// This is EOF, but EOF can’t be returned because there’s a field that
|
||
// needs to be returned to the caller. Cache the detected EOF so it
|
||
// can be returned next time. This is done to support proper semantics
|
||
// for weird “files” like terminal input that can reach EOF and then
|
||
// “grow”, allowing subsequent reads past EOF to block while waiting
|
||
// for more data. Once EOF is detected by a read that returns 0, that
|
||
// EOF signal should propagate to the caller before attempting a new
|
||
// read. Here, it will be returned on the next call to this method
|
||
// without attempting to read more data.
|
||
eof_ = true;
|
||
field->swap(local_field);
|
||
return Result::kSuccess;
|
||
}
|
||
return Result::kEndOfFile;
|
||
}
|
||
|
||
DCHECK_LE(static_cast<size_t>(read_result), arraysize(buf_));
|
||
DCHECK(
|
||
base::IsValueInRangeForNumericType<decltype(buf_len_)>(read_result));
|
||
buf_len_ = static_cast<decltype(buf_len_)>(read_result);
|
||
buf_pos_ = 0;
|
||
}
|
||
|
||
const char* const start = buf_ + buf_pos_;
|
||
const char* const end = buf_ + buf_len_;
|
||
const char* const found = std::find(start, end, delimiter);
|
||
|
||
local_field.append(start, found);
|
||
buf_pos_ = static_cast<decltype(buf_pos_)>(found - buf_);
|
||
DCHECK_LE(buf_pos_, buf_len_);
|
||
|
||
if (found != end) {
|
||
// A real delimiter character was found. Append it to the field being
|
||
// built and return it.
|
||
local_field.push_back(delimiter);
|
||
++buf_pos_;
|
||
DCHECK_LE(buf_pos_, buf_len_);
|
||
field->swap(local_field);
|
||
return Result::kSuccess;
|
||
}
|
||
}
|
||
}
|
||
|
||
DelimitedFileReader::Result DelimitedFileReader::GetLine(std::string* line) {
|
||
return GetDelim('\n', line);
|
||
}
|
||
|
||
} // namespace crashpad
|