2016-12-14 18:37:44 +01:00
|
|
|
// OpenVPN -- An application to securely tunnel IP networks
|
|
|
|
// over a single port, with support for SSL/TLS-based
|
|
|
|
// session authentication and key exchange,
|
|
|
|
// packet encryption, packet authentication, and
|
|
|
|
// packet compression.
|
|
|
|
//
|
2022-09-29 11:41:13 +02:00
|
|
|
// Copyright (C) 2012-2022 OpenVPN Inc.
|
2016-12-14 18:37:44 +01:00
|
|
|
//
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
2017-12-21 21:42:20 +01:00
|
|
|
// it under the terms of the GNU Affero General Public License Version 3
|
2016-12-14 18:37:44 +01:00
|
|
|
// as published by the Free Software Foundation.
|
|
|
|
//
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2017-12-21 21:42:20 +01:00
|
|
|
// GNU Affero General Public License for more details.
|
2016-12-14 18:37:44 +01:00
|
|
|
//
|
2017-12-21 21:42:20 +01:00
|
|
|
// You should have received a copy of the GNU Affero General Public License
|
2016-12-14 18:37:44 +01:00
|
|
|
// along with this program in the COPYING file.
|
|
|
|
// If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
// Unix file read/write
|
|
|
|
|
2022-01-31 06:10:01 +01:00
|
|
|
#pragma once
|
2016-12-14 18:37:44 +01:00
|
|
|
|
|
|
|
#include <openvpn/common/platform.hpp>
|
|
|
|
|
|
|
|
#if defined(OPENVPN_PLATFORM_WIN)
|
|
|
|
#error unix file methods not supported on Windows
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
#include <unistd.h> // for lseek
|
|
|
|
#include <sys/types.h> // for lseek, open
|
|
|
|
#include <sys/stat.h> // for open
|
|
|
|
#include <fcntl.h> // for open
|
2018-08-20 07:34:46 +02:00
|
|
|
#include <cstdint>
|
2016-12-14 18:37:44 +01:00
|
|
|
|
|
|
|
#include <openvpn/common/exception.hpp>
|
|
|
|
#include <openvpn/common/size.hpp>
|
|
|
|
#include <openvpn/common/scoped_fd.hpp>
|
|
|
|
#include <openvpn/common/write.hpp>
|
2017-04-23 01:54:01 +02:00
|
|
|
#include <openvpn/common/strerror.hpp>
|
2020-06-23 01:54:18 +02:00
|
|
|
#include <openvpn/common/stat.hpp>
|
2018-08-20 07:34:46 +02:00
|
|
|
#include <openvpn/common/modstat.hpp>
|
2022-01-31 06:10:01 +01:00
|
|
|
#include <openvpn/common/stringtempl.hpp>
|
2016-12-14 18:37:44 +01:00
|
|
|
#include <openvpn/buffer/bufread.hpp>
|
|
|
|
|
|
|
|
namespace openvpn {
|
|
|
|
OPENVPN_EXCEPTION(file_unix_error);
|
|
|
|
|
|
|
|
// write binary buffer to file
|
2022-05-13 18:35:16 +02:00
|
|
|
static constexpr mode_t WRITE_BINARY_UNIX_EXISTING = 010000; // special mode that is useful for writing /proc files
|
2016-12-14 18:37:44 +01:00
|
|
|
inline void write_binary_unix(const std::string& fn,
|
|
|
|
const mode_t mode,
|
2018-08-20 07:34:46 +02:00
|
|
|
const std::uint64_t mtime_ns, // set explicit modification-time in nanoseconds since epoch, or 0 to defer to system
|
2016-12-14 18:37:44 +01:00
|
|
|
const void *buf,
|
2020-01-06 05:26:37 +01:00
|
|
|
const ssize_t size)
|
2016-12-14 18:37:44 +01:00
|
|
|
{
|
|
|
|
// open
|
2022-05-13 18:35:16 +02:00
|
|
|
int flags = O_WRONLY|O_CLOEXEC;
|
|
|
|
if (!(mode & WRITE_BINARY_UNIX_EXISTING))
|
|
|
|
flags |= O_CREAT|O_TRUNC;
|
|
|
|
ScopedFD fd(::open(fn.c_str(), flags, mode & (WRITE_BINARY_UNIX_EXISTING-1)));
|
2016-12-14 18:37:44 +01:00
|
|
|
if (!fd.defined())
|
|
|
|
{
|
|
|
|
const int eno = errno;
|
2017-04-23 01:54:01 +02:00
|
|
|
throw file_unix_error(fn + " : open for write : " + strerror_str(eno));
|
2016-12-14 18:37:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// write
|
2018-08-20 07:34:46 +02:00
|
|
|
if (size)
|
|
|
|
{
|
|
|
|
const ssize_t len = write_retry(fd(), buf, size);
|
|
|
|
if (len != size)
|
2020-08-22 21:26:29 +02:00
|
|
|
{
|
|
|
|
if (len == -1)
|
|
|
|
{
|
|
|
|
const int eno = errno;
|
|
|
|
throw file_unix_error(fn + " : write error : " + strerror_str(eno));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
throw file_unix_error(fn + " : incomplete write, request_size=" + std::to_string(size) + " actual_size=" + std::to_string(len));
|
|
|
|
}
|
2018-08-20 07:34:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// explicit modification time
|
|
|
|
if (mtime_ns)
|
|
|
|
update_file_mod_time_nanoseconds(fd(), mtime_ns);
|
2016-12-14 18:37:44 +01:00
|
|
|
|
|
|
|
// close
|
|
|
|
{
|
|
|
|
const int eno = fd.close_with_errno();
|
|
|
|
if (eno)
|
2017-04-23 01:54:01 +02:00
|
|
|
throw file_unix_error(fn + " : close for write : " + strerror_str(eno));
|
2016-12-14 18:37:44 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void write_binary_unix(const std::string& fn,
|
|
|
|
const mode_t mode,
|
2018-08-20 07:34:46 +02:00
|
|
|
const std::uint64_t mtime_ns,
|
2016-12-14 18:37:44 +01:00
|
|
|
const Buffer& buf)
|
|
|
|
{
|
2018-08-20 07:34:46 +02:00
|
|
|
write_binary_unix(fn, mode, mtime_ns, buf.c_data(), buf.size());
|
2017-12-29 06:45:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
inline void write_binary_unix(const std::string& fn,
|
|
|
|
const mode_t mode,
|
2018-08-20 07:34:46 +02:00
|
|
|
const std::uint64_t mtime_ns,
|
2017-12-29 06:45:25 +01:00
|
|
|
const ConstBuffer& buf)
|
|
|
|
{
|
2018-08-20 07:34:46 +02:00
|
|
|
write_binary_unix(fn, mode, mtime_ns, buf.c_data(), buf.size());
|
2016-12-14 18:37:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
inline void write_text_unix(const std::string& fn,
|
|
|
|
const mode_t mode,
|
2018-08-20 07:34:46 +02:00
|
|
|
const std::uint64_t mtime_ns,
|
2016-12-14 18:37:44 +01:00
|
|
|
const std::string& content)
|
|
|
|
{
|
2018-08-20 07:34:46 +02:00
|
|
|
write_binary_unix(fn, mode, mtime_ns, content.c_str(), content.length());
|
2016-12-14 18:37:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
enum { // MUST be distinct from BufferAllocated flags
|
|
|
|
NULL_ON_ENOENT = (1<<8),
|
|
|
|
};
|
|
|
|
inline BufferPtr read_binary_unix(const std::string& fn,
|
|
|
|
const std::uint64_t max_size = 0,
|
2020-06-23 01:54:18 +02:00
|
|
|
const unsigned int buffer_flags = 0,
|
|
|
|
std::uint64_t* mtime_ns = nullptr)
|
2016-12-14 18:37:44 +01:00
|
|
|
{
|
|
|
|
// open
|
|
|
|
ScopedFD fd(::open(fn.c_str(), O_RDONLY|O_CLOEXEC));
|
|
|
|
if (!fd.defined())
|
|
|
|
{
|
|
|
|
const int eno = errno;
|
|
|
|
if ((buffer_flags & NULL_ON_ENOENT) && eno == ENOENT)
|
|
|
|
return BufferPtr();
|
2017-04-23 01:54:01 +02:00
|
|
|
throw file_unix_error(fn + " : open for read : " + strerror_str(eno));
|
2016-12-14 18:37:44 +01:00
|
|
|
}
|
|
|
|
|
2020-06-23 01:54:18 +02:00
|
|
|
// get file timestamp
|
|
|
|
if (mtime_ns)
|
|
|
|
*mtime_ns = fd_mod_time_nanoseconds(fd());
|
|
|
|
|
2016-12-14 18:37:44 +01:00
|
|
|
// get file length
|
|
|
|
const off_t length = ::lseek(fd(), 0, SEEK_END);
|
|
|
|
if (length < 0)
|
|
|
|
{
|
|
|
|
const int eno = errno;
|
2017-04-23 01:54:01 +02:00
|
|
|
throw file_unix_error(fn + " : seek end error : " + strerror_str(eno));
|
2016-12-14 18:37:44 +01:00
|
|
|
}
|
|
|
|
if (::lseek(fd(), 0, SEEK_SET) != 0)
|
|
|
|
{
|
|
|
|
const int eno = errno;
|
2017-04-23 01:54:01 +02:00
|
|
|
throw file_unix_error(fn + " : seek begin error : " + strerror_str(eno));
|
2016-12-14 18:37:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// maximum size exceeded?
|
|
|
|
if (max_size && std::uint64_t(length) > max_size)
|
|
|
|
throw file_unix_error(fn + " : file too large [" + std::to_string(length) + '/' + std::to_string(max_size) + ']');
|
|
|
|
|
|
|
|
// allocate buffer
|
|
|
|
BufferPtr bp = new BufferAllocated(size_t(length), buffer_flags);
|
|
|
|
|
|
|
|
// read file content into buffer
|
|
|
|
while (buf_read(fd(), *bp, fn))
|
|
|
|
;
|
|
|
|
|
|
|
|
// check for close error
|
|
|
|
{
|
|
|
|
const int eno = fd.close_with_errno();
|
|
|
|
if (eno)
|
2017-04-23 01:54:01 +02:00
|
|
|
throw file_unix_error(fn + " : close for read : " + strerror_str(eno));
|
2016-12-14 18:37:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return bp;
|
|
|
|
}
|
|
|
|
|
2020-08-22 21:28:12 +02:00
|
|
|
// read file into a fixed buffer, return zero or errno
|
2022-01-31 06:10:01 +01:00
|
|
|
template <typename STRING>
|
|
|
|
inline int read_binary_unix_fast(const STRING& fn,
|
2020-06-23 01:54:18 +02:00
|
|
|
Buffer& out,
|
|
|
|
std::uint64_t* mtime_ns = nullptr)
|
2017-12-29 06:46:09 +01:00
|
|
|
{
|
2022-01-31 06:10:01 +01:00
|
|
|
ScopedFD fd(::open(StringTempl::to_cstring(fn), O_RDONLY|O_CLOEXEC));
|
2017-12-29 06:46:09 +01:00
|
|
|
if (!fd.defined())
|
2019-07-22 22:48:00 +02:00
|
|
|
return errno;
|
2020-06-23 01:54:18 +02:00
|
|
|
if (mtime_ns)
|
|
|
|
*mtime_ns = fd_mod_time_nanoseconds(fd());
|
2020-08-22 21:28:12 +02:00
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
const size_t remaining = out.remaining(0);
|
|
|
|
if (!remaining)
|
|
|
|
return EAGAIN; // note that we also return EAGAIN if buffer is exactly the same size as content
|
|
|
|
const ssize_t status = ::read(fd(), out.data_end(), remaining);
|
|
|
|
if (status == 0)
|
|
|
|
return 0;
|
|
|
|
else if (status < 0)
|
|
|
|
return errno;
|
|
|
|
out.inc_size(status);
|
|
|
|
}
|
2017-12-29 06:46:09 +01:00
|
|
|
}
|
|
|
|
|
2016-12-14 18:37:44 +01:00
|
|
|
inline std::string read_text_unix(const std::string& filename,
|
|
|
|
const std::uint64_t max_size = 0,
|
2020-06-23 01:54:18 +02:00
|
|
|
const unsigned int buffer_flags = 0,
|
|
|
|
std::uint64_t* mtime_ns = nullptr)
|
2016-12-14 18:37:44 +01:00
|
|
|
{
|
2020-06-23 01:54:18 +02:00
|
|
|
BufferPtr bp = read_binary_unix(filename, max_size, buffer_flags, mtime_ns);
|
2016-12-14 18:37:44 +01:00
|
|
|
if (bp)
|
|
|
|
return buf_to_string(*bp);
|
|
|
|
else
|
|
|
|
return std::string();
|
|
|
|
}
|
|
|
|
}
|