| // Copyright 2019 The Fuchsia 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 "in_stream_file.h" | |
| #include "util.h" | |
| namespace { | |
| // Reads <= this size will complete in their entirety. Reads > this size may | |
| // read less. | |
| const uint64_t kCompleteReadThresholdBytes = 1; | |
| static_assert(kCompleteReadThresholdBytes >= 1); | |
| } // namespace | |
| InStreamFile::InStreamFile(async::Loop* fidl_loop, thrd_t fidl_thread, | |
| sys::ComponentContext* component_context, std::string input_file_name) | |
| : InStream(fidl_loop, fidl_thread, component_context), input_file_name_(input_file_name) { | |
| // std::ios::ate means start at the end to tellg() will get the size | |
| file_.open(input_file_name_.c_str(), std::ios::in | std::ios::binary | std::ios::ate); | |
| if (!file_.is_open()) { | |
| Exit("failed to open file %s", input_file_name_.c_str()); | |
| } | |
| std::streampos input_size = file_.tellg(); | |
| if (input_size == -1) { | |
| Exit("file.tellg() failed"); | |
| } | |
| eos_position_ = input_size; | |
| eos_position_known_ = true; | |
| file_.seekg(0, std::ios::beg); | |
| if (!file_) { | |
| Exit("file_.seekg(0, beg) failed"); | |
| } | |
| ZX_DEBUG_ASSERT(cursor_position_ == 0); | |
| } | |
| InStreamFile::~InStreamFile() { | |
| file_.close(); | |
| if (!file_) { | |
| Exit("file.close() failed"); | |
| } | |
| } | |
| zx_status_t InStreamFile::ReadBytesInternal(uint32_t max_bytes_to_read, uint32_t* bytes_read_out, | |
| uint8_t* buffer_out, zx::time just_fail_deadline) { | |
| // This sub-class doesn't enforce just_fail_deadline for now. | |
| (void)just_fail_deadline; | |
| // This implementation ignores the timeout, as we're reading from a local file | |
| // so not worth bothering with the timeout at least for now. | |
| ZX_DEBUG_ASSERT(static_cast<uint64_t>(file_.tellg()) == cursor_position_); | |
| ZX_DEBUG_ASSERT(eos_position_known_); | |
| ZX_DEBUG_ASSERT(cursor_position_ <= eos_position_); | |
| uint64_t bytes_to_read = max_bytes_to_read; | |
| if (cursor_position_ + bytes_to_read > eos_position_) { | |
| bytes_to_read = eos_position_ - cursor_position_; | |
| } | |
| if (!bytes_to_read) { | |
| // This indicates EOS. | |
| *bytes_read_out = 0; | |
| return ZX_OK; | |
| } | |
| // To avoid taking a dependency on complete reads, which in general InStream | |
| // doesn't guarantee, we intentionally don't read as much as requested | |
| // sometimes. Yes this does force the client code to perform quite a few | |
| // extra reads - that's intentional. | |
| if (bytes_to_read > kCompleteReadThresholdBytes) { | |
| bytes_to_read = bytes_to_read / 2; | |
| bytes_to_read = std::max(kCompleteReadThresholdBytes, bytes_to_read); | |
| } | |
| file_.read(reinterpret_cast<char*>(buffer_out), bytes_to_read); | |
| if (!file_) { | |
| Exit("file_.read() failed"); | |
| } | |
| ZX_DEBUG_ASSERT(static_cast<uint64_t>(file_.tellg()) == cursor_position_ + bytes_to_read); | |
| *bytes_read_out = bytes_to_read; | |
| // InStream::ReadBytes() takes care of advancing cursor_position_. | |
| return ZX_OK; | |
| } | |
| zx_status_t InStreamFile::ResetToStartInternal(zx::time just_fail_deadline) { | |
| // This sub-class doesn't envorce just_fail_deadline for now. | |
| (void)just_fail_deadline; | |
| file_.seekg(0, std::ios::beg); | |
| if (!file_) { | |
| Exit("file_.seekg(0, beg) failed"); | |
| } | |
| cursor_position_ = 0; | |
| return ZX_OK; | |
| } |