From fa35b8ad39043e939ec727a771ea6b204caad58d Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 27 Dec 2021 16:47:25 -0600 Subject: [PATCH] refactor: use std::string in tr_variantToStr() (#2351) * refactor: use std::string in tr_variantToStr() --- daemon/daemon.cc | 5 +- gtk/Application.cc | 8 ++- libtransmission/announce-list.cc | 7 +-- libtransmission/announcer-http.cc | 38 +++++--------- libtransmission/announcer.cc | 5 +- libtransmission/file.cc | 5 +- libtransmission/file.h | 4 +- libtransmission/log.cc | 8 ++- libtransmission/metainfo.cc | 9 ++-- libtransmission/peer-msgs.cc | 3 +- libtransmission/torrent-magnet.cc | 71 ++++++++++++++------------- libtransmission/torrent-metainfo.cc | 17 +++---- libtransmission/utils.cc | 12 ++++- libtransmission/utils.h | 2 +- libtransmission/variant.cc | 11 ++--- libtransmission/variant.h | 2 +- qt/RpcClient.cc | 6 +-- tests/libtransmission/json-test.cc | 11 ++--- tests/libtransmission/variant-test.cc | 43 +++------------- utils/remote.cc | 20 ++++---- 20 files changed, 114 insertions(+), 173 deletions(-) diff --git a/daemon/daemon.cc b/daemon/daemon.cc index 9c67b28a7..fccc69682 100644 --- a/daemon/daemon.cc +++ b/daemon/daemon.cc @@ -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; } diff --git a/gtk/Application.cc b/gtk/Application.cc index 33ab405be..79c72a7f6 100644 --- a/gtk/Application.cc +++ b/gtk/Application.cc @@ -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) diff --git a/libtransmission/announce-list.cc b/libtransmission/announce-list.cc index 92272b2f9..a51a82e86 100644 --- a/libtransmission/announce-list.cc +++ b/libtransmission/announce-list.cc @@ -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); } diff --git a/libtransmission/announcer-http.cc b/libtransmission/announcer-http.cc index 4fbdedf17..648933be3 100644 --- a/libtransmission/announcer-http.cc +++ b/libtransmission/announcer-http.cc @@ -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); } diff --git a/libtransmission/announcer.cc b/libtransmission/announcer.cc index 27ca58a4d..fd19654a7 100644 --- a/libtransmission/announcer.cc +++ b/libtransmission/announcer.cc @@ -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)); } } diff --git a/libtransmission/file.cc b/libtransmission/file.cc index 9eb578bb1..16406141b 100644 --- a/libtransmission/file.cc +++ b/libtransmission/file.cc @@ -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) { diff --git a/libtransmission/file.h b/libtransmission/file.h index 00cf40ba7..0e1d5876a 100644 --- a/libtransmission/file.h +++ b/libtransmission/file.h @@ -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()`. diff --git a/libtransmission/log.cc b/libtransmission/log.cc index b48db817d..9a958e2a8 100644 --- a/libtransmission/log.cc +++ b/libtransmission/log.cc @@ -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); } } diff --git a/libtransmission/metainfo.cc b/libtransmission/metainfo.cc index 0b04f6f84..a80a43a29 100644 --- a/libtransmission/metainfo.cc +++ b/libtransmission/metainfo.cc @@ -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); } } diff --git a/libtransmission/peer-msgs.cc b/libtransmission/peer-msgs.cc index 3e996f84a..498d3a5cd 100644 --- a/libtransmission/peer-msgs.cc +++ b/libtransmission/peer-msgs.cc @@ -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); } } diff --git a/libtransmission/torrent-magnet.cc b/libtransmission/torrent-magnet.cc index 72e07a111..858a66e0a 100644 --- a/libtransmission/torrent-magnet.cc +++ b/libtransmission/torrent-magnet.cc @@ -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{}; + if (!tr_loadFile(benc, tor->torrentFile()) || std::empty(benc)) { - auto top = tr_variant{}; - auto const contents_sv = std::string_view{ reinterpret_cast(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) diff --git a/libtransmission/torrent-metainfo.cc b/libtransmission/torrent-metainfo.cc index c51b22def..aefdd94fa 100644 --- a/libtransmission/torrent-metainfo.cc +++ b/libtransmission/torrent-metainfo.cc @@ -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 { diff --git a/libtransmission/utils.cc b/libtransmission/utils.cc index f8976ef52..9ae738d91 100644 --- a/libtransmission/utils.cc +++ b/libtransmission/utils.cc @@ -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); diff --git a/libtransmission/utils.h b/libtransmission/utils.h index 470e793cc..ef6eacb81 100644 --- a/libtransmission/utils.h +++ b/libtransmission/utils.h @@ -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 diff --git a/libtransmission/variant.cc b/libtransmission/variant.cc index 3af40862e..c30cd68da 100644 --- a/libtransmission/variant.cc +++ b/libtransmission/variant.cc @@ -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; } diff --git a/libtransmission/variant.h b/libtransmission/variant.h index 0fa2d4857..d615e4ba0 100644 --- a/libtransmission/variant.h +++ b/libtransmission/variant.h @@ -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); diff --git a/qt/RpcClient.cc b/qt/RpcClient.cc index bc71babfe..7a6796453 100644 --- a/qt/RpcClient.cc +++ b/qt/RpcClient.cc @@ -144,11 +144,7 @@ void RpcClient::sendNetworkRequest(TrVariantPtr json, QFutureInterfacepost(*request_, json_data); reply->setProperty(RequestDataPropertyKey, QVariant::fromValue(json)); reply->setProperty(RequestFutureinterfacePropertyKey, QVariant::fromValue(promise)); diff --git a/tests/libtransmission/json-test.cc b/tests/libtransmission/json-test.cc index a6f7cbcd6..ce8133481 100644 --- a/tests/libtransmission/json-test.cc +++ b/tests/libtransmission/json-test.cc @@ -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) diff --git a/tests/libtransmission/variant-test.cc b/tests/libtransmission/variant-test.cc index 0fdf4ae4d..dfbb3da3b 100644 --- a/tests/libtransmission/variant-test.cc +++ b/tests/libtransmission/variant-test.cc @@ -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); } diff --git a/utils/remote.cc b/utils/remote.cc index 87d26642a..e90353d55 100644 --- a/utils/remote.cc +++ b/utils/remote.cc @@ -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)