153 lines
3.5 KiB
C++
153 lines
3.5 KiB
C++
/*
|
|
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "webrtc/system_wrappers/include/file_wrapper.h"
|
|
|
|
#ifdef _WIN32
|
|
#include <Windows.h>
|
|
#else
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#endif
|
|
|
|
#include "webrtc/base/checks.h"
|
|
|
|
namespace webrtc {
|
|
namespace {
|
|
FILE* FileOpen(const char* file_name_utf8, bool read_only) {
|
|
#if defined(_WIN32)
|
|
int len = MultiByteToWideChar(CP_UTF8, 0, file_name_utf8, -1, nullptr, 0);
|
|
std::wstring wstr(len, 0);
|
|
MultiByteToWideChar(CP_UTF8, 0, file_name_utf8, -1, &wstr[0], len);
|
|
FILE* file = _wfopen(wstr.c_str(), read_only ? L"rb" : L"wb");
|
|
#else
|
|
FILE* file = fopen(file_name_utf8, read_only ? "rb" : "wb");
|
|
#endif
|
|
return file;
|
|
}
|
|
} // namespace
|
|
|
|
// static
|
|
FileWrapper* FileWrapper::Create() {
|
|
return new FileWrapper();
|
|
}
|
|
|
|
// static
|
|
FileWrapper FileWrapper::Open(const char* file_name_utf8, bool read_only) {
|
|
return FileWrapper(FileOpen(file_name_utf8, read_only), 0);
|
|
}
|
|
|
|
FileWrapper::FileWrapper() {}
|
|
|
|
FileWrapper::FileWrapper(FILE* file, size_t max_size)
|
|
: file_(file), max_size_in_bytes_(max_size) {}
|
|
|
|
FileWrapper::~FileWrapper() {
|
|
CloseFileImpl();
|
|
}
|
|
|
|
FileWrapper::FileWrapper(FileWrapper&& other) {
|
|
operator=(std::move(other));
|
|
}
|
|
|
|
FileWrapper& FileWrapper::operator=(FileWrapper&& other) {
|
|
file_ = other.file_;
|
|
max_size_in_bytes_ = other.max_size_in_bytes_;
|
|
position_ = other.position_;
|
|
other.file_ = nullptr;
|
|
return *this;
|
|
}
|
|
|
|
void FileWrapper::CloseFile() {
|
|
rtc::CritScope lock(&lock_);
|
|
CloseFileImpl();
|
|
}
|
|
|
|
int FileWrapper::Rewind() {
|
|
rtc::CritScope lock(&lock_);
|
|
if (file_ != nullptr) {
|
|
position_ = 0;
|
|
return fseek(file_, 0, SEEK_SET);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void FileWrapper::SetMaxFileSize(size_t bytes) {
|
|
rtc::CritScope lock(&lock_);
|
|
max_size_in_bytes_ = bytes;
|
|
}
|
|
|
|
int FileWrapper::Flush() {
|
|
rtc::CritScope lock(&lock_);
|
|
return FlushImpl();
|
|
}
|
|
|
|
bool FileWrapper::OpenFile(const char* file_name_utf8, bool read_only) {
|
|
size_t length = strlen(file_name_utf8);
|
|
if (length > kMaxFileNameSize - 1)
|
|
return false;
|
|
|
|
rtc::CritScope lock(&lock_);
|
|
if (file_ != nullptr)
|
|
return false;
|
|
|
|
file_ = FileOpen(file_name_utf8, read_only);
|
|
return file_ != nullptr;
|
|
}
|
|
|
|
bool FileWrapper::OpenFromFileHandle(FILE* handle) {
|
|
if (!handle)
|
|
return false;
|
|
rtc::CritScope lock(&lock_);
|
|
CloseFileImpl();
|
|
file_ = handle;
|
|
return true;
|
|
}
|
|
|
|
int FileWrapper::Read(void* buf, size_t length) {
|
|
rtc::CritScope lock(&lock_);
|
|
if (file_ == nullptr)
|
|
return -1;
|
|
|
|
size_t bytes_read = fread(buf, 1, length, file_);
|
|
return static_cast<int>(bytes_read);
|
|
}
|
|
|
|
bool FileWrapper::Write(const void* buf, size_t length) {
|
|
if (buf == nullptr)
|
|
return false;
|
|
|
|
rtc::CritScope lock(&lock_);
|
|
|
|
if (file_ == nullptr)
|
|
return false;
|
|
|
|
// Check if it's time to stop writing.
|
|
if (max_size_in_bytes_ > 0 && (position_ + length) > max_size_in_bytes_)
|
|
return false;
|
|
|
|
size_t num_bytes = fwrite(buf, 1, length, file_);
|
|
position_ += num_bytes;
|
|
|
|
return num_bytes == length;
|
|
}
|
|
|
|
void FileWrapper::CloseFileImpl() {
|
|
if (file_ != nullptr)
|
|
fclose(file_);
|
|
file_ = nullptr;
|
|
}
|
|
|
|
int FileWrapper::FlushImpl() {
|
|
return (file_ != nullptr) ? fflush(file_) : -1;
|
|
}
|
|
|
|
} // namespace webrtc
|