ftpiiu_plugin/source/fs.cpp

283 lines
6.1 KiB
C++
Raw Normal View History

2020-04-05 21:16:16 +02:00
// ftpd is a server implementation based on the following:
// - RFC 959 (https://tools.ietf.org/html/rfc959)
// - RFC 3659 (https://tools.ietf.org/html/rfc3659)
// - suggested implementation details from https://cr.yp.to/ftp/filesystem.html
//
// Copyright (C) 2020 Michael Theall
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// 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
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "fs.h"
2020-05-19 03:45:46 +02:00
#include <cassert>
2020-04-05 21:16:16 +02:00
#include <cinttypes>
#include <cstdio>
2020-05-08 06:30:23 +02:00
#include <string>
2020-04-05 21:16:16 +02:00
2022-03-31 18:53:47 +02:00
#if defined(NDS) || defined(__3DS__) || defined(__SWITCH__)
2020-04-24 22:51:43 +02:00
#define getline __getline
#endif
2020-04-05 21:16:16 +02:00
std::string fs::printSize (std::uint64_t const size_)
{
constexpr std::uint64_t const KiB = 1024;
constexpr std::uint64_t const MiB = 1024 * KiB;
constexpr std::uint64_t const GiB = 1024 * MiB;
constexpr std::uint64_t const TiB = 1024 * GiB;
constexpr std::uint64_t const PiB = 1024 * TiB;
constexpr std::uint64_t const EiB = 1024 * PiB;
char buffer[64] = {};
for (auto const &[name, bin] : {
// clang-format off
std::make_pair ("EiB", EiB),
std::make_pair ("PiB", PiB),
std::make_pair ("TiB", TiB),
std::make_pair ("GiB", GiB),
std::make_pair ("MiB", MiB),
std::make_pair ("KiB", KiB)
// clang-format on
})
{
2020-04-06 07:36:03 +02:00
// get the integral portion of the number
2020-04-05 21:16:16 +02:00
auto const whole = size_ / bin;
if (size_ >= 100 * bin)
{
2020-04-06 07:36:03 +02:00
// >= 100, print xxxXiB
2020-04-05 21:16:16 +02:00
std::sprintf (buffer, "%" PRIu64 "%s", whole, name);
return buffer;
}
2020-04-06 07:36:03 +02:00
// get the fractional portion of the number
2020-04-05 21:16:16 +02:00
auto const frac = size_ - whole * bin;
if (size_ >= 10 * bin)
{
2020-04-06 07:36:03 +02:00
// >= 10, print xx.xXiB
2020-04-05 21:16:16 +02:00
std::sprintf (buffer, "%" PRIu64 ".%" PRIu64 "%s", whole, frac * 10 / bin, name);
return buffer;
}
if (size_ >= 1000 * (bin / KiB))
{
2020-04-06 07:36:03 +02:00
// >= 1000 of lesser bin, print x.xxXiB
2020-04-05 21:16:16 +02:00
std::sprintf (buffer, "%" PRIu64 ".%02" PRIu64 "%s", whole, frac * 100 / bin, name);
return buffer;
}
}
2020-04-06 07:36:03 +02:00
// < 1KiB, just print the number
std::sprintf (buffer, "%" PRIu64 "B", size_);
2020-04-05 21:16:16 +02:00
return buffer;
}
///////////////////////////////////////////////////////////////////////////
2020-04-24 22:51:43 +02:00
fs::File::~File ()
{
std::free (m_lineBuffer);
}
2020-04-05 21:16:16 +02:00
fs::File::File () = default;
fs::File::File (File &&that_) = default;
fs::File &fs::File::operator= (File &&that_) = default;
fs::File::operator bool () const
{
return static_cast<bool> (m_fp);
}
fs::File::operator FILE * () const
{
return m_fp.get ();
}
void fs::File::setBufferSize (std::size_t const size_)
{
if (m_bufferSize != size_)
{
m_buffer = std::make_unique<char[]> (size_);
m_bufferSize = size_;
}
if (m_fp)
std::setvbuf (m_fp.get (), m_buffer.get (), _IOFBF, m_bufferSize);
}
bool fs::File::open (char const *const path_, char const *const mode_)
{
auto const fp = std::fopen (path_, mode_);
if (!fp)
return false;
m_fp = std::unique_ptr<std::FILE, int (*) (std::FILE *)> (fp, &std::fclose);
if (m_buffer)
std::setvbuf (m_fp.get (), m_buffer.get (), _IOFBF, m_bufferSize);
return true;
}
void fs::File::close ()
{
m_fp.reset ();
}
2020-05-19 03:45:46 +02:00
std::make_signed_t<std::size_t> fs::File::seek (std::size_t const pos_, int const origin_)
2020-04-05 21:16:16 +02:00
{
return std::fseek (m_fp.get (), pos_, origin_);
}
2020-05-19 03:45:46 +02:00
std::make_signed_t<std::size_t> fs::File::read (void *const buffer_, std::size_t const size_)
2020-04-05 21:16:16 +02:00
{
2020-05-19 03:45:46 +02:00
assert (buffer_);
assert (size_ > 0);
return std::fread (buffer_, 1, size_, m_fp.get ());
}
std::make_signed_t<std::size_t> fs::File::read (IOBuffer &buffer_)
{
assert (buffer_.freeSize () > 0);
auto const rc = read (buffer_.freeArea (), buffer_.freeSize ());
if (rc > 0)
buffer_.markUsed (rc);
return rc;
2020-04-05 21:16:16 +02:00
}
2020-04-24 22:51:43 +02:00
std::string_view fs::File::readLine ()
{
while (true)
{
auto rc = ::getline (&m_lineBuffer, &m_lineBufferSize, m_fp.get ());
if (rc < 0)
return {};
while (rc > 0)
{
if (m_lineBuffer[rc - 1] != '\r' && m_lineBuffer[rc - 1] != '\n')
break;
m_lineBuffer[--rc] = 0;
}
if (rc > 0)
return std::string_view (m_lineBuffer, rc);
}
}
2020-05-19 03:45:46 +02:00
bool fs::File::readAll (void *const buffer_, std::size_t const size_)
2020-04-05 21:16:16 +02:00
{
2020-05-19 03:45:46 +02:00
assert (buffer_);
assert (size_ > 0);
auto p = static_cast<char *> (buffer_);
2020-04-05 21:16:16 +02:00
2020-05-19 03:45:46 +02:00
std::size_t bytes = 0;
2020-04-05 21:16:16 +02:00
while (bytes < size_)
{
auto const rc = read (p, size_ - bytes);
if (rc <= 0)
return false;
p += rc;
bytes += rc;
}
return true;
}
2020-05-19 03:45:46 +02:00
std::make_signed_t<std::size_t> fs::File::write (void const *const buffer_, std::size_t const size_)
2020-04-05 21:16:16 +02:00
{
assert (buffer_);
assert (size_ > 0);
2020-05-19 03:45:46 +02:00
return std::fwrite (buffer_, 1, size_, m_fp.get ());
2020-04-05 21:16:16 +02:00
}
std::make_signed_t<std::size_t> fs::File::write (IOBuffer &buffer_)
{
assert (buffer_.usedSize () > 0);
auto const rc = write (buffer_.usedArea (), buffer_.usedSize ());
if (rc > 0)
buffer_.markFree (rc);
return rc;
}
2020-05-19 03:45:46 +02:00
bool fs::File::writeAll (void const *const buffer_, std::size_t const size_)
2020-04-05 21:16:16 +02:00
{
2020-05-19 03:45:46 +02:00
assert (buffer_);
assert (size_ > 0);
auto p = static_cast<char const *> (buffer_);
2020-04-05 21:16:16 +02:00
2020-05-19 03:45:46 +02:00
std::size_t bytes = 0;
2020-04-05 21:16:16 +02:00
while (bytes < size_)
{
auto const rc = write (p, size_ - bytes);
if (rc <= 0)
return false;
p += rc;
bytes += rc;
}
return true;
}
///////////////////////////////////////////////////////////////////////////
fs::Dir::~Dir () = default;
fs::Dir::Dir () = default;
fs::Dir::Dir (Dir &&that_) = default;
fs::Dir &fs::Dir::operator= (Dir &&that_) = default;
fs::Dir::operator bool () const
{
return static_cast<bool> (m_dp);
}
fs::Dir::operator DIR * () const
{
return m_dp.get ();
}
bool fs::Dir::open (char const *const path_)
{
auto const dp = ::opendir (path_);
if (!dp)
return false;
m_dp = std::unique_ptr<DIR, int (*) (DIR *)> (dp, &::closedir);
return true;
}
void fs::Dir::close ()
{
m_dp.reset ();
}
struct dirent *fs::Dir::read ()
{
2020-04-06 07:36:03 +02:00
errno = 0;
2020-04-05 21:16:16 +02:00
return ::readdir (m_dp.get ());
}