github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge 087282fcf1 into b519ce04e3

pull/807/merge
Nils Maier 2024-08-24 10:39:36 -07:00 committed by GitHub
parent b519ce04e3 087282fcf1
commit 45d8f8694b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 381 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/Makefile.am
View File

@ -255,6 +255,7 @@ SRCS = \
uri_split.c uri_split.h\
usage_text.h\
util.cc util.h\
util_fs.cc\
util_security.cc util_security.h\
ValueBase.cc ValueBase.h\
ValueBaseDiskWriter.h\

5
src/RpcMethodFactory.cc
View File

@ -88,6 +88,7 @@ std::vector<std::string> rpcMethodNames = {
"aria2.forceShutdown",
"aria2.getGlobalStat",
"aria2.saveSession",
"aria2.getDiskspaceInformation",
"system.multicall",
"system.listMethods",
"system.listNotifications",
@ -251,6 +252,10 @@ std::unique_ptr<RpcMethod> createMethod(const std::string& methodName)
return make_unique<SaveSessionRpcMethod>();
}
if (methodName == GetDiskspaceInformationRpcMethod::getMethodName()) {
return make_unique<GetDiskspaceInformationRpcMethod>();
}
if (methodName == SystemMulticallRpcMethod::getMethodName()) {
return make_unique<SystemMulticallRpcMethod>();
}

152
src/RpcMethodImpl.cc
View File

@ -95,58 +95,62 @@ const char VLB_COMPLETE[] = "complete";
const char VLB_USED[] = "used";
const char VLB_ZERO[] = "0";
const char KEY_GID[] = "gid";
const char KEY_AM_CHOKING[] = "amChoking";
const char KEY_ANNOUNCE_LIST[] = "announceList";
const char KEY_BELONGS_TO[] = "belongsTo";
const char KEY_BITFIELD[] = "bitfield";
const char KEY_BITTORRENT[] = "bittorrent";
const char KEY_COMMENT[] = "comment";
const char KEY_COMPLETED_LENGTH[] = "completedLength";
const char KEY_CONNECTIONS[] = "connections";
const char KEY_CREATION_DATE[] = "creationDate";
const char KEY_CURRENT_URI[] = "currentUri";
const char KEY_DIR[] = "dir";
const char KEY_DISKSPACE_AVAILABLE[] = "available";
const char KEY_DISKSPACE_CAPACITY[] = "capacity";
const char KEY_DISKSPACE_FREE[] = "free";
const char KEY_DISKSPACE_PATH[] = "path";
const char KEY_DOWNLOAD_SPEED[] = "downloadSpeed";
const char KEY_ENABLED_FEATURES[] = "enabledFeatures";
const char KEY_ERROR_CODE[] = "errorCode";
const char KEY_ERROR_MESSAGE[] = "errorMessage";
const char KEY_STATUS[] = "status";
const char KEY_TOTAL_LENGTH[] = "totalLength";
const char KEY_COMPLETED_LENGTH[] = "completedLength";
const char KEY_DOWNLOAD_SPEED[] = "downloadSpeed";
const char KEY_UPLOAD_SPEED[] = "uploadSpeed";
const char KEY_UPLOAD_LENGTH[] = "uploadLength";
const char KEY_CONNECTIONS[] = "connections";
const char KEY_BITFIELD[] = "bitfield";
const char KEY_PIECE_LENGTH[] = "pieceLength";
const char KEY_NUM_PIECES[] = "numPieces";
const char KEY_FILES[] = "files";
const char KEY_FOLLOWED_BY[] = "followedBy";
const char KEY_FOLLOWING[] = "following";
const char KEY_BELONGS_TO[] = "belongsTo";
const char KEY_INFO_HASH[] = "infoHash";
const char KEY_NUM_SEEDERS[] = "numSeeders";
const char KEY_PEER_ID[] = "peerId";
const char KEY_IP[] = "ip";
const char KEY_PORT[] = "port";
const char KEY_AM_CHOKING[] = "amChoking";
const char KEY_PEER_CHOKING[] = "peerChoking";
const char KEY_SEEDER[] = "seeder";
const char KEY_GID[] = "gid";
const char KEY_INDEX[] = "index";
const char KEY_PATH[] = "path";
const char KEY_SELECTED[] = "selected";
const char KEY_LENGTH[] = "length";
const char KEY_URI[] = "uri";
const char KEY_CURRENT_URI[] = "currentUri";
const char KEY_VERSION[] = "version";
const char KEY_ENABLED_FEATURES[] = "enabledFeatures";
const char KEY_METHOD_NAME[] = "methodName";
const char KEY_PARAMS[] = "params";
const char KEY_SESSION_ID[] = "sessionId";
const char KEY_FILES[] = "files";
const char KEY_DIR[] = "dir";
const char KEY_URIS[] = "uris";
const char KEY_BITTORRENT[] = "bittorrent";
const char KEY_INFO[] = "info";
const char KEY_NAME[] = "name";
const char KEY_ANNOUNCE_LIST[] = "announceList";
const char KEY_COMMENT[] = "comment";
const char KEY_CREATION_DATE[] = "creationDate";
const char KEY_INFO_HASH[] = "infoHash";
const char KEY_IP[] = "ip";
const char KEY_LENGTH[] = "length";
const char KEY_METHOD_NAME[] = "methodName";
const char KEY_MODE[] = "mode";
const char KEY_SERVERS[] = "servers";
const char KEY_NUM_WAITING[] = "numWaiting";
const char KEY_NUM_STOPPED[] = "numStopped";
const char KEY_NAME[] = "name";
const char KEY_NUM_ACTIVE[] = "numActive";
const char KEY_NUM_PIECES[] = "numPieces";
const char KEY_NUM_SEEDERS[] = "numSeeders";
const char KEY_NUM_STOPPED[] = "numStopped";
const char KEY_NUM_STOPPED_TOTAL[] = "numStoppedTotal";
const char KEY_NUM_WAITING[] = "numWaiting";
const char KEY_PARAMS[] = "params";
const char KEY_PATH[] = "path";
const char KEY_PEER_CHOKING[] = "peerChoking";
const char KEY_PEER_ID[] = "peerId";
const char KEY_PIECE_LENGTH[] = "pieceLength";
const char KEY_PORT[] = "port";
const char KEY_SEEDER[] = "seeder";
const char KEY_SELECTED[] = "selected";
const char KEY_SERVERS[] = "servers";
const char KEY_SESSION_ID[] = "sessionId";
const char KEY_STATUS[] = "status";
const char KEY_TOTAL_LENGTH[] = "totalLength";
const char KEY_UPLOAD_LENGTH[] = "uploadLength";
const char KEY_UPLOAD_SPEED[] = "uploadSpeed";
const char KEY_URIS[] = "uris";
const char KEY_URI[] = "uri";
const char KEY_VERIFIED_LENGTH[] = "verifiedLength";
const char KEY_VERIFY_PENDING[] = "verifyIntegrityPending";
const char KEY_VERSION[] = "version";
} // namespace
namespace {
@ -1410,6 +1414,72 @@ std::unique_ptr<ValueBase> SaveSessionRpcMethod::process(const RpcRequest& req,
fmt("Failed to serialize session to '%s'.", filename.c_str()));
}
std::unique_ptr<ValueBase>
GetDiskspaceInformationRpcMethod::process(const RpcRequest& req,
DownloadEngine* e)
{
auto result = Dict::g();
const List* gidsParam = checkParam<List>(req, 0);
std::map<std::string, uintmax_t> known;
std::error_code ec;
if (gidsParam) {
for (auto& elem : *gidsParam) {
const String* sgid = downcast<String>(elem);
if (sgid) {
a2_gid_t gid = str2Gid(sgid);
auto group = e->getRequestGroupMan()->findGroup(gid);
if (!group) {
throw DL_ABORT_EX(
fmt("Diskspace information requested for Invalid GID#%s",
GroupId::toHex(gid).c_str()));
}
auto dctx = group->getDownloadContext();
if (!dctx) {
throw DL_ABORT_EX(
fmt("Diskspace information requested for broken GID#%s",
GroupId::toHex(gid).c_str()));
}
auto path = dctx->getBasePath();
if (path.empty()) {
auto option = group->getOption();
if (!option->blank(PREF_OUT)) {
path = util::applyDir(option->get(PREF_DIR), option->get(PREF_OUT));
}
else {
path = option->get(PREF_DIR);
}
}
auto ds = util::filesystem::space_downwards(path.c_str(), ec);
if (ec) {
throw DL_ABORT_EX(
fmt("Diskspace information returned failure for GID#%s",
GroupId::toHex(gid).c_str()));
}
auto sizes = Dict::g();
sizes->put(KEY_DISKSPACE_PATH, String::g(path));
sizes->put(KEY_DISKSPACE_AVAILABLE, Integer::g(ds.available));
sizes->put(KEY_DISKSPACE_CAPACITY, Integer::g(ds.capacity));
sizes->put(KEY_DISKSPACE_FREE, Integer::g(ds.free));
result->put(sgid->s(), std::move(sizes));
}
}
}
else {
auto ds = util::filesystem::space_downwards(nullptr, ec);
if (ec) {
throw DL_ABORT_EX("Diskspace information returned failure");
}
auto sizes = Dict::g();
sizes->put(KEY_DISKSPACE_PATH, String::g("."));
sizes->put(KEY_DISKSPACE_AVAILABLE, Integer::g(ds.available));
sizes->put(KEY_DISKSPACE_CAPACITY, Integer::g(ds.capacity));
sizes->put(KEY_DISKSPACE_FREE, Integer::g(ds.free));
result->put("aria2", std::move(sizes));
}
return std::move(result);
}
std::unique_ptr<ValueBase>
SystemMulticallRpcMethod::process(const RpcRequest& req, DownloadEngine* e)
{

9
src/RpcMethodImpl.h
View File

@ -516,6 +516,15 @@ public:
static const char* getMethodName() { return "aria2.saveSession"; }
};
class GetDiskspaceInformationRpcMethod : public RpcMethod {
protected:
virtual std::unique_ptr<ValueBase> process(const RpcRequest& req,
DownloadEngine* e) CXX11_OVERRIDE;
public:
static const char* getMethodName() { return "aria2.getDiskspaceInformation"; }
};
class SystemMulticallRpcMethod : public RpcMethod {
protected:
virtual std::unique_ptr<ValueBase> process(const RpcRequest& req,

19
src/util.h
View File

@ -53,6 +53,7 @@
#include <algorithm>
#include <vector>
#include <memory>
#include <system_error>
#include "a2time.h"
#include "a2netcompat.h"
@ -879,6 +880,24 @@ void make_fd_cloexec(int fd);
bool gainPrivilege(LPCTSTR privName);
#endif // __MINGW32__
// Basically std::experimental::filesystem, to be replaced later when the
// filesystem stdlib becomes stable and gains wide compiler support
namespace filesystem {
struct space_info {
uintmax_t capacity;
uintmax_t free;
uintmax_t available;
};
space_info space(const char* path, std::error_code& code);
// Progress downwards in the provided path, yielding a result for the first
// directory that exists.
space_info space_downwards(const char* path, std::error_code& code);
} // namespace filesystem
} // namespace util
} // namespace aria2

119
src/util_fs.cc Normal file
View File

@ -0,0 +1,119 @@
/* <!-- copyright */
/*
* aria2 - The high speed download utility
*
* Copyright (C) 2016 Tatsuhiro Tsujikawa
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* In addition, as a special exception, the copyright holders give
* permission to link the code of portions of this program with the
* OpenSSL library under certain conditions as described in each
* individual source file, and distribute linked combinations
* including the two.
* You must obey the GNU General Public License in all respects
* for all of the code used other than OpenSSL. If you modify
* file(s) with this exception, you may extend this exception to your
* version of the file(s), but you are not obligated to do so. If you
* do not wish to do so, delete this exception statement from your
* version. If you delete this exception statement from all source
* files in the program, then also delete it here.
*/
/* copyright --> */
#include "a2io.h"
#include "util.h"
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#else // _WIN32
#include <sys/statvfs.h>
#endif
namespace aria2 {
namespace util {
namespace filesystem {
space_info space(const char* path, std::error_code& ec)
{
space_info rv{static_cast<uintmax_t>(-1), static_cast<uintmax_t>(-1),
static_cast<uintmax_t>(-1)};
if (!path || !*path) {
path = ".";
}
#ifdef _WIN32
ULARGE_INTEGER sp_avail, sp_free, sp_cap;
auto wpath = utf8ToWChar(path);
if (GetDiskFreeSpaceExW(wpath.c_str(), &sp_avail, &sp_cap, &sp_free)) {
rv.capacity = static_cast<uintmax_t>(sp_cap.QuadPart);
rv.available = static_cast<uintmax_t>(sp_avail.QuadPart);
rv.free = static_cast<uintmax_t>(sp_free.QuadPart);
ec.clear();
}
else {
ec.assign(GetLastError(), std::system_category());
}
#else // _WIN32
struct statvfs st;
if (!statvfs(path, &st)) {
rv.capacity = static_cast<uintmax_t>(st.f_blocks) * st.f_frsize;
rv.free = static_cast<uintmax_t>(st.f_bfree) * st.f_frsize;
rv.available = static_cast<uintmax_t>(st.f_bavail) * st.f_frsize;
ec.clear();
}
else {
ec.assign(errno, std::system_category());
}
#endif // _WIN32
return rv;
}
space_info space_downwards(const char* path, std::error_code& ec)
{
auto rv = space(path, ec);
if (!ec) {
return rv;
}
std::string spath(path);
for (;;) {
if (spath.empty()) {
break;
}
#if _WIN32
if (spath == "\\\\") {
// raw UNC prefix
break;
}
#endif
auto pos = spath.find_last_of("/\\");
if (pos == std::string::npos) {
spath = "";
}
else {
spath = spath.substr(0, pos);
}
rv = space(spath.c_str(), ec);
if (!ec) {
break;
}
}
return rv;
}
} // namespace filesystem
} // namespace util
} // namespace aria2

1
test/Makefile.am
View File

@ -17,6 +17,7 @@ aria2c_SOURCES = AllTest.cc\
RequestGroupTest.cc\
UtilTest1.cc\
UtilTest2.cc\
UtilFsTest.cc\
UtilSecurityTest.cc\
UriListParserTest.cc\
HttpHeaderProcessorTest.cc\

116
test/UtilFsTest.cc Normal file
View File

@ -0,0 +1,116 @@
#include "util.h"
#include <fstream>
#include <cppunit/extensions/HelperMacros.h>
#ifdef _WIN32
static char* mkdtemp(char* tpl)
{
char* dn = mktemp(tpl);
if (!dn) {
return dn;
}
if (mkdir(dn)) {
return nullptr;
}
return dn;
}
#endif // _WIN32
namespace aria2 {
class UtilFsTest : public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(UtilFsTest);
CPPUNIT_TEST(testSpace);
CPPUNIT_TEST(testSpacePwd);
CPPUNIT_TEST(testSpaceDownwardsFile);
CPPUNIT_TEST(testSpaceDownwardsDir);
CPPUNIT_TEST_SUITE_END();
private:
public:
void setUp() {}
void testSpace();
void testSpacePwd();
void testSpaceDownwardsFile();
void testSpaceDownwardsDir();
};
CPPUNIT_TEST_SUITE_REGISTRATION(UtilFsTest);
void UtilFsTest::testSpace()
{
const char* tmpl = "aria2.test.tmp.XXXXXX";
char* tpl = strdup(tmpl); // lets just leak this
CPPUNIT_ASSERT(tpl);
char* tmp = mkdtemp(tpl);
CPPUNIT_ASSERT(tmp);
std::error_code ec;
util::filesystem::space(tmp, ec);
CPPUNIT_ASSERT(!ec);
rmdir(tmp);
auto rv = util::filesystem::space(tmp, ec);
CPPUNIT_ASSERT(ec);
CPPUNIT_ASSERT_EQUAL(rv.available, static_cast<uintmax_t>(-1));
CPPUNIT_ASSERT_EQUAL(rv.capacity, static_cast<uintmax_t>(-1));
CPPUNIT_ASSERT_EQUAL(rv.free, static_cast<uintmax_t>(-1));
}
void UtilFsTest::testSpacePwd()
{
std::error_code ec;
util::filesystem::space(nullptr, ec);
CPPUNIT_ASSERT(!ec);
util::filesystem::space("", ec);
CPPUNIT_ASSERT(!ec);
util::filesystem::space(".", ec);
CPPUNIT_ASSERT(!ec);
util::filesystem::space("doesnotexit", ec);
CPPUNIT_ASSERT(ec);
util::filesystem::space_downwards("doesnotexit", ec);
CPPUNIT_ASSERT(!ec);
}
void UtilFsTest::testSpaceDownwardsFile()
{
const char* tmpl = "aria2.test.tmp.XXXXXX";
char* tpl = strdup(tmpl); // lets just leak this
CPPUNIT_ASSERT(tpl);
char* tmp = mkdtemp(tpl);
CPPUNIT_ASSERT(tmp);
std::string tn(tmp);
tn += "/aria2.tmp";
{
std::ofstream s(tn);
std::error_code ec;
std::string tn2(tn);
tn2 += "/something.else.entirely";
util::filesystem::space(tn2.c_str(), ec);
CPPUNIT_ASSERT_MESSAGE(tn2, ec);
util::filesystem::space_downwards(tn2.c_str(), ec);
CPPUNIT_ASSERT_MESSAGE(tn2, !ec);
}
unlink(tn.c_str());
rmdir(tmp);
}
void UtilFsTest::testSpaceDownwardsDir()
{
const char* tmpl = "aria2.test.tmp.XXXXXX";
char* tpl = strdup(tmpl); // lets just leak this
CPPUNIT_ASSERT(tpl);
char* tmp = mkdtemp(tpl);
CPPUNIT_ASSERT(tmp);
std::string tn(tmp);
tn += "/something.else.entirely";
std::error_code ec;
auto rv = util::filesystem::space(tn.c_str(), ec);
CPPUNIT_ASSERT_MESSAGE(tn, ec);
rv = util::filesystem::space_downwards(tn.c_str(), ec);
rmdir(tmp);
CPPUNIT_ASSERT_MESSAGE(tn, !ec);
}
} // namespace aria2