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

refactor: use std::string in tr_variantToStr() (#2351) 

* refactor: use std::string in tr_variantToStr()
This commit is contained in:
Charles Kerr 2021-12-27 16:47:25 -06:00 committed by GitHub
parent 0b095dc258
commit fa35b8ad39
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 114 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
daemon/daemon.cc
View File

@ -857,9 +857,8 @@ static bool init_daemon_data(int argc, char* argv[], struct daemon_data* data, b
if (dumpSettings)
{
char* str = tr_variantToStr(&data->settings, TR_VARIANT_FMT_JSON, nullptr);
fprintf(stderr, "%s", str);
tr_free(str);
auto const str = tr_variantToStr(&data->settings, TR_VARIANT_FMT_JSON);
fprintf(stderr, "%s", str.c_str());
goto EXIT_EARLY;
}

8
gtk/Application.cc
View File

@ -450,11 +450,9 @@ bool Application::Impl::on_rpc_changed_idle(tr_rpc_callback_type type, int torre
}
else
{
char* a = tr_variantToStr(oldval, TR_VARIANT_FMT_BENC, nullptr);
char* b = tr_variantToStr(newval, TR_VARIANT_FMT_BENC, nullptr);
changed = g_strcmp0(a, b) != 0;
tr_free(b);
tr_free(a);
auto const a = tr_variantToStr(oldval, TR_VARIANT_FMT_BENC);
auto const b = tr_variantToStr(newval, TR_VARIANT_FMT_BENC);
changed = a != b;
}
if (changed)

7
libtransmission/announce-list.cc
View File

@ -250,10 +250,7 @@ bool tr_announce_list::save(std::string_view torrent_file, tr_error** error) con
}
// save it
auto contents_len = size_t{};
auto* const contents = tr_variantToStr(&metainfo, TR_VARIANT_FMT_BENC, &contents_len);
auto const contents = tr_variantToStr(&metainfo, TR_VARIANT_FMT_BENC);
tr_variantFree(&metainfo);
auto const success = tr_saveFile(torrent_file, { contents, contents_len }, error);
tr_free(contents);
return success;
return tr_saveFile(torrent_file, contents, error);
}

38
libtransmission/announcer-http.cc
View File

@ -41,7 +41,7 @@ static char const* get_event_string(tr_announce_request const* req)
return req->partial_seed && (req->event != TR_ANNOUNCE_EVENT_STOPPED) ? "paused" : tr_announce_event_get_string(req->event);
}
static char* announce_url_new(tr_session const* session, tr_announce_request const* req)
static std::string announce_url_new(tr_session const* session, tr_announce_request const* req)
{
auto const announce_sv = req->announce_url.sv();
@ -115,7 +115,7 @@ static char* announce_url_new(tr_session const* session, tr_announce_request con
tr_http_escape(buf, ipv6_readable, true);
}
return evbuffer_free_to_str(buf, nullptr);
return evbuffer_free_to_str(buf);
}
static tr_pex* listToPex(tr_variant* peerList, size_t* setme_len)
@ -227,17 +227,12 @@ static void on_announce_done(
}
else
{
auto len = size_t{};
char* str = tr_variantToStr(&benc, TR_VARIANT_FMT_JSON, &len);
fprintf(stderr, "%s", "Announce response:\n< ");
for (size_t i = 0; i < len; ++i)
for (auto const ch : tr_variantToStr(&benc, TR_VARIANT_FMT_JSON))
{
fputc(str[i], stderr);
fputc(ch, stderr);
}
fputc('\n', stderr);
tr_free(str);
}
}
@ -329,10 +324,9 @@ void tr_tracker_http_announce(
d->response.info_hash = request->info_hash;
tr_strlcpy(d->log_name, request->log_name, sizeof(d->log_name));
char* const url = announce_url_new(session, request);
dbgmsg(request->log_name, "Sending announce to libcurl: \"%s\"", url);
auto const url = announce_url_new(session, request);
dbgmsg(request->log_name, "Sending announce to libcurl: \"%" TR_PRIsv "\"", TR_PRIsv_ARG(url));
tr_webRun(session, url, on_announce_done, d);
tr_free(url);
}
/****
@ -400,17 +394,12 @@ static void on_scrape_done(
}
else
{
auto len = size_t{};
char* str = tr_variantToStr(&top, TR_VARIANT_FMT_JSON, &len);
fprintf(stderr, "%s", "Scrape response:\n< ");
for (size_t i = 0; i < len; ++i)
for (auto const ch : tr_variantToStr(&top, TR_VARIANT_FMT_JSON))
{
fputc(str[i], stderr);
fputc(ch, stderr);
}
fputc('\n', stderr);
tr_free(str);
}
}
@ -481,7 +470,7 @@ static void on_scrape_done(
tr_runInEventThread(session, on_scrape_done_eventthread, data);
}
static char* scrape_url_new(tr_scrape_request const* req)
static std::string scrape_url_new(tr_scrape_request const* req)
{
auto const sv = req->scrape_url.sv();
@ -497,7 +486,7 @@ static char* scrape_url_new(tr_scrape_request const* req)
delimiter = '&';
}
return evbuffer_free_to_str(buf, nullptr);
return evbuffer_free_to_str(buf);
}
void tr_tracker_http_scrape(
@ -506,8 +495,6 @@ void tr_tracker_http_scrape(
tr_scrape_response_func response_func,
void* response_func_user_data)
{
char* url = scrape_url_new(request);
auto* d = new scrape_data{};
d->response.scrape_url = request->scrape_url;
d->response_func = response_func;
@ -524,8 +511,7 @@ void tr_tracker_http_scrape(
tr_strlcpy(d->log_name, request->log_name, sizeof(d->log_name));
dbgmsg(request->log_name, "Sending scrape to libcurl: \"%s\"", url);
auto const url = scrape_url_new(request);
dbgmsg(request->log_name, "Sending scrape to libcurl: \"%" TR_PRIsv "\"", TR_PRIsv_ARG(url));
tr_webRun(session, url, on_scrape_done, d);
tr_free(url);
}

5
libtransmission/announcer.cc
View File

@ -649,9 +649,8 @@ static void dbgmsg_tier_announce_queue(tr_tier const* tier)
evbuffer_add_printf(buf, "[%d:%s]", i, str);
}
char* const message = evbuffer_free_to_str(buf, nullptr);
tr_logAddDeep(__FILE__, __LINE__, name, "announce queue is %s", message);
tr_free(message);
auto const message = evbuffer_free_to_str(buf);
tr_logAddDeep(__FILE__, __LINE__, name, "announce queue is %" TR_PRIsv, TR_PRIsv_ARG(message));
}
}

5
libtransmission/file.cc
View File

@ -81,12 +81,11 @@ bool tr_sys_file_read_line(tr_sys_file_t handle, char* buffer, size_t buffer_siz
return ret;
}
bool tr_sys_file_write_line(tr_sys_file_t handle, char const* buffer, tr_error** error)
bool tr_sys_file_write_line(tr_sys_file_t handle, std::string_view buffer, tr_error** error)
{
TR_ASSERT(handle != TR_BAD_SYS_FILE);
TR_ASSERT(buffer != nullptr);
bool ret = tr_sys_file_write(handle, buffer, strlen(buffer), nullptr, error);
bool ret = tr_sys_file_write(handle, std::data(buffer), std::size(buffer), nullptr, error);
if (ret)
{

4
libtransmission/file.h
View File

@ -578,13 +578,13 @@ bool tr_sys_file_read_line(tr_sys_file_t handle, char* buffer, size_t buffer_siz
* should already be in UTF-8 encoding, or whichever else you expect.
*
* @param[in] handle Valid file descriptor.
* @param[in] buffer Zero-terminated string to write.
* @param[in] buffer String to write.
* @param[out] error Pointer to error object. Optional, pass `nullptr` if you
* are not interested in error details.
*
* @return `True` on success, `false` otherwise (with `error` set accordingly).
*/
bool tr_sys_file_write_line(tr_sys_file_t handle, char const* buffer, struct tr_error** error);
bool tr_sys_file_write_line(tr_sys_file_t handle, std::string_view buffer, struct tr_error** error);
/**
* @brief Portability wrapper for `fprintf()`.

8
libtransmission/log.cc
View File

@ -174,19 +174,17 @@ void tr_logAddDeep(char const* file, int line, char const* name, char const* fmt
va_end(args);
evbuffer_add_printf(buf, " (%s:%d)" TR_NATIVE_EOL_STR, base, line);
size_t message_len = 0;
char* const message = evbuffer_free_to_str(buf, &message_len);
auto const message = evbuffer_free_to_str(buf);
#ifdef _WIN32
OutputDebugStringA(message);
OutputDebugStringA(message.c_str());
#endif
if (fp != TR_BAD_SYS_FILE)
{
tr_sys_file_write(fp, message, message_len, nullptr, nullptr);
tr_sys_file_write(fp, std::data(message), std::size(message), nullptr, nullptr);
}
tr_free(message);
tr_free(base);
}
}

9
libtransmission/metainfo.cc
View File

@ -387,11 +387,8 @@ static char const* tr_metainfoParseImpl(
}
else
{
size_t blen = 0;
char* bstr = tr_variantToStr(infoDict, TR_VARIANT_FMT_BENC, &blen);
auto const hash = tr_sha1(std::string_view{ bstr, blen });
tr_free(bstr);
auto const benc = tr_variantToStr(infoDict, TR_VARIANT_FMT_BENC);
auto const hash = tr_sha1(benc);
if (!hash)
{
return "hash";
@ -402,7 +399,7 @@ static char const* tr_metainfoParseImpl(
if (infoDictLength != nullptr)
{
*infoDictLength = blen;
*infoDictLength = std::size(benc);
}
}

3
libtransmission/peer-msgs.cc
View File

@ -682,11 +682,10 @@ static void myDebug(char const* file, int line, tr_peerMsgsImpl const* msgs, cha
va_end(args);
evbuffer_add_printf(buf, " (%s:%d)", base, line);
char* const message = evbuffer_free_to_str(buf, nullptr);
auto const message = evbuffer_free_to_str(buf);
tr_sys_file_write_line(fp, message, nullptr);
tr_free(base);
tr_free(message);
}
}

71
libtransmission/torrent-magnet.cc
View File

@ -28,6 +28,8 @@
#include "variant.h"
#include "web-utils.h"
using namespace std::literals;
#define dbgmsg(tor, ...) tr_logAddDeepNamed(tr_torrentName(tor), __VA_ARGS__)
/***
@ -113,33 +115,34 @@ bool tr_torrentSetMetadataSizeHint(tr_torrent* tor, int64_t size)
static size_t findInfoDictOffset(tr_torrent const* tor)
{
size_t offset = 0;
/* load the file, and find the info dict's offset inside the file */
auto fileLen = size_t{};
uint8_t* const fileContents = tr_loadFile(tor->torrentFile(), &fileLen, nullptr);
if (fileContents != nullptr)
// load the torrent's .torrent file
auto benc = std::vector<char>{};
if (!tr_loadFile(benc, tor->torrentFile()) || std::empty(benc))
{
auto top = tr_variant{};
auto const contents_sv = std::string_view{ reinterpret_cast<char const*>(fileContents), fileLen };
if (tr_variantFromBuf(&top, TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE, contents_sv))
{
tr_variant* infoDict = nullptr;
if (tr_variantDictFindDict(&top, TR_KEY_info, &infoDict))
{
auto infoLen = size_t{};
char* infoContents = tr_variantToStr(infoDict, TR_VARIANT_FMT_BENC, &infoLen);
uint8_t const* i = (uint8_t const*)tr_memmem((char*)fileContents, fileLen, infoContents, infoLen);
offset = i != nullptr ? i - fileContents : 0;
tr_free(infoContents);
}
tr_variantFree(&top);
}
tr_free(fileContents);
return {};
}
// parse the benc
auto top = tr_variant{};
auto const benc_sv = std::string_view{ std::data(benc), std::size(benc) };
if (!tr_variantFromBuf(&top, TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE, benc_sv))
{
return {};
}
auto offset = size_t{};
tr_variant* info_dict = nullptr;
if (tr_variantDictFindDict(&top, TR_KEY_info, &info_dict))
{
auto const info_dict_benc = tr_variantToStr(info_dict, TR_VARIANT_FMT_BENC);
auto const it = std::search(std::begin(benc), std::end(benc), std::begin(info_dict_benc), std::end(info_dict_benc));
if (it != std::end(benc))
{
offset = std::distance(std::begin(benc), it);
}
}
tr_variantFree(&top);
return offset;
}
@ -388,31 +391,31 @@ double tr_torrentGetMetadataPercent(tr_torrent const* tor)
/* TODO: this should be renamed tr_metainfoGetMagnetLink() and moved to metainfo.c for consistency */
char* tr_torrentInfoGetMagnetLink(tr_info const* inf)
{
evbuffer* const s = evbuffer_new();
auto buf = std::string{};
evbuffer_add_printf(s, "magnet:?xt=urn:btih:%s", inf->hashString);
buf += "magnet:?xt=urn:btih:"sv;
buf += inf->hashString;
char const* const name = inf->name;
if (!tr_str_is_empty(name))
{
evbuffer_add_printf(s, "%s", "&dn=");
tr_http_escape(s, name, true);
buf += "&dn="sv;
tr_http_escape(buf, name, true);
}
for (size_t i = 0, n = std::size(*inf->announce_list); i < n; ++i)
{
evbuffer_add_printf(s, "%s", "&tr=");
tr_http_escape(s, inf->announce_list->at(i).announce.full, true);
buf += "&tr="sv;
tr_http_escape(buf, inf->announce_list->at(i).announce.full, true);
}
for (unsigned int i = 0; i < inf->webseedCount; i++)
{
evbuffer_add_printf(s, "%s", "&ws=");
tr_http_escape(s, inf->webseeds[i], true);
buf += "&ws="sv;
tr_http_escape(buf, inf->webseeds[i], true);
}
return evbuffer_free_to_str(s, nullptr);
return tr_strvDup(buf);
}
char* tr_torrentGetMagnetLink(tr_torrent const* tor)

17
libtransmission/torrent-metainfo.cc
View File

@ -514,12 +514,10 @@ std::string_view tr_torrent_metainfo::parseImpl(tr_torrent_metainfo& setme, tr_v
{
// Calculate the hash of the `info` dict.
// This is the torrent's unique ID and is central to everything.
size_t blen = 0;
char* const bstr = tr_variantToStr(info_dict, TR_VARIANT_FMT_BENC, &blen);
auto const hash = tr_sha1(std::string_view{ bstr, blen });
auto const info_dict_benc = tr_variantToStr(info_dict, TR_VARIANT_FMT_BENC);
auto const hash = tr_sha1(info_dict_benc);
if (!hash)
{
tr_free(bstr);
return "bad info_dict checksum";
}
setme.info_hash_ = *hash;
@ -531,18 +529,15 @@ std::string_view tr_torrent_metainfo::parseImpl(tr_torrent_metainfo& setme, tr_v
//
// Calculating this later from scratch is kind of expensive,
// so do it here since we've already got the bencoded info dict.
auto const it = std::search(std::begin(benc), std::end(benc), bstr, bstr + blen);
auto const it = std::search(std::begin(benc), std::end(benc), std::begin(info_dict_benc), std::end(info_dict_benc));
setme.info_dict_offset_ = std::distance(std::begin(benc), it);
setme.info_dict_size_ = blen;
setme.info_dict_size_ = std::size(info_dict_benc);
// In addition, remember the offset of the pieces dictionary entry.
// This will be useful when we load piece checksums on demand.
auto constexpr Key = "6:pieces"sv;
auto constexpr* BKey = std::data(Key);
auto const pit = std::search(bstr, bstr + blen, BKey, BKey + std::size(Key));
setme.pieces_offset_ = setme.info_dict_offset_ + (pit - bstr) + std::size(Key);
tr_free(bstr);
auto const pit = std::search(std::begin(benc), std::end(benc), std::begin(Key), std::end(Key));
setme.pieces_offset_ = std::distance(std::begin(benc), pit) + std::size(Key);
}
else
{

12
libtransmission/utils.cc
View File

@ -467,7 +467,17 @@ tr_disk_space tr_dirSpace(std::string_view dir)
*****
****/
char* evbuffer_free_to_str(struct evbuffer* buf, size_t* result_len)
std::string evbuffer_free_to_str(evbuffer* buf)
{
auto const n = evbuffer_get_length(buf);
auto ret = std::string{};
ret.resize(n);
evbuffer_copyout(buf, std::data(ret), n);
evbuffer_free(buf);
return ret;
}
static char* evbuffer_free_to_str(struct evbuffer* buf, size_t* result_len)
{
size_t const n = evbuffer_get_length(buf);
auto* const ret = tr_new(char, n + 1);

2
libtransmission/utils.h
View File

@ -228,7 +228,7 @@ constexpr bool tr_str_is_empty(char const* value)
return value == nullptr || *value == '\0';
}
char* evbuffer_free_to_str(struct evbuffer* buf, size_t* result_len);
std::string evbuffer_free_to_str(evbuffer* buf);
/**
* @brief sprintf() a string into a newly-allocated buffer large enough to hold it

11
libtransmission/variant.cc
View File

@ -1200,20 +1200,18 @@ struct evbuffer* tr_variantToBuf(tr_variant const* v, tr_variant_fmt fmt)
return buf;
}
char* tr_variantToStr(tr_variant const* v, tr_variant_fmt fmt, size_t* len)
std::string tr_variantToStr(tr_variant const* v, tr_variant_fmt fmt)
{
struct evbuffer* buf = tr_variantToBuf(v, fmt);
return evbuffer_free_to_str(buf, len);
return evbuffer_free_to_str(tr_variantToBuf(v, fmt));
}
int tr_variantToFile(tr_variant const* v, tr_variant_fmt fmt, std::string_view filename)
{
auto error_code = int{ 0 };
auto contents_len = size_t{};
auto* const contents = tr_variantToStr(v, fmt, &contents_len);
auto const contents = tr_variantToStr(v, fmt);
tr_error* error = nullptr;
tr_saveFile(filename, { contents, contents_len }, &error);
tr_saveFile(filename, { std::data(contents), std::size(contents) }, &error);
if (error != nullptr)
{
tr_logAddError(_("Error saving \"%" TR_PRIsv "\": %s (%d)"), TR_PRIsv_ARG(filename), error->message, error->code);
@ -1221,7 +1219,6 @@ int tr_variantToFile(tr_variant const* v, tr_variant_fmt fmt, std::string_view f
tr_error_clear(&error);
}
tr_free(contents);
return error_code;
}

2
libtransmission/variant.h
View File

@ -108,7 +108,7 @@ enum tr_variant_fmt
int tr_variantToFile(tr_variant const* variant, tr_variant_fmt fmt, std::string_view filename);
char* tr_variantToStr(tr_variant const* variant, tr_variant_fmt fmt, size_t* len);
std::string tr_variantToStr(tr_variant const* variant, tr_variant_fmt fmt);
struct evbuffer* tr_variantToBuf(tr_variant const* variant, tr_variant_fmt fmt);

6
qt/RpcClient.cc
View File

@ -144,11 +144,7 @@ void RpcClient::sendNetworkRequest(TrVariantPtr json, QFutureInterface<RpcRespon
request_ = request;
}
size_t raw_json_data_length;
auto* raw_json_data = tr_variantToStr(json.get(), TR_VARIANT_FMT_JSON_LEAN, &raw_json_data_length);
QByteArray json_data(raw_json_data, raw_json_data_length);
tr_free(raw_json_data);
auto const json_data = QByteArray::fromStdString(tr_variantToStr(json.get(), TR_VARIANT_FMT_JSON_LEAN));
QNetworkReply* reply = networkAccessManager()->post(*request_, json_data);
reply->setProperty(RequestDataPropertyKey, QVariant::fromValue(json));
reply->setProperty(RequestFutureinterfacePropertyKey, QVariant::fromValue(promise));

11
tests/libtransmission/json-test.cc
View File

@ -85,7 +85,6 @@ TEST_P(JSONTest, testUtf8)
auto in = "{ \"key\": \"Letöltések\" }"sv;
tr_variant top;
auto sv = std::string_view{};
char* json;
tr_quark const key = tr_quark_new("key"sv);
EXPECT_TRUE(tr_variantFromBuf(&top, TR_VARIANT_PARSE_JSON | TR_VARIANT_PARSE_INPLACE, in));
@ -114,19 +113,17 @@ TEST_P(JSONTest, testUtf8)
EXPECT_TRUE(tr_variantIsDict(&top));
EXPECT_TRUE(tr_variantDictFindStrView(&top, key, &sv));
EXPECT_EQ("Letöltések"sv, sv);
json = tr_variantToStr(&top, TR_VARIANT_FMT_JSON, nullptr);
auto json = tr_variantToStr(&top, TR_VARIANT_FMT_JSON);
tr_variantFree(&top);
EXPECT_NE(nullptr, json);
EXPECT_NE(nullptr, strstr(json, "\\u00f6"));
EXPECT_NE(nullptr, strstr(json, "\\u00e9"));
EXPECT_FALSE(std::empty(json));
EXPECT_NE(std::string::npos, json.find("\\u00f6"));
EXPECT_NE(std::string::npos, json.find("\\u00e9"));
EXPECT_TRUE(tr_variantFromBuf(&top, TR_VARIANT_PARSE_JSON | TR_VARIANT_PARSE_INPLACE, json));
EXPECT_TRUE(tr_variantIsDict(&top));
EXPECT_TRUE(tr_variantDictFindStrView(&top, key, &sv));
EXPECT_EQ("Letöltések"sv, sv);
tr_variantFree(&top);
tr_free(json);
}
TEST_P(JSONTest, test1)

43
tests/libtransmission/variant-test.cc
View File

@ -229,12 +229,7 @@ TEST_F(VariantTest, parse)
EXPECT_EQ(32, i);
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(&val, 2), &i));
EXPECT_EQ(16, i);
auto len = size_t{};
auto* saved = tr_variantToStr(&val, TR_VARIANT_FMT_BENC, &len);
EXPECT_EQ(std::size(benc), len);
EXPECT_EQ(benc, saved);
tr_free(saved);
EXPECT_EQ(benc, tr_variantToStr(&val, TR_VARIANT_FMT_BENC));
tr_variantFree(&val);
end = nullptr;
@ -248,10 +243,7 @@ TEST_F(VariantTest, parse)
EXPECT_TRUE(tr_variantFromBuf(&val, TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE, benc, &end));
EXPECT_EQ(std::data(benc) + std::size(benc), end);
saved = tr_variantToStr(&val, TR_VARIANT_FMT_BENC, &len);
EXPECT_EQ(std::size(benc), len);
EXPECT_EQ(benc, saved);
tr_free(saved);
EXPECT_EQ(benc, tr_variantToStr(&val, TR_VARIANT_FMT_BENC));
tr_variantFree(&val);
}
@ -284,10 +276,7 @@ TEST_F(VariantTest, bencParseAndReencode)
if (is_good)
{
EXPECT_EQ(test.benc.data() + test.benc.size(), end);
auto saved_len = size_t{};
auto* saved = tr_variantToStr(&val, TR_VARIANT_FMT_BENC, &saved_len);
EXPECT_EQ(test.benc, std::string(saved, saved_len));
tr_free(saved);
EXPECT_EQ(test.benc, tr_variantToStr(&val, TR_VARIANT_FMT_BENC));
tr_variantFree(&val);
}
}
@ -303,12 +292,7 @@ TEST_F(VariantTest, bencSortWhenSerializing)
auto const ok = tr_variantFromBuf(&val, TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE, In, &end);
EXPECT_TRUE(ok);
EXPECT_EQ(std::data(In) + std::size(In), end);
auto len = size_t{};
auto* saved = tr_variantToStr(&val, TR_VARIANT_FMT_BENC, &len);
auto sv = std::string_view{ saved, len };
EXPECT_EQ(ExpectedOut, sv);
tr_free(saved);
EXPECT_EQ(ExpectedOut, tr_variantToStr(&val, TR_VARIANT_FMT_BENC));
tr_variantFree(&val);
}
@ -323,12 +307,7 @@ TEST_F(VariantTest, bencMalformedTooManyEndings)
auto const ok = tr_variantFromBuf(&val, TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE, In, &end);
EXPECT_TRUE(ok);
EXPECT_EQ(std::data(In) + std::size(ExpectedOut), end);
auto len = size_t{};
auto* saved = tr_variantToStr(&val, TR_VARIANT_FMT_BENC, &len);
auto sv = std::string_view{ saved, len };
EXPECT_EQ(ExpectedOut, sv);
tr_free(saved);
EXPECT_EQ(ExpectedOut, tr_variantToStr(&val, TR_VARIANT_FMT_BENC));
tr_variantFree(&val);
}
@ -369,10 +348,8 @@ TEST_F(VariantTest, bencToJson)
tr_variant top;
tr_variantFromBuf(&top, TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE, test.benc);
auto len = size_t{};
auto* str = tr_variantToStr(&top, TR_VARIANT_FMT_JSON_LEAN, &len);
EXPECT_EQ(test.expected, stripWhitespace(std::string(str, len)));
tr_free(str);
auto const str = tr_variantToStr(&top, TR_VARIANT_FMT_JSON_LEAN);
EXPECT_EQ(test.expected, stripWhitespace(str));
tr_variantFree(&top);
}
}
@ -447,11 +424,7 @@ TEST_F(VariantTest, stackSmash)
EXPECT_EQ(in.data() + in.size(), end);
// confirm that we can serialize it back again
size_t len;
auto* saved = tr_variantToStr(&val, TR_VARIANT_FMT_BENC, &len);
EXPECT_NE(nullptr, saved);
EXPECT_EQ(in, std::string(saved, len));
tr_free(saved);
EXPECT_EQ(in, tr_variantToStr(&val, TR_VARIANT_FMT_BENC));
tr_variantFree(&val);
}

20
utils/remote.cc
View File

@ -816,9 +816,9 @@ static size_t parseResponseHeader(void* ptr, size_t size, size_t nmemb, void* /*
return line_len;
}
static long getTimeoutSecs(char const* req)
static long getTimeoutSecs(std::string_view req)
{
if (strstr(req, "\"method\":\"blocklist-update\"") != nullptr)
if (req.find("\"method\":\"blocklist-update\""sv) != std::string_view::npos)
{
return 300L;
}
@ -2193,24 +2193,23 @@ static void tr_curl_easy_cleanup(CURL* curl)
static int flush(char const* rpcurl, tr_variant** benc)
{
CURLcode res;
CURL* curl;
int status = EXIT_SUCCESS;
struct evbuffer* buf = evbuffer_new();
char* json = tr_variantToStr(*benc, TR_VARIANT_FMT_JSON_LEAN, nullptr);
auto const json = tr_variantToStr(*benc, TR_VARIANT_FMT_JSON_LEAN);
auto const rpcurl_http = tr_strvJoin(UseSSL ? "https://" : "http://", rpcurl);
curl = tr_curl_easy_init(buf);
auto* const buf = evbuffer_new();
auto* curl = tr_curl_easy_init(buf);
curl_easy_setopt(curl, CURLOPT_URL, rpcurl_http.c_str());
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json.c_str());
curl_easy_setopt(curl, CURLOPT_TIMEOUT, getTimeoutSecs(json));
if (debug)
{
fprintf(stderr, "posting:\n--------\n%s\n--------\n", json);
fprintf(stderr, "posting:\n--------\n%s\n--------\n", json.c_str());
}
if ((res = curl_easy_perform(curl)) != CURLE_OK)
auto const res = curl_easy_perform(curl);
if (res != CURLE_OK)
{
tr_logAddNamedError(MyName, " (%s) %s", rpcurl_http.c_str(), curl_easy_strerror(res));
status |= EXIT_FAILURE;
@ -2247,7 +2246,6 @@ static int flush(char const* rpcurl, tr_variant** benc)
}
/* cleanup */
tr_free(json);
evbuffer_free(buf);
if (curl != nullptr)