C++ modernize: Replace MIN/MAX with type safe std::min/std::max (#1806)

* C++ modernize: Replace MIN/MAX with type safe std::min/std::max

* Template std::min/max invocations now explicitly use largest integer type

* torrent.cc did not have <algorithm> included

* MIN/MAX Changes for subprocess-win32.cc

* Using type{} style cast instead of template parameter in std::min/max

* 32-bit type cast errors with uint64_t versus size_t

* 32-bit type cast errors inout.cc and file.cc

* Missing include in windows code; Type cast error fixed

* Missing macro in win32 daemon; Replaced MIN in commented code with std::min

* Update libtransmission/tr-getopt.cc

Co-authored-by: Mike Gelfand <mikedld@users.noreply.github.com>

* Update libtransmission/file-posix.cc

Co-authored-by: Mike Gelfand <mikedld@users.noreply.github.com>

* Update tests/libtransmission/copy-test.cc

Co-authored-by: Mike Gelfand <mikedld@users.noreply.github.com>

* Update libtransmission/peer-mgr.cc

Co-authored-by: Mike Gelfand <mikedld@users.noreply.github.com>

* Strlen returns size_t, remove cast

Co-authored-by: Charles Kerr <charles@charleskerr.com>
Co-authored-by: Mike Gelfand <mikedld@users.noreply.github.com>

daemon/daemon-win32.c

@@ -108,6 +108,8 @@ static void update_service_status(
     }
 }
 
+#define TR_MAX(a, b) (((a) > (b)) ? (a) : (b))
+
 static unsigned int __stdcall service_stop_thread_main(void* param)
 {
     callbacks->on_stop(callback_arg);
@@ -118,7 +120,7 @@ static unsigned int __stdcall service_stop_thread_main(void* param)
     for (DWORD checkpoint = 2; WaitForSingleObject(service_thread, sleep_time) == WAIT_TIMEOUT; ++checkpoint)
     {
         wait_time = wait_time >= sleep_time ? wait_time - sleep_time : 0;
-        update_service_status(SERVICE_STOP_PENDING, NO_ERROR, 0, checkpoint, MAX(wait_time, sleep_time * 2));
+        update_service_status(SERVICE_STOP_PENDING, NO_ERROR, 0, checkpoint, TR_MAX(wait_time, sleep_time * 2));
     }
 
     return 0;

libtransmission/announcer.cc

@@ -6,11 +6,11 @@
  *
  */
 
-#include <algorithm> // std::partial_sort
+#include <algorithm>
-#include <limits.h> /* INT_MAX */
+#include <climits> /* INT_MAX */
-#include <stdio.h>
+#include <cstdio>
-#include <stdlib.h> /* qsort() */
+#include <cstdlib> /* qsort() */
-#include <string.h> /* strcmp(), memcpy(), strncmp() */
+#include <cstring> /* strcmp(), memcpy(), strncmp() */
 #include <vector>
 
 #include <event2/buffer.h>
@@ -797,7 +797,7 @@ time_t tr_announcerNextManualAnnounce(tr_torrent const* tor)
     {
         if (tt->tiers[i].isRunning)
         {
-            ret = MIN(ret, tt->tiers[i].manualAnnounceAllowedAt);
+            ret = std::min(ret, tt->tiers[i].manualAnnounceAllowedAt);
         }
     }
 
@@ -834,7 +834,7 @@ static void tier_update_announce_priority(tr_tier* tier)
 
     for (int i = 0; i < tier->announce_event_count; ++i)
     {
-        priority = MAX(priority, (int)tier->announce_events[i]);
+        priority = std::max(priority, int{ tier->announce_events[i] });
     }
 
     tier->announce_event_priority = priority;
@@ -1475,7 +1475,7 @@ static void on_scrape_done(tr_scrape_response const* response, void* vsession)
                 else
                 {
                     tier->lastScrapeSucceeded = true;
-                    tier->scrapeIntervalSec = MAX(DEFAULT_SCRAPE_INTERVAL_SEC, response->min_request_interval);
+                    tier->scrapeIntervalSec = std::max(int{ DEFAULT_SCRAPE_INTERVAL_SEC }, response->min_request_interval);
                     tier->scrapeAt = get_next_scrape_time(session, tier, tier->scrapeIntervalSec);
                     tr_logAddTorDbg(tier->tor, "Scrape successful. Rescraping in %d seconds.", tier->scrapeIntervalSec);
 
@@ -1524,7 +1524,7 @@ static void on_scrape_done(tr_scrape_response const* response, void* vsession)
                error out, lower the value once for that batch, not N times. */
             if (*multiscrape_max >= response->row_count)
             {
-                int const n = MAX(1, *multiscrape_max - TR_MULTISCRAPE_STEP);
+                int const n = std::max(1, int{ *multiscrape_max - TR_MULTISCRAPE_STEP });
                 if (*multiscrape_max != n)
                 {
                     char* scheme = nullptr;

libtransmission/bandwidth.cc

@@ -6,7 +6,8 @@
  *
  */
 
-#include <string.h> /* memset() */
+#include <algorithm>
+#include <cstring> /* memset() */
 
 #include "transmission.h"
 #include "bandwidth.h"
@@ -159,7 +160,7 @@ static void allocateBandwidth(
     TR_ASSERT(tr_isBandwidth(b));
     TR_ASSERT(tr_isDirection(dir));
 
-    tr_priority_t const priority = MAX(parent_priority, b->priority);
+    tr_priority_t const priority = std::max(parent_priority, b->priority);
 
     /* set the available bandwidth */
     if (b->band[dir].isLimited)
@@ -307,7 +308,7 @@ static unsigned int bandwidthClamp(tr_bandwidth const* b, uint64_t now, tr_direc
     {
         if (b->band[dir].isLimited)
         {
-            byteCount = MIN(byteCount, b->band[dir].bytesLeft);
+            byteCount = std::min(byteCount, b->band[dir].bytesLeft);
 
             /* if we're getting close to exceeding the speed limit,
              * clamp down harder on the bytes available */
@@ -380,7 +381,7 @@ void tr_bandwidthUsed(tr_bandwidth* b, tr_direction dir, size_t byteCount, bool
 
     if (band->isLimited && isPieceData)
     {
-        band->bytesLeft -= MIN(band->bytesLeft, byteCount);
+        band->bytesLeft -= std::min(size_t{ band->bytesLeft }, byteCount);
     }
 
 #ifdef DEBUG_DIRECTION

libtransmission/bitfield.cc

@@ -6,7 +6,8 @@
  *
  */
 
-#include <string.h> /* memset */
+#include <algorithm>
+#include <cstring> /* memset */
 
 #include "transmission.h"
 #include "bitfield.h"
@@ -85,7 +86,7 @@ static size_t countRange(tr_bitfield const* b, size_t begin, size_t end)
     else
     {
         uint8_t val;
-        size_t const walk_end = MIN(b->alloc_count, last_byte);
+        size_t const walk_end = std::min(b->alloc_count, last_byte);
 
         /* first byte */
         size_t const first_shift = begin - (first_byte * 8);
@@ -220,7 +221,7 @@ static void tr_bitfieldEnsureBitsAlloced(tr_bitfield* b, size_t n)
 
     if (has_all)
     {
-        bytes_needed = get_bytes_needed(MAX(n, b->true_count));
+        bytes_needed = get_bytes_needed(std::max(n, b->true_count));
     }
     else
     {
@@ -353,7 +354,7 @@ void tr_bitfieldSetRaw(tr_bitfield* b, void const* bits, size_t byte_count, bool
 
     if (bounded)
     {
-        byte_count = MIN(byte_count, get_bytes_needed(b->bit_count));
+        byte_count = std::min(byte_count, get_bytes_needed(b->bit_count));
     }
 
     b->bits = static_cast<uint8_t*>(tr_memdup(bits, byte_count));

libtransmission/fdlimit.cc

@@ -6,9 +6,10 @@
  *
  */
 
-#include <errno.h>
+#include <algorithm>
-#include <inttypes.h>
+#include <cerrno>
-#include <string.h>
+#include <cinttypes>
+#include <cstring>
 
 #include "transmission.h"
 #include "error.h"
@@ -90,7 +91,7 @@ static bool preallocate_file_full(tr_sys_file_t fd, uint64_t length, tr_error**
         /* fallback: the old-fashioned way */
         while (success && length > 0)
         {
-            uint64_t const thisPass = MIN(length, sizeof(buf));
+            uint64_t const thisPass = std::min(length, uint64_t{ sizeof(buf) });
             uint64_t bytes_written;
             success = tr_sys_file_write(fd, buf, thisPass, &bytes_written, &my_error);
             length -= bytes_written;

libtransmission/file-posix.cc

@@ -9,19 +9,20 @@
 #undef _GNU_SOURCE
 #define _GNU_SOURCE
 
+#include <algorithm>
+#include <cerrno>
+#include <climits> /* PATH_MAX */
+#include <cstdint> /* SIZE_MAX */
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #include <dirent.h>
-#include <errno.h>
 #include <fcntl.h> /* O_LARGEFILE, posix_fadvise(), [posix_]fallocate(), fcntl() */
 #include <libgen.h> /* basename(), dirname() */
-#include <limits.h> /* PATH_MAX */
-#include <stdint.h> /* SIZE_MAX */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
 #include <sys/file.h> /* flock() */
 #include <sys/mman.h> /* mmap(), munmap() */
 #include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h> /* lseek(), write(), ftruncate(), pread(), pwrite(), pathconf(), etc */
 #include <vector>
 
@@ -487,7 +488,7 @@ bool tr_sys_path_copy(char const* src_path, char const* dst_path, tr_error** err
 
     while (file_size > 0)
     {
-        size_t const chunk_size = MIN(file_size, SSIZE_MAX);
+        size_t const chunk_size = std::min(file_size, uint64_t{ SSIZE_MAX });
         ssize_t const copied =
 #ifdef USE_COPY_FILE_RANGE
             copy_file_range(in, nullptr, out, nullptr, chunk_size, 0);
@@ -518,7 +519,7 @@ bool tr_sys_path_copy(char const* src_path, char const* dst_path, tr_error** err
 
     while (file_size > 0)
     {
-        uint64_t const chunk_size = MIN(file_size, buflen);
+        uint64_t const chunk_size = std::min(file_size, uint64_t{ buflen });
         uint64_t bytes_read;
         uint64_t bytes_written;
 

libtransmission/file.cc

@@ -6,7 +6,8 @@
  *
  */
 
-#include <string.h> /* strlen() */
+#include <algorithm>
+#include <cstring> /* strlen() */
 
 #include "transmission.h"
 #include "error.h"
@@ -26,7 +27,7 @@ bool tr_sys_file_read_line(tr_sys_file_t handle, char* buffer, size_t buffer_siz
 
     while (buffer_size > 0)
     {
-        size_t const bytes_needed = MIN(buffer_size, 1024u);
+        size_t const bytes_needed = std::min(buffer_size, size_t{ 1024 });
 
         ret = tr_sys_file_read(handle, buffer + offset, bytes_needed, &bytes_read, error);
 

libtransmission/inout.cc

@@ -6,9 +6,10 @@
  *
  */
 
-#include <errno.h>
+#include <algorithm>
-#include <stdlib.h> /* bsearch() */
+#include <cerrno>
-#include <string.h> /* memcmp() */
+#include <cstdlib> /* bsearch() */
+#include <cstring> /* memcmp() */
 
 #include "transmission.h"
 #include "cache.h" /* tr_cacheReadBlock() */
@@ -217,7 +218,7 @@ static int readOrWritePiece(
     while (buflen != 0 && err == 0)
     {
         tr_file const* file = &info->files[fileIndex];
-        uint64_t const bytesThisPass = MIN(buflen, file->length - fileOffset);
+        uint64_t const bytesThisPass = std::min(uint64_t{ buflen }, uint64_t{ file->length - fileOffset });
 
         err = readOrWriteBytes(tor->session, tor, ioMode, fileIndex, fileOffset, buf, bytesThisPass);
         buf += bytesThisPass;
@@ -278,7 +279,7 @@ static bool recalculateHash(tr_torrent* tor, tr_piece_index_t pieceIndex, uint8_
 
     while (bytesLeft != 0)
     {
-        size_t const len = MIN(bytesLeft, buflen);
+        size_t const len = std::min(bytesLeft, buflen);
         success = tr_cacheReadBlock(tor->session->cache, tor, pieceIndex, offset, len, static_cast<uint8_t*>(buffer)) == 0;
 
         if (!success)

libtransmission/makemeta.cc

@@ -6,9 +6,10 @@
  *
  */
 
-#include <errno.h>
+#include <algorithm>
-#include <stdlib.h> /* qsort */
+#include <cerrno>
-#include <string.h> /* strcmp, strlen */
+#include <cstdlib> /* qsort */
+#include <cstring> /* strcmp, strlen */
 
 #include <event2/util.h> /* evutil_ascii_strcasecmp() */
 
@@ -283,12 +284,12 @@ static uint8_t* getHashInfo(tr_metainfo_builder* b)
         TR_ASSERT(b->pieceIndex < b->pieceCount);
 
         uint8_t* bufptr = buf;
-        uint32_t const thisPieceSize = (uint32_t)MIN(b->pieceSize, totalRemain);
+        uint32_t const thisPieceSize = std::min(uint64_t{ b->pieceSize }, totalRemain);
         uint64_t leftInPiece = thisPieceSize;
 
         while (leftInPiece != 0)
         {
-            uint64_t const n_this_pass = MIN(b->files[fileIndex].size - off, leftInPiece);
+            uint64_t const n_this_pass = std::min(b->files[fileIndex].size - off, leftInPiece);
             uint64_t n_read = 0;
             (void)tr_sys_file_read(fd, bufptr, n_this_pass, &n_read, nullptr);
             bufptr += n_read;

libtransmission/peer-io.cc

@@ -6,14 +6,15 @@
  *
  */
 
-#include <errno.h>
+#include <algorithm>
-#include <string.h>
+#include <cerrno>
+#include <cstdint>
+#include <cstring>
 
 #include <event2/event.h>
 #include <event2/buffer.h>
 #include <event2/bufferevent.h>
 
-#include <stdint.h>
 #include <libutp/utp.h>
 
 #include "transmission.h"
@@ -158,7 +159,7 @@ static void didWriteWrapper(tr_peerIo* io, unsigned int bytes_transferred)
     {
         struct tr_datatype* next = io->outbuf_datatypes;
 
-        unsigned int const payload = MIN(next->length, bytes_transferred);
+        unsigned int const payload = std::min(uint64_t{ next->length }, uint64_t{ bytes_transferred });
         /* For uTP sockets, the overhead is computed in utp_on_overhead. */
         unsigned int const overhead = io->socket.type == TR_PEER_SOCKET_TYPE_TCP ? guessPacketOverhead(payload) : 0;
         uint64_t const now = tr_time_msec();
@@ -1096,8 +1097,8 @@ static unsigned int getDesiredOutputBufferSize(tr_peerIo const* io, uint64_t now
     unsigned int const currentSpeed_Bps = tr_bandwidthGetPieceSpeed_Bps(&io->bandwidth, now, TR_UP);
     unsigned int const period = 15U; /* arbitrary */
     /* the 3 is arbitrary; the .5 is to leave room for messages */
-    static unsigned int const ceiling = (unsigned int)(MAX_BLOCK_SIZE * 3.5);
+    static auto const ceiling = (unsigned int)(MAX_BLOCK_SIZE * 3.5);
-    return MAX(ceiling, currentSpeed_Bps * period);
+    return std::max(ceiling, currentSpeed_Bps * period);
 }
 
 size_t tr_peerIoGetWriteBufferSpace(tr_peerIo const* io, uint64_t now)
@@ -1301,7 +1302,7 @@ void tr_peerIoDrain(tr_peerIo* io, struct evbuffer* inbuf, size_t byteCount)
 
     while (byteCount > 0)
     {
-        size_t const thisPass = MIN(byteCount, buflen);
+        size_t const thisPass = std::min(byteCount, buflen);
         tr_peerIoReadBytes(io, inbuf, buf, thisPass);
         byteCount -= thisPass;
     }

libtransmission/peer-mgr.cc

@@ -6,15 +6,15 @@
  *
  */
 
-#include <algorithm> // std::partial_sort
+#include <algorithm>
-#include <errno.h> /* error codes ERANGE, ... */
+#include <cerrno> /* error codes ERANGE, ... */
-#include <limits.h> /* INT_MAX */
+#include <climits> /* INT_MAX */
-#include <string.h> /* memcpy, memcmp, strstr */
+#include <cstdlib> /* qsort */
-#include <stdlib.h> /* qsort */
+#include <cstring> /* memcpy, memcmp, strstr */
 
 #include <event2/event.h>
 
-#include <stdint.h>
+#include <cstdint>
 #include <libutp/utp.h>
 
 #include "transmission.h"
@@ -833,7 +833,7 @@ static void updateEndgame(tr_swarm* s)
         numDownloading += countActiveWebseeds(s);
 
         /* average number of pending requests per downloading peer */
-        s->endgame = s->requestCount / MAX(numDownloading, 1);
+        s->endgame = s->requestCount / std::max(numDownloading, 1);
     }
 }
 
@@ -1504,7 +1504,7 @@ static void refillUpkeep(evutil_socket_t fd, short what, void* vmgr)
 
     while ((tor = tr_torrentNext(mgr->session, tor)) != nullptr)
     {
-        cancel_buflen = MAX(cancel_buflen, tor->swarm->requestCount);
+        cancel_buflen = std::max(cancel_buflen, tor->swarm->requestCount);
     }
 
     if (cancel_buflen > 0)
@@ -2432,7 +2432,7 @@ int tr_peerMgrGetPeers(tr_torrent const* tor, tr_pex** setme_pex, uint8_t af, ui
     ***  add the first N of them into our return list
     **/
 
-    n = MIN(atomCount, maxCount);
+    n = std::min(atomCount, maxCount);
     pex = walk = tr_new0(tr_pex, n);
 
     for (int i = 0; i < atomCount && count < n; ++i)
@@ -2754,7 +2754,7 @@ uint64_t tr_peerMgrGetDesiredAvailable(tr_torrent const* tor)
 
     uint64_t desiredAvailable = 0;
 
-    for (size_t i = 0, n = MIN(tor->info.pieceCount, s->pieceReplicationSize); i < n; ++i)
+    for (size_t i = 0, n = std::min(size_t{ tor->info.pieceCount }, s->pieceReplicationSize); i < n; ++i)
     {
         if (!tor->info.pieces[i].dnd && s->pieceReplication[i] > 0)
         {
@@ -3041,7 +3041,7 @@ static void rechokeDownloads(tr_swarm* s)
             /* cancelRate: of the block requests we've recently made, the percentage we cancelled.
              * higher values indicate more congestion. */
             double const cancelRate = cancels / (double)(cancels + blocks);
-            double const mult = 1 - MIN(cancelRate, 0.5);
+            double const mult = 1 - std::min(cancelRate, 0.5);
             maxPeers = s->interestedCount * mult;
             tordbg(
                 s,
@@ -3057,7 +3057,7 @@ static void rechokeDownloads(tr_swarm* s)
         {
             int const maxIncrease = 15;
             time_t const maxHistory = 2 * CANCEL_HISTORY_SEC;
-            double const mult = MIN(timeSinceCancel, maxHistory) / (double)maxHistory;
+            double const mult = std::min(timeSinceCancel, maxHistory) / (double)maxHistory;
             int const inc = maxIncrease * mult;
             maxPeers = s->maxPeers + inc;
             tordbg(
@@ -3153,7 +3153,7 @@ static void rechokeDownloads(tr_swarm* s)
 
     /* now that we know which & how many peers to be interested in... update the peer interest */
 
-    s->interestedCount = MIN(maxPeers, rechoke_count);
+    s->interestedCount = std::min(maxPeers, rechoke_count);
 
     for (int i = 0; i < rechoke_count; ++i)
     {
@@ -3437,7 +3437,7 @@ static bool shouldPeerBeClosed(tr_swarm const* s, tr_peer const* peer, int peerC
         int const lo = MIN_UPLOAD_IDLE_SECS;
         int const hi = MAX_UPLOAD_IDLE_SECS;
         int const limit = hi - (hi - lo) * strictness;
-        int const idleTime = now - MAX(atom->time, atom->piece_data_time);
+        int const idleTime = now - std::max(atom->time, atom->piece_data_time);
 
         if (idleTime > limit)
         {
@@ -3975,7 +3975,7 @@ static int compareAtomPtrsByShelfDate(void const* va, void const* vb)
 
 static int getMaxAtomCount(tr_torrent const* tor)
 {
-    return MIN(50, tor->maxConnectedPeers * 3);
+    return std::min(50, tor->maxConnectedPeers * 3);
 }
 
 static void atomPulse(evutil_socket_t fd, short what, void* vmgr)
@@ -4182,7 +4182,7 @@ static uint64_t getPeerCandidateScore(tr_torrent const* tor, struct peer_atom co
 static bool checkBestScoresComeFirst(struct peer_candidate const* candidates, int n, int k)
 {
     uint64_t worstFirstScore = 0;
-    int const x = MIN(n, k) - 1;
+    int const x = std::min(n, k) - 1;
 
     for (int i = 0; i < x; i++)
     {

libtransmission/peer-msgs.cc

@@ -6,10 +6,11 @@
  *
  */
 
-#include <errno.h>
+#include <algorithm>
-#include <stdarg.h>
+#include <cerrno>
-#include <stdlib.h>
+#include <cstdarg>
-#include <string.h>
+#include <cstdlib>
+#include <cstring>
 
 #include <event2/buffer.h>
 #include <event2/bufferevent.h>
@@ -636,7 +637,7 @@ static void updateFastSet(tr_peerMsgs* msgs)
     {
         struct tr_address const* addr = tr_peerIoGetAddress(msgs->io, nullptr);
         tr_info const* inf = &msgs->torrent->info;
-        size_t const numwant = MIN(MAX_FAST_SET_SIZE, inf->pieceCount);
+        size_t const numwant = std::min(MAX_FAST_SET_SIZE, inf->pieceCount);
 
         /* build the fast set */
         msgs->fastsetSize = tr_generateAllowedSet(msgs->fastset, numwant, inf->pieceCount, inf->hash, addr);
@@ -1170,7 +1171,7 @@ static void parseUtPex(tr_peerMsgs* msgs, uint32_t msglen, struct evbuffer* inbu
         }
 
         pex = tr_peerMgrCompactToPex(added, added_len, added_f, added_f_len, &n);
-        n = MIN(n, MAX_PEX_PEER_COUNT);
+        n = std::min(n, size_t{ MAX_PEX_PEER_COUNT });
         tr_peerMgrAddPex(tor, TR_PEER_FROM_PEX, pex, n);
 
         tr_free(pex);
@@ -1190,7 +1191,7 @@ static void parseUtPex(tr_peerMsgs* msgs, uint32_t msglen, struct evbuffer* inbu
         }
 
         pex = tr_peerMgrCompact6ToPex(added, added_len, added_f, added_f_len, &n);
-        n = MIN(n, MAX_PEX_PEER_COUNT);
+        n = std::min(n, size_t{ MAX_PEX_PEER_COUNT });
         tr_peerMgrAddPex(tor, TR_PEER_FROM_PEX, pex, n);
 
         tr_free(pex);
@@ -1452,7 +1453,7 @@ static ReadState readBtPiece(tr_peerMsgs* msgs, struct evbuffer* inbuf, size_t i
 
         /* read in another chunk of data */
         nLeft = req->length - evbuffer_get_length(block_buffer);
-        n = MIN(nLeft, inlen);
+        n = std::min(nLeft, inlen);
 
         tr_peerIoReadBytesToBuf(msgs->io, inbuf, block_buffer, n);
 
@@ -1892,20 +1893,20 @@ static void updateDesiredRequestCount(tr_peerMsgs* msgs)
 
         if (tr_torrentUsesSpeedLimit(torrent, TR_PEER_TO_CLIENT))
         {
-            rate_Bps = MIN(rate_Bps, tr_torrentGetSpeedLimit_Bps(torrent, TR_PEER_TO_CLIENT));
+            rate_Bps = std::min(rate_Bps, tr_torrentGetSpeedLimit_Bps(torrent, TR_PEER_TO_CLIENT));
         }
 
         /* honor the session limits, if enabled */
         if (tr_torrentUsesSessionLimits(torrent) &&
             tr_sessionGetActiveSpeedLimit_Bps(torrent->session, TR_PEER_TO_CLIENT, &irate_Bps))
         {
-            rate_Bps = MIN(rate_Bps, irate_Bps);
+            rate_Bps = std::min(rate_Bps, irate_Bps);
         }
 
         /* use this desired rate to figure out how
          * many requests we should send to this peer */
         estimatedBlocksInPeriod = (rate_Bps * seconds) / torrent->blockSize;
-        msgs->desiredRequestCount = MAX(floor, estimatedBlocksInPeriod);
+        msgs->desiredRequestCount = std::max(floor, estimatedBlocksInPeriod);
 
         /* honor the peer's maximum request count, if specified */
         if ((msgs->reqq > 0) && (msgs->desiredRequestCount > msgs->reqq))

libtransmission/port-forwarding.cc

@@ -6,8 +6,8 @@
  *
  */
 
-#include <stdio.h>
+#include <algorithm>
-
+#include <cstdio>
 #include <sys/types.h>
 
 #include <event2/event.h>
@@ -262,5 +262,5 @@ bool tr_sharedTraversalIsEnabled(tr_shared const* s)
 
 int tr_sharedTraversalStatus(tr_shared const* s)
 {
-    return MAX(s->natpmpStatus, s->upnpStatus);
+    return std::max(s->natpmpStatus, s->upnpStatus);
 }

libtransmission/ptrarray.cc

@@ -6,7 +6,8 @@
  *
  */
 
-#include <string.h> /* memmove */
+#include <algorithm>
+#include <cstring> /* memmove */
 
 #include "ptrarray.h"
 #include "tr-assert.h"
@@ -50,7 +51,7 @@ int tr_ptrArrayInsert(tr_ptrArray* t, void* ptr, int pos)
 {
     if (t->n_items >= t->n_alloc)
     {
-        t->n_alloc = MAX(FLOOR, t->n_alloc * 2);
+        t->n_alloc = std::max(FLOOR, t->n_alloc * 2);
         t->items = tr_renew(void*, t->items, t->n_alloc);
     }
 

libtransmission/quark.cc

@@ -6,8 +6,9 @@
  *
  */
 
-#include <stdlib.h> /* bsearch() */
+#include <algorithm>
-#include <string.h> /* memcmp() */
+#include <cstdlib> /* bsearch() */
+#include <cstring> /* memcmp() */
 
 #include "transmission.h"
 #include "ptrarray.h"
@@ -424,7 +425,7 @@ static int compareKeys(void const* va, void const* vb)
     auto const* a = static_cast<struct tr_key_struct const*>(va);
     auto const* b = static_cast<struct tr_key_struct const*>(vb);
 
-    int ret = memcmp(a->str, b->str, MIN(a->len, b->len));
+    int ret = memcmp(a->str, b->str, std::min(a->len, b->len));
 
     if (ret == 0 && a->len != b->len)
     {

libtransmission/resume.cc

@@ -6,7 +6,8 @@
  *
  */
 
-#include <string.h>
+#include <algorithm>
+#include <cstring>
 
 #include "transmission.h"
 #include "completion.h"
@@ -69,7 +70,7 @@ static void savePeers(tr_variant* dict, tr_torrent const* tor)
 static size_t addPeers(tr_torrent* tor, uint8_t const* buf, size_t buflen)
 {
     size_t const n_in = buflen / sizeof(tr_pex);
-    size_t const n_pex = MIN(n_in, MAX_REMEMBERED_PEERS);
+    size_t const n_pex = std::min(n_in, size_t{ MAX_REMEMBERED_PEERS });
 
     tr_pex pex[MAX_REMEMBERED_PEERS];
     memcpy(pex, buf, sizeof(tr_pex) * n_pex);

libtransmission/rpc-server.cc

@@ -6,8 +6,9 @@
  *
  */
 
-#include <errno.h>
+#include <algorithm>
-#include <string.h> /* memcpy */
+#include <cerrno>
+#include <cstring> /* memcpy */
 
 #include <zlib.h>
 
@@ -802,7 +803,7 @@ static void rpc_server_on_start_retry(evutil_socket_t fd, short type, void* cont
 static int rpc_server_start_retry(tr_rpc_server* server)
 {
     int retry_delay = (server->start_retry_counter / SERVER_START_RETRY_DELAY_STEP + 1) * SERVER_START_RETRY_DELAY_INCREMENT;
-    retry_delay = MIN(retry_delay, SERVER_START_RETRY_MAX_DELAY);
+    retry_delay = std::min(retry_delay, int{ SERVER_START_RETRY_MAX_DELAY });
 
     if (server->start_retry_timer == nullptr)
     {

libtransmission/rpcimpl.cc

@@ -6,10 +6,11 @@
  *
  */
 
-#include <ctype.h> /* isdigit */
+#include <algorithm>
-#include <errno.h>
+#include <cctype> /* isdigit */
-#include <stdlib.h> /* strtol */
+#include <cerrno>
-#include <string.h> /* strcmp */
+#include <cstdlib> /* strtol */
+#include <cstring> /* strcmp */
 
 #ifndef ZLIB_CONST
 #define ZLIB_CONST
@@ -1246,7 +1247,7 @@ static int copyTrackers(tr_tracker_info* tgt, tr_tracker_info const* src, int n)
     {
         tgt[i].tier = src[i].tier;
         tgt[i].announce = tr_strdup(src[i].announce);
-        maxTier = MAX(maxTier, src[i].tier);
+        maxTier = std::max(maxTier, src[i].tier);
     }
 
     return maxTier;

libtransmission/session.cc

@@ -6,15 +6,15 @@
  *
  */
 
-#include <algorithm> // std::partial_sort
+#include <algorithm> // std::partial_sort, min, max
-#include <errno.h> /* ENOENT */
+#include <cerrno> /* ENOENT */
-#include <limits.h> /* INT_MAX */
+#include <climits> /* INT_MAX */
-#include <stdlib.h>
+#include <csignal>
-#include <string.h> /* memcpy */
+#include <cstdint>
+#include <cstdlib>
+#include <cstring> /* memcpy */
 #include <vector>
 
-#include <signal.h>
-
 #ifndef _WIN32
 #include <sys/types.h> /* umask() */
 #include <sys/stat.h> /* umask() */
@@ -23,7 +23,6 @@
 #include <event2/dns.h> /* evdns_base_free() */
 #include <event2/event.h>
 
-#include <stdint.h>
 #include <libutp/utp.h>
 
 // #define TR_SHOW_DEPRECATED
@@ -3082,7 +3081,7 @@ int tr_sessionCountQueueFreeSlots(tr_session* session, tr_direction dir)
         /* is it stalled? */
         if (stalled_enabled)
         {
-            int const idle_secs = (int)difftime(now, MAX(tor->startDate, tor->activityDate));
+            int const idle_secs = (int)difftime(now, std::max(tor->startDate, tor->activityDate));
             if (idle_secs >= stalled_if_idle_for_n_seconds)
                 continue;
         }

libtransmission/subprocess-win32.cc

@@ -6,10 +6,11 @@
  *
  */
 
-#include <limits.h>
+#include <algorithm>
-#include <stdlib.h>
+#include <climits>
-#include <string.h>
+#include <cstdlib>
-#include <wchar.h>
+#include <cstring>
+#include <cwchar>
 
 #include <windows.h>
 
@@ -94,7 +95,7 @@ static bool parse_env_block_part(wchar_t const* part, size_t* full_len, size_t*
 
 static int compare_wide_strings_ci(wchar_t const* lhs, size_t lhs_len, wchar_t const* rhs, size_t rhs_len)
 {
-    int diff = wcsnicmp(lhs, rhs, MIN(lhs_len, rhs_len));
+    int diff = wcsnicmp(lhs, rhs, std::min(lhs_len, rhs_len));
 
     if (diff == 0)
     {

libtransmission/torrent.cc

@@ -6,8 +6,14 @@
  *
  */
 
-#include <errno.h> /* EINVAL */
+#include <algorithm> /* EINVAL */
-#include <signal.h> /* signal() */
+#include <cerrno> /* EINVAL */
+#include <climits> /* INT_MAX */
+#include <cmath>
+#include <csignal> /* signal() */
+#include <cstdarg>
+#include <cstdlib> /* qsort */
+#include <cstring> /* memcmp */
 
 #ifndef _WIN32
 #include <sys/wait.h> /* wait() */
@@ -16,12 +22,6 @@
 #include <windows.h> /* CreateProcess(), GetLastError() */
 #endif
 
-#include <math.h>
-#include <stdarg.h>
-#include <string.h> /* memcmp */
-#include <stdlib.h> /* qsort */
-#include <limits.h> /* INT_MAX */
-
 #include <event2/util.h> /* evutil_vsnprintf() */
 
 #include "transmission.h"
@@ -478,7 +478,7 @@ static bool tr_torrentIsSeedIdleLimitDone(tr_torrent* tor)
 {
     uint16_t idleMinutes;
     return tr_torrentGetSeedIdle(tor, &idleMinutes) &&
-        difftime(tr_time(), MAX(tor->startDate, tor->activityDate)) >= idleMinutes * 60U;
+        difftime(tr_time(), std::max(tor->startDate, tor->activityDate)) >= idleMinutes * 60U;
 }
 
 /***
@@ -641,7 +641,7 @@ static tr_priority_t calculatePiecePriority(tr_torrent const* tor, tr_piece_inde
 {
     // safeguard against a bad arg
     tr_info const* const inf = tr_torrentInfo(tor);
-    file_hint = MIN(file_hint, inf->fileCount - 1);
+    file_hint = std::min(file_hint, inf->fileCount - 1);
 
     // find the first file with data in this piece
     tr_file_index_t first = file_hint;
@@ -661,7 +661,7 @@ static tr_priority_t calculatePiecePriority(tr_torrent const* tor, tr_piece_inde
             break;
         }
 
-        priority = MAX(priority, file->priority);
+        priority = std::max(priority, file->priority);
 
         /* When dealing with multimedia files, getting the first and
            last pieces can sometimes allow you to preview it a bit
@@ -1245,7 +1245,7 @@ tr_torrent_activity tr_torrentGetActivity(tr_torrent const* tor)
 static int torrentGetIdleSecs(tr_torrent const* tor, tr_torrent_activity activity)
 {
     return ((activity == TR_STATUS_DOWNLOAD || activity == TR_STATUS_SEED) && tor->startDate != 0) ?
-        (int)difftime(tr_time(), MAX(tor->startDate, tor->activityDate)) :
+        (int)difftime(tr_time(), std::max(tor->startDate, tor->activityDate)) :
         -1;
 }
 
@@ -2851,7 +2851,7 @@ void tr_torrentSetDateAdded(tr_torrent* tor, time_t t)
     TR_ASSERT(tr_isTorrent(tor));
 
     tor->addedDate = t;
-    tor->anyDate = MAX(tor->anyDate, tor->addedDate);
+    tor->anyDate = std::max(tor->anyDate, tor->addedDate);
 }
 
 void tr_torrentSetDateActive(tr_torrent* tor, time_t t)
@@ -2859,7 +2859,7 @@ void tr_torrentSetDateActive(tr_torrent* tor, time_t t)
     TR_ASSERT(tr_isTorrent(tor));
 
     tor->activityDate = t;
-    tor->anyDate = MAX(tor->anyDate, tor->activityDate);
+    tor->anyDate = std::max(tor->anyDate, tor->activityDate);
 }
 
 void tr_torrentSetDateDone(tr_torrent* tor, time_t t)
@@ -2867,7 +2867,7 @@ void tr_torrentSetDateDone(tr_torrent* tor, time_t t)
     TR_ASSERT(tr_isTorrent(tor));
 
     tor->doneDate = t;
-    tor->anyDate = MAX(tor->anyDate, tor->doneDate);
+    tor->anyDate = std::max(tor->anyDate, tor->doneDate);
 }
 
 /**
@@ -3441,7 +3441,7 @@ void tr_torrentGotBlock(tr_torrent* tor, tr_block_index_t block)
                 uint32_t const n = tr_torPieceCountBytes(tor, p);
                 tr_logAddTorErr(tor, _("Piece %" PRIu32 ", which was just downloaded, failed its checksum test"), p);
                 tor->corruptCur += n;
-                tor->downloadedCur -= MIN(tor->downloadedCur, n);
+                tor->downloadedCur -= std::min(tor->downloadedCur, uint64_t{ n });
                 tr_peerMgrGotBadPiece(tor, p);
             }
         }
@@ -3449,7 +3449,7 @@ void tr_torrentGotBlock(tr_torrent* tor, tr_block_index_t block)
     else
     {
         uint32_t const n = tr_torBlockCountBytes(tor, block);
-        tor->downloadedCur -= MIN(tor->downloadedCur, n);
+        tor->downloadedCur -= std::min(tor->downloadedCur, uint64_t{ n });
         tr_logAddTorDbg(tor, "we have this block already...");
     }
 }
@@ -3675,7 +3675,7 @@ void tr_torrentSetQueuePosition(tr_torrent* tor, int pos)
         }
     }
 
-    tor->queuePosition = MIN(pos, back + 1);
+    tor->queuePosition = std::min(pos, back + 1);
     tor->anyDate = now;
 
     TR_ASSERT(queueIsSequenced(tor->session));

libtransmission/tr-dht.cc

@@ -22,14 +22,12 @@
  *
  */
 
-/* ansi */
+#include <algorithm>
-#include <errno.h>
+#include <cerrno>
-#include <stdio.h>
+#include <csignal> /* sig_atomic_t */
-#include <string.h> /* memcpy(), memset(), memchr(), strlen() */
+#include <cstdio>
-#include <stdlib.h> /* atoi() */
+#include <cstdlib> /* atoi() */
-
+#include <cstring> /* memcpy(), memset(), memchr(), strlen() */
-/* posix */
-#include <signal.h> /* sig_atomic_t */
 
 #ifdef _WIN32
 #include <inttypes.h>
@@ -177,7 +175,7 @@ static void dht_bootstrap(void* closure)
         tr_logAddNamedInfo("DHT", "Bootstrapping from %d IPv6 nodes", num6);
     }
 
-    for (int i = 0; i < MAX(num, num6); ++i)
+    for (int i = 0; i < std::max(num, num6); ++i)
     {
         if (i < num && !bootstrap_done(cl->session, AF_INET))
         {
@@ -859,7 +857,7 @@ void dht_hash(void* hash_return, int hash_size, void const* v1, int len1, void c
     unsigned char sha1[SHA_DIGEST_LENGTH];
     tr_sha1(sha1, v1, len1, v2, len2, v3, len3, nullptr);
     memset(hash_return, 0, hash_size);
-    memcpy(hash_return, sha1, MIN(hash_size, SHA_DIGEST_LENGTH));
+    memcpy(hash_return, sha1, std::min(hash_size, SHA_DIGEST_LENGTH));
 }
 
 int dht_random_bytes(void* buf, size_t size)

libtransmission/tr-getopt.cc

@@ -6,10 +6,11 @@
  *
  */
 
-#include <ctype.h> /* isspace() */
+#include <algorithm>
-#include <stdio.h>
+#include <cctype> /* isspace() */
-#include <stdlib.h> /* exit() */
+#include <cstdio>
-#include <string.h>
+#include <cstdlib> /* exit() */
+#include <cstring>
 
 #include "transmission.h"
 #include "tr-getopt.h"
@@ -100,21 +101,23 @@ static void getopts_usage_line(tr_option const* opt, int longWidth, int shortWid
 
 static void maxWidth(struct tr_option const* o, int* longWidth, int* shortWidth, int* argWidth)
 {
+    // FIXME: in this function sign bits from int* are lost, then 64-bit result is truncated to 32-bit int
+    // Convert arguments to size_t*
     char const* arg;
 
     if (o->longName != nullptr)
     {
-        *longWidth = MAX(*longWidth, (int)strlen(o->longName));
+        *longWidth = std::max((size_t)*longWidth, strlen(o->longName));
     }
 
     if (o->shortName != nullptr)
     {
-        *shortWidth = MAX(*shortWidth, (int)strlen(o->shortName));
+        *shortWidth = std::max((size_t)*shortWidth, strlen(o->shortName));
     }
 
     if ((arg = getArgName(o)) != nullptr)
     {
-        *argWidth = MAX(*argWidth, (int)strlen(arg));
+        *argWidth = std::max((size_t)*argWidth, strlen(arg));
     }
 }
 

libtransmission/tr-lpd.cc

@@ -20,21 +20,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
 
-/* ansi */
+#include <algorithm>
-#include <errno.h>
+#include <cctype> /* toupper() */
-#include <stdio.h>
+#include <cerrno>
-#include <string.h> /* strlen(), strncpy(), strstr(), memset() */
+#include <csignal> /* sig_atomic_t */
-
+#include <cstdio>
-/* posix */
+#include <cstring> /* strlen(), strncpy(), strstr(), memset() */
-#include <signal.h> /* sig_atomic_t */
-#include <ctype.h> /* toupper() */
 
 #ifdef _WIN32
 #include <inttypes.h>
 #include <ws2tcpip.h>
 typedef uint16_t in_port_t; /* all missing */
 #else
-#include <sys/time.h>
+#include <ctime>
 #include <unistd.h> /* close() */
 #include <sys/types.h>
 #include <sys/socket.h> /* socket(), bind() */
@@ -269,7 +267,7 @@ static bool lpd_extractParam(char const* const str, char const* const name, int
 
         /* if value string hits the length limit n,
          * leave space for a trailing '\0' character */
-        n = MIN(len, n - 1);
+        n = std::min(len, n - 1);
         strncpy(val, beg, n);
         val[n] = 0;
     }

libtransmission/tr-macros.h

@@ -147,17 +147,6 @@
     } while (0)
 #endif
 
-/* Sometimes the system defines MAX/MIN, sometimes not.
-   In the latter case, define those here since we will use them */
-
-#ifndef MAX
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-#endif
-
-#ifndef MIN
-#define MIN(a, b) ((a) > (b) ? (b) : (a))
-#endif
-
 /***
 ****
 ***/

libtransmission/utils.cc

@@ -13,16 +13,16 @@
 #endif
 
 #include <array> // std::array
-#include <ctype.h> /* isdigit(), tolower() */
+#include <cctype> /* isdigit(), tolower() */
-#include <errno.h>
+#include <cerrno>
-#include <float.h> /* DBL_DIG */
+#include <cfloat> /* DBL_DIG */
-#include <locale.h> /* localeconv() */
+#include <clocale> /* localeconv() */
-#include <math.h> /* fabs(), floor() */
+#include <cmath> /* fabs(), floor() */
-#include <stdint.h> /* SIZE_MAX */
+#include <cstdint> /* SIZE_MAX */
-#include <stdio.h>
+#include <cstdio>
-#include <stdlib.h> /* getenv() */
+#include <cstdlib> /* getenv() */
-#include <string.h> /* strerror(), memset(), memmem() */
+#include <cstring> /* strerror(), memset(), memmem() */
-#include <time.h> /* nanosleep() */
+#include <ctime> /* nanosleep() */
 
 #ifdef _WIN32
 #include <ws2tcpip.h> /* WSAStartup() */
@@ -30,7 +30,7 @@
 #include <shellapi.h> /* CommandLineToArgv() */
 #include <shlwapi.h> /* StrStrIA() */
 #else
-#include <sys/time.h>
+#include <ctime>
 #include <unistd.h> /* getpagesize() */
 #endif
 
@@ -1423,8 +1423,8 @@ static bool parseNumberSection(char const* str, size_t len, struct number_range*
 
     tr_free(tmp);
 
-    setme->low = MIN(a, b);
+    setme->low = (int)std::min(a, b); // FIXME: narrowing long to int
-    setme->high = MAX(a, b);
+    setme->high = (int)std::max(a, b);
 
     errno = error;
     return success;

libtransmission/verify.cc

@@ -6,8 +6,9 @@
  *
  */
 
-#include <string.h> /* memcmp() */
+#include <algorithm>
-#include <stdlib.h> /* free() */
+#include <cstdlib> /* free() */
+#include <cstring> /* memcmp() */
 
 #include "transmission.h"
 #include "completion.h"
@@ -76,8 +77,8 @@ static bool verifyTorrent(tr_torrent* tor, bool* stopFlag)
         /* figure out how much we can read this pass */
         leftInPiece = tr_torPieceCountBytes(tor, pieceIndex) - piecePos;
         leftInFile = file->length - filePos;
-        bytesThisPass = MIN(leftInFile, leftInPiece);
+        bytesThisPass = std::min(leftInFile, leftInPiece);
-        bytesThisPass = MIN(bytesThisPass, buflen);
+        bytesThisPass = std::min(bytesThisPass, uint64_t{ buflen });
 
         /* read a bit */
         if (fd != TR_BAD_SYS_FILE)

libtransmission/web.cc

@@ -6,7 +6,8 @@
  *
  */
 
-#include <string.h> /* strlen(), strstr() */
+#include <algorithm>
+#include <cstring> /* strlen(), strstr() */
 
 #ifdef _WIN32
 #include <windows.h>
@@ -541,7 +542,7 @@ static void tr_webThreadFunc(void* vsession)
                     /* curl_multi_wait() returns immediately if there are
                      * no fds to wait for, so we need an explicit wait here
                      * to emulate select() behavior */
-                    tr_wait_msec(MIN(msec, THREADFUNC_MAX_SLEEP_MSEC / 2));
+                    tr_wait_msec(std::min(msec, THREADFUNC_MAX_SLEEP_MSEC / 2L));
                 }
             }
             else

libtransmission/webseed.cc

@@ -6,7 +6,8 @@
  *
  */
 
-#include <string.h> /* strlen() */
+#include <algorithm>
+#include <cstring> /* strlen() */
 
 #include <event2/buffer.h>
 #include <event2/event.h>
@@ -163,7 +164,7 @@ static void write_block_func(void* vdata)
         {
             while (len > 0)
             {
-                uint32_t const bytes_this_pass = MIN(len, block_size);
+                uint32_t const bytes_this_pass = std::min(len, block_size);
                 tr_cacheWriteBlock(cache, tor, piece, offset_end - len, bytes_this_pass, buf);
                 len -= bytes_this_pass;
             }
@@ -323,7 +324,7 @@ static void on_idle(tr_webseed* w)
         blocks = tr_new(tr_block_index_t, want * 2);
         tr_peerMgrGetNextRequests(tor, &w->parent, want, blocks, &got, true);
 
-        w->idle_connections -= MIN(w->idle_connections, got);
+        w->idle_connections -= std::min(w->idle_connections, got);
 
         if (w->retry_tickcount >= FAILURE_RETRY_INTERVAL && got == want)
         {
@@ -488,7 +489,7 @@ static void task_request_next_chunk(struct tr_webseed_task* t)
 
         tr_ioFindFileLocation(tor, step_piece, step_piece_offset, &file_index, &file_offset);
         file = &inf->files[file_index];
-        this_pass = MIN(remain, file->length - file_offset);
+        this_pass = std::min(remain, file->length - file_offset);
 
         if (urls[file_index] == nullptr)
         {

tests/libtransmission/copy-test.cc

@@ -6,6 +6,8 @@
  *
  */
 
+#include <algorithm>
+
 #include "transmission.h"
 #include "error.h"
 #include "file.h"
@@ -57,7 +59,7 @@ private:
         size_t buf_pos = 0;
         while (buf_pos < buf_len && bytes_remaining > 0)
         {
-            uint64_t const chunk_size = MIN(buf_len - buf_pos, bytes_remaining);
+            uint64_t const chunk_size = std::min(uint64_t{ buf_len - buf_pos }, bytes_remaining);
             uint64_t bytes_read = 0;
 
             tr_sys_file_read(fd, buf + buf_pos, chunk_size, &bytes_read, nullptr);