1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "mojo/public/cpp/system/file_data_source.h"
#include <algorithm>
#include <limits>
#include "base/numerics/safe_conversions.h"
namespace mojo {
namespace {
uint64_t CalculateEndOffset(base::File* file, MojoResult* result) {
if (!file->IsValid())
return 0u;
int64_t length = file->GetLength();
if (length < 0) {
*result =
FileDataSource::ConvertFileErrorToMojoResult(file->GetLastFileError());
return 0u;
}
return length;
}
} // namespace
// static
MojoResult FileDataSource::ConvertFileErrorToMojoResult(
base::File::Error error) {
switch (error) {
case base::File::FILE_OK:
return MOJO_RESULT_OK;
case base::File::FILE_ERROR_NOT_FOUND:
return MOJO_RESULT_NOT_FOUND;
case base::File::FILE_ERROR_SECURITY:
case base::File::FILE_ERROR_ACCESS_DENIED:
return MOJO_RESULT_PERMISSION_DENIED;
case base::File::FILE_ERROR_TOO_MANY_OPENED:
case base::File::FILE_ERROR_NO_MEMORY:
return MOJO_RESULT_RESOURCE_EXHAUSTED;
case base::File::FILE_ERROR_ABORT:
return MOJO_RESULT_ABORTED;
default:
return MOJO_RESULT_UNKNOWN;
}
}
FileDataSource::FileDataSource(base::File file)
: file_(std::move(file)),
error_(ConvertFileErrorToMojoResult(file_.error_details())),
start_offset_(0u),
end_offset_(CalculateEndOffset(&file_, &error_)) {}
FileDataSource::~FileDataSource() = default;
void FileDataSource::SetRange(uint64_t start, uint64_t end) {
if (start > end) {
start_offset_ = 0;
end_offset_ = 0;
if (error_ == MOJO_RESULT_OK)
error_ = MOJO_RESULT_INVALID_ARGUMENT;
} else {
start_offset_ = start;
end_offset_ = end;
}
}
uint64_t FileDataSource::GetLength() const {
return end_offset_ - start_offset_;
}
DataPipeProducer::DataSource::ReadResult FileDataSource::Read(
uint64_t offset,
base::span<char> buffer) {
ReadResult result;
if (error_ != MOJO_RESULT_OK)
result.result = error_;
else if (GetLength() < offset)
result.result = MOJO_RESULT_INVALID_ARGUMENT;
uint64_t readable_size = GetLength() - offset;
uint64_t read_size =
std::min(static_cast<uint64_t>(std::numeric_limits<int>::max()),
std::min(static_cast<uint64_t>(buffer.size()), readable_size));
// |read_offset| should not overflow if 'GetLength() < offset' is true.
// Otherwise, MOJO_RESULT_INVALID_ARGUMENT should be already set.
uint64_t read_offset = start_offset_ + offset;
if (read_offset > std::numeric_limits<int64_t>::max())
result.result = MOJO_RESULT_INVALID_ARGUMENT;
if (result.result != MOJO_RESULT_OK)
return result;
std::optional<size_t> bytes_read =
file_.Read(static_cast<int64_t>(read_offset),
base::as_writable_bytes(buffer).first(
base::checked_cast<size_t>(read_size)));
if (!bytes_read.has_value()) {
result.bytes_read = 0;
result.result = ConvertFileErrorToMojoResult(file_.GetLastFileError());
} else {
result.bytes_read = bytes_read.value();
}
return result;
}
} // namespace mojo
|
