factor out includes from config.hpp into the files actually using it. primarily, printf family of functions, since C++11 version is used now. This removes the need for an snprintf-wrapper on windows (#732)

Jamfile

@@ -717,6 +717,10 @@ local usage-requirements =
 	<toolset>msvc,<variant>release:<linkflags>/OPT:ICF=5
 	<toolset>msvc,<variant>release:<linkflags>/OPT:REF
 
+	# disable bogus deprecation warnings on msvc8
+	<toolset>msvc:<define>_SCL_SECURE_NO_DEPRECATE
+	<toolset>msvc:<define>_CRT_SECURE_NO_DEPRECATE
+
 	<cxxflags>$(CXXFLAGS)
 	<linkflags>$(LDFLAGS)
 	;
@@ -743,10 +747,6 @@ lib torrent
 	<conditional>@warnings
 	<cxxflags>$(CXXFLAGS)
 
-	# disable bogus deprecation warnings on msvc8
-	<toolset>msvc:<define>_SCL_SECURE_NO_DEPRECATE
-	<toolset>msvc:<define>_CRT_SECURE_NO_DEPRECATE
-
 	<tag>@tag
 
 	$(usage-requirements)

examples/client_test.cpp

@@ -55,6 +55,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/extensions/ut_pex.hpp"
 #include "libtorrent/extensions/smart_ban.hpp"
 
+#include "libtorrent/aux_/max_path.hpp"
 #include "libtorrent/torrent_info.hpp"
 #include "libtorrent/announce_entry.hpp"
 #include "libtorrent/entry.hpp"
@@ -161,7 +162,7 @@ retry:
 
 	if (ret < 0 && errno != 0 && errno != ETIMEDOUT)
 	{
-		fprintf(stderr, "select failed: %s\n", strerror(errno));
+		std::fprintf(stderr, "select failed: %s\n", strerror(errno));
 		sleep_ms(500);
 	}
 
@@ -204,7 +205,7 @@ int load_file(std::string const& filename, std::vector<char>& v
 	, libtorrent::error_code& ec, int limit = 8000000)
 {
 	ec.clear();
-	FILE* f = fopen(filename.c_str(), "rb");
+	FILE* f = std::fopen(filename.c_str(), "rb");
 	if (f == NULL)
 	{
 		ec.assign(errno, boost::system::system_category());
@@ -215,20 +216,20 @@ int load_file(std::string const& filename, std::vector<char>& v
 	if (r != 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 	long s = ftell(f);
 	if (s < 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
 	if (s > limit)
 	{
-		fclose(f);
+		std::fclose(f);
 		return -2;
 	}
 
@@ -236,26 +237,26 @@ int load_file(std::string const& filename, std::vector<char>& v
 	if (r != 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
 	v.resize(s);
 	if (s == 0)
 	{
-		fclose(f);
+		std::fclose(f);
 		return 0;
 	}
 
-	r = int(fread(&v[0], 1, v.size(), f));
+	r = int(std::fread(&v[0], 1, v.size(), f));
 	if (r < 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
-	fclose(f);
+	std::fclose(f);
 
 	if (r != s) return -3;
 
@@ -349,10 +350,10 @@ std::string print_endpoint(libtorrent::tcp::endpoint const& ep)
 	address const& addr = ep.address();
 #if TORRENT_USE_IPV6
 	if (addr.is_v6())
-		snprintf(buf, sizeof(buf), "[%s]:%d", addr.to_string(ec).c_str(), ep.port());
+		std::snprintf(buf, sizeof(buf), "[%s]:%d", addr.to_string(ec).c_str(), ep.port());
 	else
 #endif
-		snprintf(buf, sizeof(buf), "%s:%d", addr.to_string(ec).c_str(), ep.port());
+		std::snprintf(buf, sizeof(buf), "%s:%d", addr.to_string(ec).c_str(), ep.port());
 	return buf;
 }
 
@@ -412,7 +413,7 @@ int print_peer_info(std::string& out
 
 		if (print_ip)
 		{
-			snprintf(str, sizeof(str), "%-30s ", (::print_endpoint(i->ip) +
+			std::snprintf(str, sizeof(str), "%-30s ", (::print_endpoint(i->ip) +
 				(i->flags & peer_info::utp_socket ? " [uTP]" : "") +
 				(i->flags & peer_info::i2p_socket ? " [i2p]" : "")
 				).c_str());
@@ -420,14 +421,14 @@ int print_peer_info(std::string& out
 		}
 
 		char temp[10];
-		snprintf(temp, sizeof(temp), "%d/%d"
+		std::snprintf(temp, sizeof(temp), "%d/%d"
 			, i->download_queue_length
 			, i->target_dl_queue_length);
 		temp[7] = 0;
 
 		char peer_progress[10];
-		snprintf(peer_progress, sizeof(peer_progress), "%.1f%%", i->progress_ppm / 10000.f);
+		std::snprintf(peer_progress, sizeof(peer_progress), "%.1f%%", i->progress_ppm / 10000.f);
-		snprintf(str, sizeof(str)
+		std::snprintf(str, sizeof(str)
 			, "%s %s%s (%s|%s) %s%s (%s|%s) %s%7s %4d%4d%4d %s%s%s%s%s%s%s%s%s%s%s%s%s %s%s%s %s%s%s %s%s%s%s%s%s "
 			, progress_bar(i->progress_ppm / 1000, 15, col_green, '#', '-', peer_progress).c_str()
 			, esc("32"), add_suffix(i->down_speed, "/s").c_str()
@@ -471,13 +472,13 @@ int print_peer_info(std::string& out
 
 		if (print_fails)
 		{
-			snprintf(str, sizeof(str), "%3d %3d "
+			std::snprintf(str, sizeof(str), "%3d %3d "
 				, i->failcount, i->num_hashfails);
 			out += str;
 		}
 		if (print_send_bufs)
 		{
-			snprintf(str, sizeof(str), "%2d %6d %6d%5dkB "
+			std::snprintf(str, sizeof(str), "%2d %6d %6d%5dkB "
 				, i->requests_in_buffer, i->used_send_buffer
 				, i->used_receive_buffer
 				, i->queue_bytes / 1000);
@@ -489,16 +490,16 @@ int print_peer_info(std::string& out
 			// timeout is only meaningful if there is at least one outstanding
 			// request to the peer
 			if (i->download_queue_length > 0)
-				snprintf(req_timeout, sizeof(req_timeout), "%d", i->request_timeout);
+				std::snprintf(req_timeout, sizeof(req_timeout), "%d", i->request_timeout);
 
-			snprintf(str, sizeof(str), "%8d %4d %7s %6d "
+			std::snprintf(str, sizeof(str), "%8d %4d %7s %6d "
 				, int(total_seconds(i->last_active))
 				, int(total_seconds(i->last_request))
 				, req_timeout
 				, int(total_seconds(i->download_queue_time)));
 			out += str;
 		}
-		snprintf(str, sizeof(str), "%s|%s %5d "
+		std::snprintf(str, sizeof(str), "%s|%s %5d "
 			, add_suffix(i->pending_disk_bytes).c_str()
 			, add_suffix(i->pending_disk_read_bytes).c_str()
 			, i->rtt);
@@ -509,7 +510,7 @@ int print_peer_info(std::string& out
 			if (i->downloading_piece_index >= 0)
 			{
 				char buf[50];
-				snprintf(buf, sizeof(buf), "%d:%d", i->downloading_piece_index, i->downloading_block_index);
+				std::snprintf(buf, sizeof(buf), "%d:%d", i->downloading_piece_index, i->downloading_block_index);
 				out += progress_bar(
 					i->downloading_progress * 1000 / i->downloading_total, 14, col_green, '-', '#', buf);
 			}
@@ -523,7 +524,7 @@ int print_peer_info(std::string& out
 		{
 			bool unchoked = (i->flags & peer_info::choked) == 0;
 
-			snprintf(str, sizeof(str), " %s %s"
+			std::snprintf(str, sizeof(str), " %s %s"
 				, add_suffix(i->remote_dl_rate, "/s").c_str()
 				, unchoked ? add_suffix(i->estimated_reciprocation_rate, "/s").c_str() : "      ");
 			out += str;
@@ -642,7 +643,7 @@ void print_settings(int const start, int const num
 	{
 		char const* name = libtorrent::name_for_setting(i);
 		if (!name || name[0] == '\0') continue;
-		printf(fmt, name);
+		std::printf(fmt, name);
 	}
 }
 
@@ -653,7 +654,7 @@ void add_torrent(libtorrent::session& ses
 	using namespace libtorrent;
 	static int counter = 0;
 
-	printf("[%d] %s\n", counter++, torrent.c_str());
+	std::printf("[%d] %s\n", counter++, torrent.c_str());
 
 	error_code ec;
 	add_torrent_params p;
@@ -665,7 +666,7 @@ void add_torrent(libtorrent::session& ses
 	if (!ec)
 	{
 		p = read_resume_data(&resume_data[0], int(resume_data.size()), ec);
-		if (ec) printf("  failed to load resume data: %s\n", ec.message().c_str());
+		if (ec) std::printf("  failed to load resume data: %s\n", ec.message().c_str());
 	}
 	ec.clear();
 
@@ -677,7 +678,7 @@ void add_torrent(libtorrent::session& ses
 	p.save_path = save_path;
 	p.storage_mode = (storage_mode_t)allocation_mode;
 	p.flags &= ~add_torrent_params::flag_duplicate_is_error;
-	p.userdata = (void*)strdup(torrent.c_str());
+	p.userdata = static_cast<void*>(new std::string(torrent));
 	ses.async_add_torrent(p);
 	files.insert(std::pair<const std::string, torrent_handle>(torrent, torrent_handle()));
 }
@@ -760,7 +761,7 @@ void scan_dir(std::string const& dir_path
 	std::vector<std::string> ents = list_dir(dir_path, filter_fun, ec);
 	if (ec)
 	{
-		fprintf(stderr, "failed to list directory: (%s : %d) %s\n"
+		std::fprintf(stderr, "failed to list directory: (%s : %d) %s\n"
 			, ec.category().name(), ec.value(), ec.message().c_str());
 		return;
 	}
@@ -839,17 +840,17 @@ void print_alert(libtorrent::alert const* a, std::string& str)
 	str += esc("0");
 
 	if (g_log_file)
-		fprintf(g_log_file, "[%s] %s\n", timestamp(),  a->message().c_str());
+		std::fprintf(g_log_file, "[%s] %s\n", timestamp(),  a->message().c_str());
 }
 
 int save_file(std::string const& filename, std::vector<char>& v)
 {
-	FILE* f = fopen(filename.c_str(), "wb");
+	FILE* f = std::fopen(filename.c_str(), "wb");
 	if (f == NULL)
 		return -1;
 
-	int w = int(fwrite(&v[0], 1, v.size(), f));
+	int w = int(std::fwrite(&v[0], 1, v.size(), f));
-	fclose(f);
+	std::fclose(f);
 
 	if (w < 0) return -1;
 	if (w != int(v.size())) return -3;
@@ -898,8 +899,9 @@ bool handle_alert(libtorrent::session& ses, libtorrent::alert* a
 #endif
 		{
 			char msg[256];
-			snprintf(msg, sizeof(msg), "ERROR. could not load certificate %s: %s\n", cert.c_str(), strerror(errno));
+			std::snprintf(msg, sizeof(msg), "ERROR. could not load certificate %s: %s\n"
-			if (g_log_file) fprintf(g_log_file, "[%s] %s\n", timestamp(), msg);
+				, cert.c_str(), std::strerror(errno));
+			if (g_log_file) std::fprintf(g_log_file, "[%s] %s\n", timestamp(), msg);
 			return true;
 		}
 
@@ -912,14 +914,15 @@ bool handle_alert(libtorrent::session& ses, libtorrent::alert* a
 #endif
 		{
 			char msg[256];
-			snprintf(msg, sizeof(msg), "ERROR. could not load private key %s: %s\n", priv.c_str(), strerror(errno));
+			std::snprintf(msg, sizeof(msg), "ERROR. could not load private key %s: %s\n"
-			if (g_log_file) fprintf(g_log_file, "[%s] %s\n", timestamp(), msg);
+				, priv.c_str(), std::strerror(errno));
+			if (g_log_file) std::fprintf(g_log_file, "[%s] %s\n", timestamp(), msg);
 			return true;
 		}
 
 		char msg[256];
-		snprintf(msg, sizeof(msg), "loaded certificate %s and key %s\n", cert.c_str(), priv.c_str());
+		std::snprintf(msg, sizeof(msg), "loaded certificate %s and key %s\n", cert.c_str(), priv.c_str());
-		if (g_log_file) fprintf(g_log_file, "[%s] %s\n", timestamp(), msg);
+		if (g_log_file) std::fprintf(g_log_file, "[%s] %s\n", timestamp(), msg);
 
 		h.set_ssl_certificate(cert, priv, "certificates/dhparams.pem", "1234");
 		h.resume();
@@ -974,13 +977,14 @@ bool handle_alert(libtorrent::session& ses, libtorrent::alert* a
 		std::string filename;
 		if (p->params.userdata)
 		{
-			filename = (char*)p->params.userdata;
+			std::string* f = static_cast<std::string*>(p->params.userdata);
-			free(p->params.userdata);
+			filename.swap(*f);
+			delete f;
 		}
 
 		if (p->error)
 		{
-			fprintf(stderr, "failed to add torrent: %s %s\n", filename.c_str()
+			std::fprintf(stderr, "failed to add torrent: %s %s\n", filename.c_str()
 				, p->error.message().c_str());
 		}
 		else
@@ -1064,7 +1068,7 @@ bool handle_alert(libtorrent::session& ses, libtorrent::alert* a
 		torrent_handle h = p->handle;
 		if (h.is_valid())
 		{
-			fprintf(stderr, "FAILED TO SAVE RESUME DATA: %s\n"
+			std::fprintf(stderr, "FAILED TO SAVE RESUME DATA: %s\n"
 				, h.status().name.c_str());
 		}
 		if (h.is_valid()
@@ -1107,7 +1111,7 @@ void print_piece(libtorrent::partial_piece_info* pp
 	int piece = pp ? pp->piece_index : cs->piece;
 	int num_blocks = pp ? pp->blocks_in_piece : int(cs->blocks.size());
 
-	snprintf(str, sizeof(str), "%5d:[", piece);
+	std::snprintf(str, sizeof(str), "%5d:[", piece);
 	out += str;
 	char const* last_color = 0;
 	for (int j = 0; j < num_blocks; ++j)
@@ -1143,7 +1147,7 @@ void print_piece(libtorrent::partial_piece_info* pp
 		}
 		if (last_color == 0 || strcmp(last_color, color) != 0)
 		{
-			snprintf(str, sizeof(str), "%s%c", color, chr);
+			std::snprintf(str, sizeof(str), "%s%c", color, chr);
 			out += str;
 		}
 		else
@@ -1165,7 +1169,7 @@ int main(int argc, char* argv[])
 
 	if (argc == 1)
 	{
-		fprintf(stderr, "usage: client_test [OPTIONS] [TORRENT|MAGNETURL|URL]\n\n"
+		std::fprintf(stderr, "usage: client_test [OPTIONS] [TORRENT|MAGNETURL|URL]\n\n"
 			"OPTIONS:\n"
 			"\n CLIENT OPTIONS\n"
 			"  -f <log file>         logs all events to the given file\n"
@@ -1293,7 +1297,7 @@ int main(int argc, char* argv[])
 			int const sett_name = setting_by_name(key);
 			if (sett_name < 0)
 			{
-				fprintf(stderr, "unknown setting: \"%s\"\n", key.c_str());
+				std::fprintf(stderr, "unknown setting: \"%s\"\n", key.c_str());
 				return 1;
 			}
 
@@ -1310,7 +1314,7 @@ int main(int argc, char* argv[])
 					}
 					else
 					{
-						fprintf(stderr, "invalid value for \"%s\". expected 0 or 1\n"
+						std::fprintf(stderr, "invalid value for \"%s\". expected 0 or 1\n"
 							, key.c_str());
 						return 1;
 					}
@@ -1329,7 +1333,7 @@ int main(int argc, char* argv[])
 
 		switch (argv[i][1])
 		{
-			case 'f': g_log_file = fopen(arg, "w+"); break;
+			case 'f': g_log_file = std::fopen(arg, "w+"); break;
 			case 'k': high_performance_seed(settings); --i; break;
 			case 'G': seed_mode = true; --i; break;
 			case 's': save_path = arg; break;
@@ -1345,11 +1349,12 @@ int main(int argc, char* argv[])
 				break;
 			case 'x':
 				{
-					FILE* filter = fopen(arg, "r");
+					FILE* filter = std::fopen(arg, "r");
 					if (filter)
 					{
 						unsigned int a,b,c,d,e,f,g,h, flags;
-						while (fscanf(filter, "%u.%u.%u.%u - %u.%u.%u.%u %u\n", &a, &b, &c, &d, &e, &f, &g, &h, &flags) == 9)
+						while (std::fscanf(filter, "%u.%u.%u.%u - %u.%u.%u.%u %u\n"
+							, &a, &b, &c, &d, &e, &f, &g, &h, &flags) == 9)
 						{
 							address_v4 start((a << 24) + (b << 16) + (c << 8) + d);
 							address_v4 last((e << 24) + (f << 16) + (g << 8) + h);
@@ -1357,7 +1362,7 @@ int main(int argc, char* argv[])
 							else flags = 0;
 							loaded_ip_filter.add_rule(start, last, flags);
 						}
-						fclose(filter);
+						std::fclose(filter);
 					}
 				}
 				break;
@@ -1381,7 +1386,7 @@ int main(int argc, char* argv[])
 	int ret = mkdir(path_append(save_path, ".resume").c_str(), 0777);
 #endif
 	if (ret < 0)
-		fprintf(stderr, "failed to create resume file directory: (%d) %s\n"
+		std::fprintf(stderr, "failed to create resume file directory: (%d) %s\n"
 			, errno, strerror(errno));
 
 	settings.set_str(settings_pack::user_agent, "client_test/" LIBTORRENT_VERSION);
@@ -1471,7 +1476,7 @@ int main(int argc, char* argv[])
 				if (!ec)
 				{
 					p = read_resume_data(&resume_data[0], int(resume_data.size()), ec);
-					if (ec) printf("  failed to load resume data: %s\n", ec.message().c_str());
+					if (ec) std::printf("  failed to load resume data: %s\n", ec.message().c_str());
 				}
 				ec.clear();
 			}
@@ -1483,7 +1488,7 @@ int main(int argc, char* argv[])
 			p.storage_mode = (storage_mode_t)allocation_mode;
 			p.url = *i;
 
-			printf("adding URL: %s\n", i->c_str());
+			std::printf("adding URL: %s\n", i->c_str());
 			ses.async_add_torrent(p);
 			continue;
 		}
@@ -1598,7 +1603,7 @@ int main(int argc, char* argv[])
 				{
 					char url[4096];
 					puts("Enter magnet link:\n");
-					scanf("%4095s", url);
+					std::scanf("%4095s", url);
 
 					add_torrent_params p;
 					if (std::strstr(url, "magnet:") == url)
@@ -1616,7 +1621,7 @@ int main(int argc, char* argv[])
 						if (!ec)
 						{
 							p = read_resume_data(&resume_data[0], int(resume_data.size()), ec);
-							if (ec) printf("  failed to load resume data: %s\n", ec.message().c_str());
+							if (ec) std::printf("  failed to load resume data: %s\n", ec.message().c_str());
 						}
 						ec.clear();
 					}
@@ -1628,7 +1633,7 @@ int main(int argc, char* argv[])
 					p.storage_mode = (storage_mode_t)allocation_mode;
 					p.url = url;
 
-					printf("adding URL: %s\n", url);
+					std::printf("adding URL: %s\n", url);
 					ses.async_add_torrent(p);
 				}
 
@@ -1654,10 +1659,10 @@ int main(int argc, char* argv[])
 				if (c == 'D' && h.is_valid())
 				{
 					torrent_status const& st = view.get_active_torrent();
-					printf("\n\nARE YOU SURE YOU WANT TO DELETE THE FILES FOR '%s'. THIS OPERATION CANNOT BE UNDONE. (y/N)"
+					std::printf("\n\nARE YOU SURE YOU WANT TO DELETE THE FILES FOR '%s'. THIS OPERATION CANNOT BE UNDONE. (y/N)"
 						, st.name.c_str());
 					char response = 'n';
-					scanf("%c", &response);
+					std::scanf("%c", &response);
 					if (response == 'y')
 					{
 						// also delete the .torrent file from the torrent directory
@@ -1670,7 +1675,7 @@ int main(int argc, char* argv[])
 							if (is_absolute_path(i->first)) path = i->first;
 							else path = path_append(monitor_dir, i->first);
 							if (::remove(path.c_str()) < 0)
-								printf("failed to delete .torrent file: %s\n", err.message().c_str());
+								std::printf("failed to delete .torrent file: %s\n", err.message().c_str());
 							files.erase(i);
 						}
 						if (st.handle.is_valid())
@@ -1856,7 +1861,7 @@ int main(int argc, char* argv[])
 		{
 			// TODO: 3 expose these counters as performance counters
 /*
-			snprintf(str, sizeof(str), "DHT nodes: %d DHT cached nodes: %d "
+			std::snprintf(str, sizeof(str), "DHT nodes: %d DHT cached nodes: %d "
 				"total DHT size: %" PRId64 " total observers: %d\n"
 				, sess_stat.dht_nodes, sess_stat.dht_node_cache, sess_stat.dht_global_nodes
 				, sess_stat.dht_total_allocations);
@@ -1873,7 +1878,7 @@ int main(int argc, char* argv[])
 					"################################"
 					"################################";
 				char const* short_progress_bar = "--------";
-				snprintf(str, sizeof(str)
+				std::snprintf(str, sizeof(str)
 					, "%3d [%3d, %d] %s%s\x1b[K\n"
 					, bucket, i->num_nodes, i->num_replacements
 					, progress_bar + (128 - i->num_nodes)
@@ -1885,7 +1890,7 @@ int main(int argc, char* argv[])
 			for (std::vector<dht_lookup>::iterator i = dht_active_requests.begin()
 				, end(dht_active_requests.end()); i != end; ++i)
 			{
-				snprintf(str, sizeof(str)
+				std::snprintf(str, sizeof(str)
 					, "  %10s [limit: %2d] "
 					"in-flight: %-2d "
 					"left: %-3d "
@@ -1928,7 +1933,7 @@ int main(int argc, char* argv[])
 					, end(tr.end()); i != end; ++i)
 				{
 					if (pos + 1 >= terminal_height) break;
-					snprintf(str, sizeof(str), "%2d %-55s fails: %-3d (%-3d) %s %s %5d \"%s\" %s\x1b[K\n"
+					std::snprintf(str, sizeof(str), "%2d %-55s fails: %-3d (%-3d) %s %s %5d \"%s\" %s\x1b[K\n"
 						, i->tier, i->url.c_str(), i->fails, i->fail_limit, i->verified?"OK ":"-  "
 						, i->updating?"updating"
 							:to_string(int(total_seconds(i->next_announce - now)), 8).c_str()
@@ -2026,7 +2031,7 @@ int main(int argc, char* argv[])
 					pos += 1;
 				}
 
-				snprintf(str, sizeof(str), "%s %s read cache | %s %s downloading | %s %s cached | %s %s flushed | %s %s snubbed\x1b[K\n"
+				std::snprintf(str, sizeof(str), "%s %s read cache | %s %s downloading | %s %s cached | %s %s flushed | %s %s snubbed\x1b[K\n"
 					, esc("34;7"), esc("0") // read cache
 					, esc("33;7"), esc("0") // downloading
 					, esc("36;7"), esc("0") // cached
@@ -2057,7 +2062,7 @@ int main(int argc, char* argv[])
 					{
 						if (show_pad_files)
 						{
-							snprintf(str, sizeof(str), "\x1b[34m%-70s %s\x1b[0m\x1b[K\n"
+							std::snprintf(str, sizeof(str), "\x1b[34m%-70s %s\x1b[0m\x1b[K\n"
 								, ti->files().file_name(i).c_str()
 								, add_suffix(ti->files().file_size(i)).c_str());
 							out += str;
@@ -2074,7 +2079,7 @@ int main(int argc, char* argv[])
 					std::string title = ti->files().file_name(i);
 					if (!complete)
 					{
-						snprintf(str, sizeof(str), " (%.1f%%)", progress / 10.f);
+						std::snprintf(str, sizeof(str), " (%.1f%%)", progress / 10.f);
 						title += str;
 					}
 
@@ -2101,7 +2106,7 @@ int main(int argc, char* argv[])
 						p = 0;
 					}
 
-					snprintf(str, sizeof(str), "%s %7s p: %d ",
+					std::snprintf(str, sizeof(str), "%s %7s p: %d ",
 						progress_bar(progress, file_progress_width, complete ? col_green : col_yellow, '-', '#'
 							, title.c_str()).c_str()
 						, add_suffix(file_progress[i]).c_str()
@@ -2146,7 +2151,7 @@ int main(int argc, char* argv[])
 	}
 
 	ses.pause();
-	printf("saving resume data\n");
+	std::printf("saving resume data\n");
 	std::vector<torrent_status> temp;
 	ses.get_torrent_status(&temp, &yes, 0);
 	for (std::vector<torrent_status>::iterator i = temp.begin();
@@ -2155,26 +2160,26 @@ int main(int argc, char* argv[])
 		torrent_status& st = *i;
 		if (!st.handle.is_valid())
 		{
-			printf("  skipping, invalid handle\n");
+			std::printf("  skipping, invalid handle\n");
 			continue;
 		}
 		if (!st.has_metadata)
 		{
-			printf("  skipping %s, no metadata\n", st.name.c_str());
+			std::printf("  skipping %s, no metadata\n", st.name.c_str());
 			continue;
 		}
 		if (!st.need_save_resume)
 		{
-			printf("  skipping %s, resume file up-to-date\n", st.name.c_str());
+			std::printf("  skipping %s, resume file up-to-date\n", st.name.c_str());
 			continue;
 		}
 
 		// save_resume_data will generate an alert when it's done
 		st.handle.save_resume_data();
 		++num_outstanding_resume_data;
-		printf("\r%d  ", num_outstanding_resume_data);
+		std::printf("\r%d  ", num_outstanding_resume_data);
 	}
-	printf("\nwaiting for resume data [%d]\n", num_outstanding_resume_data);
+	std::printf("\nwaiting for resume data [%d]\n", num_outstanding_resume_data);
 
 	while (num_outstanding_resume_data > 0)
 	{
@@ -2196,11 +2201,11 @@ int main(int argc, char* argv[])
 		}
 	}
 
-	if (g_log_file) fclose(g_log_file);
+	if (g_log_file) std::fclose(g_log_file);
 
 	// we're just saving the DHT state
 #ifndef TORRENT_DISABLE_DHT
-	printf("\nsaving session state\n");
+	std::printf("\nsaving session state\n");
 	{
 		entry session_state;
 		ses.save_state(session_state, session::save_dht_state);
@@ -2211,7 +2216,7 @@ int main(int argc, char* argv[])
 	}
 #endif
 
-	printf("closing session");
+	std::printf("closing session");
 
 	return 0;
 }

examples/connection_tester.cpp

@@ -420,7 +420,7 @@ struct peer_conn
 	{
 		end_time = clock_type::now();
 		char tmp[1024];
-		snprintf(tmp, sizeof(tmp), fmt, ec.message().c_str());
+		std::snprintf(tmp, sizeof(tmp), fmt, ec.message().c_str());
 		int time = int(total_milliseconds(end_time - start_time));
 		if (time == 0) time = 1;
 		float up = (boost::int64_t(blocks_sent) * 0x4000) / time / 1000.f;
@@ -431,13 +431,13 @@ struct peer_conn
 		address const& addr = s.local_endpoint(e).address();
 #if TORRENT_USE_IPV6
 		if (addr.is_v6())
-			snprintf(ep_str, sizeof(ep_str), "[%s]:%d", addr.to_string(e).c_str()
+			std::snprintf(ep_str, sizeof(ep_str), "[%s]:%d", addr.to_string(e).c_str()
 				, s.local_endpoint(e).port());
 		else
 #endif
-			snprintf(ep_str, sizeof(ep_str), "%s:%d", addr.to_string(e).c_str()
+			std::snprintf(ep_str, sizeof(ep_str), "%s:%d", addr.to_string(e).c_str()
 				, s.local_endpoint(e).port());
-		printf("%s ep: %s sent: %d received: %d duration: %d ms up: %.1fMB/s down: %.1fMB/s\n"
+		std::printf("%s ep: %s sent: %d received: %d duration: %d ms up: %.1fMB/s down: %.1fMB/s\n"
 			, tmp, ep_str, blocks_sent, blocks_received, time, up, down);
 		if (seed) --num_seeds;
 	}
@@ -483,7 +483,7 @@ struct peer_conn
 		unsigned int length = read_uint32(ptr);
 		if (length > sizeof(buffer))
 		{
-			fprintf(stderr, "len: %d\n", length);
+			std::fprintf(stderr, "len: %d\n", length);
 			close("ERROR RECEIVE MESSAGE PREFIX: packet too big", error_code());
 			return;
 		}
@@ -515,7 +515,7 @@ struct peer_conn
 			return;
 		}
 
-		//printf("msg: %d len: %d\n", msg, int(bytes_transferred));
+		//std::printf("msg: %d len: %d\n", msg, int(bytes_transferred));
 
 		if (seed)
 		{
@@ -637,7 +637,7 @@ struct peer_conn
 					}
 				}
 				--outstanding_requests;
-				fprintf(stderr, "REJECT: [ piece: %d start: %d length: %d ]\n", piece, start, length);
+				std::fprintf(stderr, "REJECT: [ piece: %d start: %d length: %d ]\n", piece, start, length);
 			}
 			else if (msg == 0) // choke
 			{
@@ -669,7 +669,7 @@ struct peer_conn
 		{
 			if (buf[i] != fill)
 			{
-				fprintf(stderr, "received invalid block. piece %d block %d\n", piece, start / 0x4000);
+				std::fprintf(stderr, "received invalid block. piece %d block %d\n", piece, start / 0x4000);
 				exit(1);
 			}
 		}
@@ -719,7 +719,7 @@ struct peer_conn
 
 void print_usage()
 {
-	fprintf(stderr, "usage: connection_tester command [options]\n\n"
+	std::fprintf(stderr, "usage: connection_tester command [options]\n\n"
 		"command is one of:\n"
 		"  gen-torrent        generate a test torrent\n"
 		"    options for this command:\n"
@@ -757,7 +757,7 @@ void print_usage()
 
 void hasher_thread(libtorrent::create_torrent* t, int start_piece, int end_piece, int piece_size, bool print)
 {
-	if (print) fprintf(stderr, "\n");
+	if (print) std::fprintf(stderr, "\n");
 	boost::uint32_t piece[0x4000 / 4];
 	for (int i = start_piece; i < end_piece; ++i)
 	{
@@ -768,9 +768,9 @@ void hasher_thread(libtorrent::create_torrent* t, int start_piece, int end_piece
 			ph.update((char*)piece, 0x4000);
 		}
 		t->set_hash(i, ph.final());
-		if (print && (i & 1)) fprintf(stderr, "\r%.1f %% ", float((i-start_piece) * 100) / float(end_piece-start_piece));
+		if (print && (i & 1)) std::fprintf(stderr, "\r%.1f %% ", float((i-start_piece) * 100) / float(end_piece-start_piece));
 	}
-	if (print) fprintf(stderr, "\n");
+	if (print) std::fprintf(stderr, "\n");
 }
 
 // size is in megabytes
@@ -789,7 +789,7 @@ void generate_torrent(std::vector<char>& buf, int size, int num_files
 	while (s > 0)
 	{
 		char b[100];
-		snprintf(b, sizeof(b), "%s/stress_test%d", torrent_name, i);
+		std::snprintf(b, sizeof(b), "%s/stress_test%d", torrent_name, i);
 		++i;
 		fs.add_file(b, (std::min)(s, boost::int64_t(file_size)));
 		s -= file_size;
@@ -845,9 +845,9 @@ void generate_data(char const* path, torrent_info const& ti)
 			storage_error error;
 			st->writev(&b, 1, i, j, 0, error);
 			if (error)
-				fprintf(stderr, "storage error: %s\n", error.ec.message().c_str());
+				std::fprintf(stderr, "storage error: %s\n", error.ec.message().c_str());
 		}
-		if (i & 1) fprintf(stderr, "\r%.1f %% ", float(i * 100) / float(ti.num_pieces()));
+		if (i & 1) std::fprintf(stderr, "\r%.1f %% ", float(i * 100) / float(ti.num_pieces()));
 	}
 }
 
@@ -855,7 +855,7 @@ void io_thread(io_service* ios)
 {
 	error_code ec;
 	ios->run(ec);
-	if (ec) fprintf(stderr, "ERROR: %s\n", ec.message().c_str());
+	if (ec) std::fprintf(stderr, "ERROR: %s\n", ec.message().c_str());
 }
 
 int main(int argc, char* argv[])
@@ -884,7 +884,7 @@ int main(int argc, char* argv[])
 
 		if (optname[0] != '-' || strlen(optname) != 2)
 		{
-			fprintf(stderr, "unknown option: %s\n", optname);
+			std::fprintf(stderr, "unknown option: %s\n", optname);
 			continue;
 		}
 
@@ -896,7 +896,7 @@ int main(int argc, char* argv[])
 
 		if (argc == 0)
 		{
-			fprintf(stderr, "missing argument for option: %s\n", optname);
+			std::fprintf(stderr, "missing argument for option: %s\n", optname);
 			break;
 		}
 
@@ -915,7 +915,7 @@ int main(int argc, char* argv[])
 			case 'p': destination_port = atoi(optarg); break;
 			case 'd': destination_ip = optarg; break;
 			case 'r': churn = atoi(optarg); break;
-			default: fprintf(stderr, "unknown option: %s\n", optname);
+			default: std::fprintf(stderr, "unknown option: %s\n", optname);
 		}
 	}
 
@@ -924,23 +924,24 @@ int main(int argc, char* argv[])
 		std::vector<char> tmp;
 		std::string name = leaf_path(torrent_file);
 		name = name.substr(0, name.find_last_of('.'));
-		printf("generating torrent: %s\n", name.c_str());
+		std::printf("generating torrent: %s\n", name.c_str());
 		generate_torrent(tmp, size ? size : 1024, num_files ? num_files : 1
 			, name.c_str());
 
 		FILE* output = stdout;
 		if (strcmp("-", torrent_file) != 0)
 		{
-			if( (output = fopen(torrent_file, "wb+")) == 0)
+			if( (output = std::fopen(torrent_file, "wb+")) == 0)
 			{
-				fprintf(stderr, "Could not open file '%s' for writing: %s\n", torrent_file, strerror(errno));
+				std::fprintf(stderr, "Could not open file '%s' for writing: %s\n"
+					, torrent_file, std::strerror(errno));
 				exit(2);
 			}
 		}
-		fprintf(stderr, "writing file to: %s\n", torrent_file);
+		std::fprintf(stderr, "writing file to: %s\n", torrent_file);
 		fwrite(&tmp[0], 1, tmp.size(), output);
 		if (output != stdout)
-			fclose(output);
+			std::fclose(output);
 
 		return 0;
 	}
@@ -950,7 +951,7 @@ int main(int argc, char* argv[])
 		torrent_info ti(torrent_file, ec);
 		if (ec)
 		{
-			fprintf(stderr, "ERROR LOADING .TORRENT: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "ERROR LOADING .TORRENT: %s\n", ec.message().c_str());
 			return 1;
 		}
 		generate_data(data_path, ti);
@@ -962,13 +963,13 @@ int main(int argc, char* argv[])
 		for (int i = 0; i < num_torrents; ++i)
 		{
 			char torrent_name[100];
-			snprintf(torrent_name, sizeof(torrent_name), "%s-%d.torrent", torrent_file, i);
+			std::snprintf(torrent_name, sizeof(torrent_name), "%s-%d.torrent", torrent_file, i);
 
 			file_storage fs;
 			for (int j = 0; j < num_files; ++j)
 			{
 				char file_name[100];
-				snprintf(file_name, sizeof(file_name), "%s-%d/file-%d", torrent_file, i, j);
+				std::snprintf(file_name, sizeof(file_name), "%s-%d/file-%d", torrent_file, i, j);
 				fs.add_file(file_name, boost::int64_t(j + i + 1) * 251);
 			}
 			// 1 MiB piece size
@@ -982,21 +983,22 @@ int main(int argc, char* argv[])
 			buf.clear();
 			std::back_insert_iterator<std::vector<char> > out(buf);
 			bencode(out, t.generate());
-			FILE* f = fopen(torrent_name, "w+");
+			FILE* f = std::fopen(torrent_name, "w+");
 			if (f == 0)
 			{
-				fprintf(stderr, "Could not open file '%s' for writing: %s\n", torrent_name, strerror(errno));
+				std::fprintf(stderr, "Could not open file '%s' for writing: %s\n"
+					, torrent_name, std::strerror(errno));
 				return 1;
 			}
 			size_t ret = fwrite(&buf[0], 1, buf.size(), f);
 			if (ret != buf.size())
 			{
-				fprintf(stderr, "write returned: %d (expected %d)\n", int(ret), int(buf.size()));
+				std::fprintf(stderr, "write returned: %d (expected %d)\n", int(ret), int(buf.size()));
-				fclose(f);
+				std::fclose(f);
 				return 1;
 			}
-			printf("wrote %s\n", torrent_name);
+			std::printf("wrote %s\n", torrent_name);
-			fclose(f);
+			std::fclose(f);
 		}
 		return 0;
 	}
@@ -1014,7 +1016,7 @@ int main(int argc, char* argv[])
 	}
 	else
 	{
-		fprintf(stderr, "unknown command: %s\n\n", command);
+		std::fprintf(stderr, "unknown command: %s\n\n", command);
 		print_usage();
 	}
 
@@ -1022,7 +1024,7 @@ int main(int argc, char* argv[])
 	address_v4 addr = address_v4::from_string(destination_ip, ec);
 	if (ec)
 	{
-		fprintf(stderr, "ERROR RESOLVING %s: %s\n", destination_ip, ec.message().c_str());
+		std::fprintf(stderr, "ERROR RESOLVING %s: %s\n", destination_ip, ec.message().c_str());
 		return 1;
 	}
 	tcp::endpoint ep(addr, boost::uint16_t(destination_port));
@@ -1040,7 +1042,7 @@ int main(int argc, char* argv[])
 	torrent_info ti(torrent_file, ec);
 	if (ec)
 	{
-		fprintf(stderr, "ERROR LOADING .TORRENT: %s\n", ec.message().c_str());
+		std::fprintf(stderr, "ERROR LOADING .TORRENT: %s\n", ec.message().c_str());
 		return 1;
 	}
 
@@ -1060,7 +1062,7 @@ int main(int argc, char* argv[])
 		ios[i % num_threads].poll_one(ec);
 		if (ec)
 		{
-			fprintf(stderr, "ERROR: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "ERROR: %s\n", ec.message().c_str());
 			break;
 		}
 	}
@@ -1088,7 +1090,7 @@ int main(int argc, char* argv[])
 		delete p;
 	}
 
-	printf("=========================\n"
+	std::printf("=========================\n"
 		"suggests: %d suggested-requests: %d\n"
 		"total sent: %.1f %% received: %.1f %%\n"
 		"rate sent: %.1f MB/s received: %.1f MB/s\n"

examples/dump_torrent.cpp

@@ -30,6 +30,9 @@ POSSIBILITY OF SUCH DAMAGE.
 
 */
 
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
+
 #include "libtorrent/entry.hpp"
 #include "libtorrent/bencode.hpp"
 #include "libtorrent/torrent_info.hpp"
@@ -41,7 +44,7 @@ int load_file(std::string const& filename, std::vector<char>& v
 	, libtorrent::error_code& ec, int limit = 8000000)
 {
 	ec.clear();
-	FILE* f = fopen(filename.c_str(), "rb");
+	FILE* f = std::fopen(filename.c_str(), "rb");
 	if (f == NULL)
 	{
 		ec.assign(errno, boost::system::system_category());
@@ -52,20 +55,20 @@ int load_file(std::string const& filename, std::vector<char>& v
 	if (r != 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 	long s = ftell(f);
 	if (s < 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
 	if (s > limit)
 	{
-		fclose(f);
+		std::fclose(f);
 		return -2;
 	}
 
@@ -73,14 +76,14 @@ int load_file(std::string const& filename, std::vector<char>& v
 	if (r != 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
 	v.resize(s);
 	if (s == 0)
 	{
-		fclose(f);
+		std::fclose(f);
 		return 0;
 	}
 
@@ -88,11 +91,11 @@ int load_file(std::string const& filename, std::vector<char>& v
 	if (r < 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
-	fclose(f);
+	std::fclose(f);
 
 	if (r != s) return -3;
 
@@ -120,41 +123,41 @@ int main(int argc, char* argv[])
 	int ret = load_file(argv[1], buf, ec, 40 * 1000000);
 	if (ret == -1)
 	{
-		fprintf(stderr, "file too big, aborting\n");
+		std::fprintf(stderr, "file too big, aborting\n");
 		return 1;
 	}
 
 	if (ret != 0)
 	{
-		fprintf(stderr, "failed to load file: %s\n", ec.message().c_str());
+		std::fprintf(stderr, "failed to load file: %s\n", ec.message().c_str());
 		return 1;
 	}
 	bdecode_node e;
 	int pos = -1;
-	printf("decoding. recursion limit: %d total item count limit: %d\n"
+	std::printf("decoding. recursion limit: %d total item count limit: %d\n"
 		, depth_limit, item_limit);
 	ret = bdecode(&buf[0], &buf[0] + buf.size(), e, ec, &pos
 		, depth_limit, item_limit);
 
-	printf("\n\n----- raw info -----\n\n%s\n", print_entry(e).c_str());
+	std::printf("\n\n----- raw info -----\n\n%s\n", print_entry(e).c_str());
 
 	if (ret != 0)
 	{
-		fprintf(stderr, "failed to decode: '%s' at character: %d\n", ec.message().c_str(), pos);
+		std::fprintf(stderr, "failed to decode: '%s' at character: %d\n", ec.message().c_str(), pos);
 		return 1;
 	}
 
 	torrent_info t(e, ec);
 	if (ec)
 	{
-		fprintf(stderr, "%s\n", ec.message().c_str());
+		std::fprintf(stderr, "%s\n", ec.message().c_str());
 		return 1;
 	}
 	e.clear();
 	std::vector<char>().swap(buf);
 
 	// print info about torrent
-	printf("\n\n----- torrent file info -----\n\n"
+	std::printf("\n\n----- torrent file info -----\n\n"
 		"nodes:\n");
 
 	typedef std::vector<std::pair<std::string, int> > node_vec;
@@ -162,18 +165,18 @@ int main(int argc, char* argv[])
 	for (node_vec::const_iterator i = nodes.begin(), end(nodes.end());
 		i != end; ++i)
 	{
-		printf("%s: %d\n", i->first.c_str(), i->second);
+		std::printf("%s: %d\n", i->first.c_str(), i->second);
 	}
 	puts("trackers:\n");
 	for (std::vector<announce_entry>::const_iterator i = t.trackers().begin();
 		i != t.trackers().end(); ++i)
 	{
-		printf("%2d: %s\n", i->tier, i->url.c_str());
+		std::printf("%2d: %s\n", i->tier, i->url.c_str());
 	}
 
 	char ih[41];
 	to_hex((char const*)&t.info_hash()[0], 20, ih);
-	printf("number of pieces: %d\n"
+	std::printf("number of pieces: %d\n"
 		"piece length: %d\n"
 		"info hash: %s\n"
 		"comment: %s\n"
@@ -196,7 +199,7 @@ int main(int argc, char* argv[])
 		int first = st.map_file(i, 0, 0).piece;
 		int last = st.map_file(i, (std::max)(boost::int64_t(st.file_size(i))-1, boost::int64_t(0)), 0).piece;
 		int flags = st.file_flags(i);
-		printf(" %8" PRIx64 " %11" PRId64 " %c%c%c%c [ %5d, %5d ] %7u %s %s %s%s\n"
+		std::printf(" %8" PRIx64 " %11" PRId64 " %c%c%c%c [ %5d, %5d ] %7u %s %s %s%s\n"
 			, st.file_offset(i)
 			, st.file_size(i)
 			, ((flags & file_storage::flag_pad_file)?'p':'-')

examples/make_torrent.cpp

@@ -40,8 +40,10 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/file.hpp"
 #include "libtorrent/file_pool.hpp"
 #include "libtorrent/hex.hpp" // for from_hex
+#include "libtorrent/aux_/max_path.hpp" // for TORRENT_MAX_PATH
 
 #include <functional>
+#include <cstdio>
 
 #ifdef TORRENT_WINDOWS
 #include <direct.h> // for _getcwd
@@ -53,7 +55,7 @@ using namespace std::placeholders;
 int load_file(std::string const& filename, std::vector<char>& v, libtorrent::error_code& ec, int limit = 8000000)
 {
 	ec.clear();
-	FILE* f = fopen(filename.c_str(), "rb");
+	FILE* f = std::fopen(filename.c_str(), "rb");
 	if (f == NULL)
 	{
 		ec.assign(errno, boost::system::system_category());
@@ -64,20 +66,20 @@ int load_file(std::string const& filename, std::vector<char>& v, libtorrent::err
 	if (r != 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 	long s = ftell(f);
 	if (s < 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
 	if (s > limit)
 	{
-		fclose(f);
+		std::fclose(f);
 		return -2;
 	}
 
@@ -85,14 +87,14 @@ int load_file(std::string const& filename, std::vector<char>& v, libtorrent::err
 	if (r != 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
 	v.resize(s);
 	if (s == 0)
 	{
-		fclose(f);
+		std::fclose(f);
 		return 0;
 	}
 
@@ -100,11 +102,11 @@ int load_file(std::string const& filename, std::vector<char>& v, libtorrent::err
 	if (r < 0)
 	{
 		ec.assign(errno, boost::system::system_category());
-		fclose(f);
+		std::fclose(f);
 		return -1;
 	}
 
-	fclose(f);
+	std::fclose(f);
 
 	if (r != s) return -3;
 
@@ -155,13 +157,13 @@ bool file_filter(std::string const& f)
 	// return false if the first character of the filename is a .
 	if (sep[0] == '.') return false;
 
-	fprintf(stderr, "%s\n", f.c_str());
+	std::fprintf(stderr, "%s\n", f.c_str());
 	return true;
 }
 
 void print_progress(int i, int num)
 {
-	fprintf(stderr, "\r%d/%d", i+1, num);
+	std::fprintf(stderr, "\r%d/%d", i+1, num);
 }
 
 void print_usage()
@@ -300,7 +302,7 @@ int main(int argc, char* argv[])
 					++i;
 					if (strlen(argv[i]) != 40)
 					{
-						fprintf(stderr, "invalid info-hash for -S. "
+						std::fprintf(stderr, "invalid info-hash for -S. "
 							"Expected 40 hex characters\n");
 						print_usage();
 						return 1;
@@ -308,7 +310,7 @@ int main(int argc, char* argv[])
 					sha1_hash ih;
 					if (!from_hex(argv[i], 40, (char*)&ih[0]))
 					{
-						fprintf(stderr, "invalid info-hash for -S\n");
+						std::fprintf(stderr, "invalid info-hash for -S\n");
 						print_usage();
 						return 1;
 					}
@@ -373,11 +375,11 @@ int main(int argc, char* argv[])
 			, std::bind(&print_progress, _1, t.num_pieces()), ec);
 		if (ec)
 		{
-			fprintf(stderr, "%s\n", ec.message().c_str());
+			std::fprintf(stderr, "%s\n", ec.message().c_str());
 			return 1;
 		}
 
-		fprintf(stderr, "\n");
+		std::fprintf(stderr, "\n");
 		t.set_creator(creator_str.c_str());
 		if (!comment_str.empty())
 			t.set_comment(comment_str.c_str());
@@ -388,7 +390,7 @@ int main(int argc, char* argv[])
 			load_file(root_cert, pem, ec, 10000);
 			if (ec)
 			{
-				fprintf(stderr, "failed to load root certificate for tracker: %s\n", ec.message().c_str());
+				std::fprintf(stderr, "failed to load root certificate for tracker: %s\n", ec.message().c_str());
 			}
 			else
 			{
@@ -401,41 +403,41 @@ int main(int argc, char* argv[])
 		bencode(back_inserter(torrent), t.generate());
 		FILE* output = stdout;
 		if (!outfile.empty())
-			output = fopen(outfile.c_str(), "wb+");
+			output = std::fopen(outfile.c_str(), "wb+");
 		if (output == NULL)
 		{
-			fprintf(stderr, "failed to open file \"%s\": (%d) %s\n"
+			std::fprintf(stderr, "failed to open file \"%s\": (%d) %s\n"
-				, outfile.c_str(), errno, strerror(errno));
+				, outfile.c_str(), errno, std::strerror(errno));
 			return 1;
 		}
 		fwrite(&torrent[0], 1, torrent.size(), output);
 
 		if (output != stdout)
-			fclose(output);
+			std::fclose(output);
 
 		if (!merklefile.empty())
 		{
-			output = fopen(merklefile.c_str(), "wb+");
+			output = std::fopen(merklefile.c_str(), "wb+");
 			if (output == NULL)
 			{
-				fprintf(stderr, "failed to open file \"%s\": (%d) %s\n"
+				std::fprintf(stderr, "failed to open file \"%s\": (%d) %s\n"
-					, merklefile.c_str(), errno, strerror(errno));
+					, merklefile.c_str(), errno, std::strerror(errno));
 				return 1;
 			}
 			int ret = int(fwrite(&t.merkle_tree()[0], 20, t.merkle_tree().size(), output));
 			if (ret != int(t.merkle_tree().size()))
 			{
-				fprintf(stderr, "failed to write %s: (%d) %s\n"
+				std::fprintf(stderr, "failed to write %s: (%d) %s\n"
-					, merklefile.c_str(), errno, strerror(errno));
+					, merklefile.c_str(), errno, std::strerror(errno));
 			}
-			fclose(output);
+			std::fclose(output);
 		}
 
 #ifndef BOOST_NO_EXCEPTIONS
 	}
 	catch (std::exception& e)
 	{
-		fprintf(stderr, "%s\n", e.what());
+		std::fprintf(stderr, "%s\n", e.what());
 	}
 #endif
 

examples/print.cpp

@@ -44,7 +44,7 @@ char const* esc(char const* code)
 std::string to_string(int v, int width)
 {
 	char buf[100];
-	snprintf(buf, sizeof(buf), "%*d", width, v);
+	std::snprintf(buf, sizeof(buf), "%*d", width, v);
 	return buf;
 }
 
@@ -67,7 +67,7 @@ std::string add_suffix_float(float val, char const* suffix)
 		if (std::fabs(val) < 1000.f) break;
 	}
 	char ret[100];
-	snprintf(ret, sizeof(ret), "%4.*f%s%s", val < 99 ? 1 : 0, val, prefix[i], suffix ? suffix : "");
+	std::snprintf(ret, sizeof(ret), "%4.*f%s%s", val < 99 ? 1 : 0, val, prefix[i], suffix ? suffix : "");
 	return ret;
 }
 
@@ -77,7 +77,7 @@ std::string color(std::string const& s, color_code c)
 	if (std::count(s.begin(), s.end(), ' ') == int(s.size())) return s;
 
 	char buf[1024];
-	snprintf(buf, sizeof(buf), "\x1b[3%dm%s\x1b[39m", c, s.c_str());
+	std::snprintf(buf, sizeof(buf), "\x1b[3%dm%s\x1b[39m", c, s.c_str());
 	return buf;
 }
 
@@ -93,7 +93,7 @@ std::string const& progress_bar(int progress, int width, color_code c
 	if (caption.empty())
 	{
 		char code[10];
-		snprintf(code, sizeof(code), "\x1b[3%dm", c);
+		std::snprintf(code, sizeof(code), "\x1b[3%dm", c);
 		bar = code;
 		std::fill_n(std::back_inserter(bar), progress_chars, fill);
 		std::fill_n(std::back_inserter(bar), width - progress_chars, bg);
@@ -116,11 +116,11 @@ std::string const& progress_bar(int progress, int width, color_code c
 
 		char str[256];
 		if (flags & progress_invert)
-			snprintf(str, sizeof(str), "\x1b[%sm\x1b[37m%s\x1b[4%d;3%dm%s\x1b[49;39m"
+			std::snprintf(str, sizeof(str), "\x1b[%sm\x1b[37m%s\x1b[4%d;3%dm%s\x1b[49;39m"
 				, background, caption.substr(0, progress_chars).c_str(), c, tc
 				, caption.substr(progress_chars).c_str());
 		else
-			snprintf(str, sizeof(str), "\x1b[4%d;3%dm%s\x1b[%sm\x1b[37m%s\x1b[49;39m"
+			std::snprintf(str, sizeof(str), "\x1b[4%d;3%dm%s\x1b[%sm\x1b[37m%s\x1b[49;39m"
 				, c, tc, caption.substr(0, progress_chars).c_str(), background
 				, caption.substr(progress_chars).c_str());
 		bar = str;
@@ -186,7 +186,7 @@ std::string const& piece_bar(libtorrent::bitfield const& p, int width)
 				if (color[i] != last_color[i])
 				{
 					char buf[40];
-					snprintf(buf, sizeof(buf), "\x1b[%d;5;%dm", bg[i & 1], 232 + color[i]);
+					std::snprintf(buf, sizeof(buf), "\x1b[%d;5;%dm", bg[i & 1], 232 + color[i]);
 					last_color[i] = color[i];
 					bar += buf;
 				}
@@ -299,7 +299,7 @@ void set_cursor_pos(int x, int y)
 	COORD c = {SHORT(x), SHORT(y)};
 	SetConsoleCursorPosition(out, c);
 #else
-	printf("\033[%d;%dH", y + 1, x + 1);
+	std::printf("\033[%d;%dH", y + 1, x + 1);
 #endif
 }
 
@@ -315,7 +315,7 @@ void clear_screen()
 	FillConsoleOutputCharacter(out, ' ', si.dwSize.X * si.dwSize.Y, c, &n);
 	FillConsoleOutputAttribute(out, 0x7, si.dwSize.X * si.dwSize.Y, c, &n);
 #else
-	printf("\033[2J");
+	std::printf("\033[2J");
 #endif
 }
 
@@ -336,7 +336,7 @@ void clear_rows(int y1, int y2)
 	FillConsoleOutputAttribute(out, 0x7, num_chars, c, &n);
 #else
 	for (int i = y1; i < y2; ++i)
-		printf("\033[%d;1H\033[2K", i + 1);
+		std::printf("\033[%d;1H\033[2K", i + 1);
 #endif
 }
 

examples/print.hpp

@@ -2,6 +2,8 @@
 #define PRINT_HPP_
 
 #include <string>
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
 #include "libtorrent/bitfield.hpp"
 
 enum color_code

examples/session_view.cpp

@@ -75,7 +75,7 @@ void session_view::render()
 	int upload_rate = int((m_cnt[0][m_sent_payload_idx] - m_cnt[1][m_sent_payload_idx])
 		/ seconds);
 
-	pos += snprintf(str, sizeof(str), "%s%s fail: %s down: %s (%s) "
+	pos += std::snprintf(str, sizeof(str), "%s%s fail: %s down: %s (%s) "
 		"  bw queue: %s | %s conns: %3d  unchoked: %2d / %2d "
 		"                                      %s\x1b[K"
 		, esc("48;5;238")
@@ -93,7 +93,7 @@ void session_view::render()
 	set_cursor_pos(0, y++);
 	print(str);
 
-	snprintf(str, sizeof(str), "%s%swaste: %s   up: %s (%s) "
+	std::snprintf(str, sizeof(str), "%s%swaste: %s   up: %s (%s) "
 		"disk queue: %s | %s cache w: %3d%% r: %3d%% "
 		"size: w: %s r: %s total: %s       %s\x1b[K"
 #ifdef _WIN32
@@ -119,7 +119,7 @@ void session_view::render()
 	print(str);
 
 /*
-	snprintf(str, sizeof(str), "| timing - "
+	std::snprintf(str, sizeof(str), "| timing - "
 		" read: %6d ms | write: %6d ms | hash: %6d"
 		, cs.average_read_time / 1000, cs.average_write_time / 1000
 		, cs.average_hash_time / 1000);
@@ -127,7 +127,7 @@ void session_view::render()
 	set_cursor_pos(0, y++);
 	print(str);
 
-	snprintf(str, sizeof(str), "| jobs   - queued: %4d (%4d) pending: %4d blocked: %4d "
+	std::snprintf(str, sizeof(str), "| jobs   - queued: %4d (%4d) pending: %4d blocked: %4d "
 		"queued-bytes: %5" PRId64 " kB"
 		, cs.queued_jobs, cs.peak_queued, cs.pending_jobs, cs.blocked_jobs
 		, m_cnt[0][m_queued_bytes_idx] / 1000);
@@ -135,7 +135,7 @@ void session_view::render()
 	set_cursor_pos(0, y++);
 	print(str);
 
-	snprintf(str, sizeof(str), "|  cache  - total: %4d read: %4d write: %4d pinned: %4d write-queue: %4d"
+	std::snprintf(str, sizeof(str), "|  cache  - total: %4d read: %4d write: %4d pinned: %4d write-queue: %4d"
 		, cs.read_cache_size + cs.write_cache_size, cs.read_cache_size
 		, cs.write_cache_size, cs.pinned_blocks
 		, int(m_cnt[0][m_queued_bytes_idx] / 0x4000));
@@ -147,38 +147,38 @@ void session_view::render()
 	int arc_size = mru_size + mfu_size;
 
 	char mru_caption[100];
-	snprintf(mru_caption, sizeof(mru_caption), "MRU: %d (%d)"
+	std::snprintf(mru_caption, sizeof(mru_caption), "MRU: %d (%d)"
 		, int(m_cnt[0][m_mru_size_idx]), int(m_cnt[0][m_mru_ghost_idx]));
 	char mfu_caption[100];
-	snprintf(mfu_caption, sizeof(mfu_caption), "MFU: %d (%d)"
+	std::snprintf(mfu_caption, sizeof(mfu_caption), "MFU: %d (%d)"
 		, int(m_cnt[0][m_mfu_size_idx]), int(m_cnt[0][m_mfu_ghost_idx]));
 
-	pos = snprintf(str, sizeof(str), "cache: ");
+	pos = std::snprintf(str, sizeof(str), "cache: ");
 	if (arc_size > 0)
 	{
 		if (mru_size > 0)
 		{
-			pos += snprintf(str + pos, sizeof(str) - pos, "%s"
+			pos += std::snprintf(str + pos, sizeof(str) - pos, "%s"
 				, progress_bar(int(m_cnt[0][m_mru_ghost_idx] * 1000 / mru_size)
 					, mru_size * (m_width-8) / arc_size, col_yellow, '-', '#'
 					, mru_caption, progress_invert).c_str());
 		}
-		pos += snprintf(str + pos, sizeof(str) - pos, "|");
+		pos += std::snprintf(str + pos, sizeof(str) - pos, "|");
 		if (mfu_size)
 		{
-			pos += snprintf(str + pos, sizeof(str) - pos, "%s"
+			pos += std::snprintf(str + pos, sizeof(str) - pos, "%s"
 				, progress_bar(int(m_cnt[0][m_mfu_size_idx] * 1000 / mfu_size)
 					, mfu_size * (m_width-8) / arc_size, col_green, '#', '-'
 					, mfu_caption).c_str());
 		}
 	}
-	pos += snprintf(str + pos, sizeof(str) - pos, "\x1b[K");
+	pos += std::snprintf(str + pos, sizeof(str) - pos, "\x1b[K");
 	set_cursor_pos(0, y++);
 	print(str);
 
 	if (m_print_utp_stats)
 	{
-		snprintf(str, sizeof(str), "uTP idle: %d syn: %d est: %d fin: %d wait: %d\x1b[K"
+		std::snprintf(str, sizeof(str), "uTP idle: %d syn: %d est: %d fin: %d wait: %d\x1b[K"
 			, int(m_cnt[0][m_utp_idle])
 			, int(m_cnt[0][m_utp_syn_sent])
 			, int(m_cnt[0][m_utp_connected])

examples/simple_client.cpp

@@ -30,7 +30,7 @@ POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#include <stdlib.h>
+#include <cstdlib>
 #include "libtorrent/entry.hpp"
 #include "libtorrent/bencode.hpp"
 #include "libtorrent/session.hpp"
@@ -65,7 +65,7 @@ int main(int argc, char* argv[])
 	error_code ec;
 	if (ec)
 	{
-		fprintf(stderr, "failed to open listen socket: %s\n", ec.message().c_str());
+		std::fprintf(stderr, "failed to open listen socket: %s\n", ec.message().c_str());
 		return 1;
 	}
 	add_torrent_params p;
@@ -73,19 +73,19 @@ int main(int argc, char* argv[])
 	p.ti = boost::make_shared<torrent_info>(std::string(argv[1]), boost::ref(ec), 0);
 	if (ec)
 	{
-		fprintf(stderr, "%s\n", ec.message().c_str());
+		std::fprintf(stderr, "%s\n", ec.message().c_str());
 		return 1;
 	}
 	s.add_torrent(p, ec);
 	if (ec)
 	{
-		fprintf(stderr, "%s\n", ec.message().c_str());
+		std::fprintf(stderr, "%s\n", ec.message().c_str());
 		return 1;
 	}
 
 	// wait for the user to end
 	char a;
-	scanf("%c\n", &a);
+	std::scanf("%c\n", &a);
 	return 0;
 }
 

examples/stats_counters.cpp

@@ -30,8 +30,9 @@ POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#include <stdio.h>
 #include "libtorrent/session_stats.hpp"
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
 
 using namespace libtorrent;
 
@@ -40,7 +41,7 @@ int main()
 	std::vector<stats_metric> m = session_stats_metrics();
 	for (int i = 0; i < int(m.size()); ++i)
 	{
-		printf("%s: %s (%d)\n"
+		std::printf("%s: %s (%d)\n"
 			, m[i].type == stats_metric::type_counter ? "CNTR" : "GAUG"
 			, m[i].name, m[i].value_index);
 	}

examples/torrent_view.cpp

@@ -18,7 +18,7 @@ std::string torrent_state(lt::torrent_status const& s)
 	else ret += state_str[s.state];
 	if (!s.paused && !s.auto_managed) ret += " [F]";
 	char buf[10];
-	snprintf(buf, sizeof(buf), " (%.1f%%)", s.progress_ppm / 10000.f);
+	std::snprintf(buf, sizeof(buf), " (%.1f%%)", s.progress_ppm / 10000.f);
 	ret += buf;
 	return ret;
 }
@@ -257,11 +257,11 @@ void torrent_view::print_tabs()
 		, "seeding", "queued", "stopped", "checking", "loaded"};
 	for (int i = 0; i < int(sizeof(filter_names)/sizeof(filter_names[0])); ++i)
 	{
-		pos += snprintf(str+ pos, sizeof(str) - pos, "%s[%s]%s"
+		pos += std::snprintf(str+ pos, sizeof(str) - pos, "%s[%s]%s"
 			, m_torrent_filter == i?esc("7"):""
 			, filter_names[i], m_torrent_filter == i?esc("0"):"");
 	}
-	pos += snprintf(str + pos, sizeof(str) - pos, "\x1b[K");
+	pos += std::snprintf(str + pos, sizeof(str) - pos, "\x1b[K");
 
 	if (m_width + 1 < int(sizeof(str)))
 		str[m_width + 1] = '\0';
@@ -275,7 +275,7 @@ void torrent_view::print_headers()
 	char str[400];
 
 	// print title bar for torrent list
-	snprintf(str, sizeof(str)
+	std::snprintf(str, sizeof(str)
 		, " %-3s %-50s %-35s %-17s %-17s %-11s %-6s %-6s %-4s\x1b[K"
 		, "#", "Name", "Progress", "Download", "Upload", "Peers (D:S)"
 		, "Down", "Up", "Flags");
@@ -299,9 +299,9 @@ void torrent_view::print_torrent(lt::torrent_status const& s, bool selected)
 
 	char queue_pos[16] = {0};
 	if (s.queue_position == -1)
-		snprintf(queue_pos, sizeof(queue_pos), "-");
+		std::snprintf(queue_pos, sizeof(queue_pos), "-");
 	else
-		snprintf(queue_pos, sizeof(queue_pos), "%d", s.queue_position);
+		std::snprintf(queue_pos, sizeof(queue_pos), "%d", s.queue_position);
 
 	std::string name = s.name;
 	if (name.size() > 50) name.resize(50);
@@ -314,7 +314,7 @@ void torrent_view::print_torrent(lt::torrent_status const& s, bool selected)
 	else if (s.current_tracker.empty())
 		progress_bar_color = col_green;
 
-	pos += snprintf(str + pos, sizeof(str) - pos, "%s%c%-3s %-50s %s%s %s (%s) "
+	pos += std::snprintf(str + pos, sizeof(str) - pos, "%s%c%-3s %-50s %s%s %s (%s) "
 		"%s (%s) %5d:%-5d %s %s %c"
 		, selection
 		, s.is_loaded ? 'L' : ' '
@@ -333,9 +333,9 @@ void torrent_view::print_torrent(lt::torrent_status const& s, bool selected)
 
 	// if this is the selected torrent, restore the background color
 	if (selected)
-		pos += snprintf(str + pos, sizeof(str) - pos, "%s", esc("0"));
+		pos += std::snprintf(str + pos, sizeof(str) - pos, "%s", esc("0"));
 
-	pos += snprintf(str + pos, sizeof(str) - pos, "\x1b[K");
+	pos += std::snprintf(str + pos, sizeof(str) - pos, "\x1b[K");
 
 	print(str);
 }

examples/upnp_test.cpp

@@ -30,14 +30,14 @@ POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#include <stdlib.h>
+#include <cstdlib>
 #include "libtorrent/session.hpp"
 #include "libtorrent/alert_types.hpp"
 
 char const* timestamp()
 {
-	time_t t = std::time(0);
+	std::time_t t = std::time(0);
-	tm* timeinfo = std::localtime(&t);
+	std::tm* timeinfo = std::localtime(&t);
 	static char str[200];
 	std::strftime(str, 200, "%b %d %X", timeinfo);
 	return str;
@@ -49,15 +49,15 @@ void print_alert(libtorrent::alert const* a)
 
 	if (alert_cast<portmap_error_alert>(a))
 	{
-		printf("%s","\x1b[32m");
+		std::printf("%s","\x1b[32m");
 	}
 	else if (alert_cast<portmap_alert>(a))
 	{
-		printf("%s","\x1b[33m");
+		std::printf("%s","\x1b[33m");
 	}
 
-	printf("[%s] %s\n", timestamp(), a->message().c_str());
+	std::printf("[%s] %s\n", timestamp(), a->message().c_str());
-	printf("%s", "\x1b[0m");
+	std::printf("%s", "\x1b[0m");
 }
 
 int main(int argc, char* argv[])
@@ -95,7 +95,7 @@ int main(int argc, char* argv[])
 		}
 	}
 
-	printf("\x1b[1m\n\n===================== done mapping. Now deleting mappings ========================\n\n\n\x1b[0m");
+	std::printf("\x1b[1m\n\n===================== done mapping. Now deleting mappings ========================\n\n\n\x1b[0m");
 
 	for (;;)
 	{

include/libtorrent/Makefile.am

@@ -162,6 +162,7 @@ nobase_include_HEADERS = \
   aux_/disable_warnings_pop.hpp     \
   aux_/escape_string.hpp            \
   aux_/io.hpp                       \
+  aux_/max_path.hpp                 \
   aux_/merkle.hpp                   \
   aux_/session_call.hpp             \
   aux_/session_impl.hpp             \

include/libtorrent/aux_/max_path.hpp

@@ -0,0 +1,68 @@
+/*
+
+Copyright (c) 2016, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution.
+    * Neither the name of the author nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TORRENT_MAX_PATH_HPP_INCLUDED
+#define TORRENT_MAX_PATH_HPP_INCLUDED
+
+// on windows, NAME_MAX refers to Unicode characters
+// on linux it refers to bytes (utf-8 encoded)
+// TODO: Make this count Unicode characters instead of bytes on windows
+
+// windows
+#if defined FILENAME_MAX
+#define TORRENT_MAX_PATH FILENAME_MAX
+
+// beos
+#elif defined B_PATH_NAME_LENGTH
+#define TORRENT_MAX_PATH B_PATH_NAME_LENGTH
+
+// solaris
+#elif defined MAXPATH
+#define TORRENT_MAX_PATH MAXPATH
+
+// none of the above
+#else
+// this is the maximum number of characters in a
+// path element / filename on windows and also on many filesystems commonly used
+// on linux
+#define TORRENT_MAX_PATH 255
+
+#ifdef _MSC_VER
+#pragma message ( "unknown platform, assuming the longest path is 255" )
+#else
+#warning "unknown platform, assuming the longest path is 255"
+#endif
+
+#endif // FILENAME_MAX
+
+#endif // TORRENT_MAX_PATH_HPP_INCLUDED
+

include/libtorrent/buffer.hpp

@@ -66,7 +66,7 @@ public:
 		int left() const
 		{
 			TORRENT_ASSERT(end >= begin);
-			TORRENT_ASSERT(end - begin < INT_MAX);
+			TORRENT_ASSERT(end - begin < (std::numeric_limits<int>::max)());
 			return int(end - begin);
 		}
 
@@ -101,7 +101,7 @@ public:
 		int left() const
 		{
 			TORRENT_ASSERT(end >= begin);
-			TORRENT_ASSERT(end - begin < INT_MAX);
+			TORRENT_ASSERT(end - begin < (std::numeric_limits<int>::max)());
 			return int(end - begin);
 		}
 

include/libtorrent/config.hpp

@@ -40,14 +40,9 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <boost/config.hpp>
 #include <boost/asio/detail/config.hpp>
 #include <boost/version.hpp>
-#include <boost/detail/endian.hpp>
 
 #include "libtorrent/aux_/disable_warnings_pop.hpp"
 
-#include <stdio.h> // for snprintf
-#include <limits.h> // for IOV_MAX
-#include <cinttypes> // for PRId64 et.al.
-
 #include "libtorrent/export.hpp"
 
 #ifdef __linux__
@@ -108,8 +103,6 @@ POSSIBILITY OF SUCH DAMAGE.
 
 // class X needs to have dll-interface to be used by clients of class Y
 #pragma warning(disable:4251)
-// '_vsnprintf': This function or variable may be unsafe
-#pragma warning(disable:4996)
 
 #if (defined(_MSC_VER) && _MSC_VER < 1310)
 #define TORRENT_COMPLETE_TYPES_REQUIRED 1
@@ -328,63 +321,8 @@ POSSIBILITY OF SUCH DAMAGE.
 #define TORRENT_BSD
 #endif
 
-// on windows, NAME_MAX refers to Unicode characters
-// on linux it refers to bytes (utf-8 encoded)
-// TODO: Make this count Unicode characters instead of bytes on windows
-
-// windows
-#if defined FILENAME_MAX
-#define TORRENT_MAX_PATH FILENAME_MAX
-
-// beos
-#elif defined B_PATH_NAME_LENGTH
-#define TORRENT_MAX_PATH B_PATH_NAME_LENGTH
-
-// solaris
-#elif defined MAXPATH
-#define TORRENT_MAX_PATH MAXPATH
-
-// none of the above
-#else
-// this is the maximum number of characters in a
-// path element / filename on windows and also on many filesystems commonly used
-// on linux
-#define TORRENT_MAX_PATH 255
-
-#ifdef _MSC_VER
-#pragma message ( "unknown platform, assuming the longest path is 255" )
-#else
-#warning "unknown platform, assuming the longest path is 255"
-#endif
-
-#endif
-
 #define TORRENT_UNUSED(x) (void)(x)
 
-#if (defined _MSC_VER && _MSC_VER < 1900) && !defined TORRENT_MINGW
-
-#include <stdarg.h>
-
-// internal
-#ifdef __cplusplus
-inline
-#else
-static
-#endif
-int snprintf(char* buf, int len, char const* fmt, ...)
-{
-	va_list lp;
-	int ret;
-	va_start(lp, fmt);
-	ret = _vsnprintf(buf, len, fmt, lp);
-	va_end(lp);
-	if (ret < 0) { buf[len-1] = 0; ret = len-1; }
-	return ret;
-}
-
-#define strtoll _strtoi64
-#endif
-
 // at the highest warning level, clang actually warns about functions
 // that could be marked noreturn.
 #if defined __clang__ || defined __GNUC__
@@ -393,16 +331,6 @@ int snprintf(char* buf, int len, char const* fmt, ...)
 #define TORRENT_NO_RETURN
 #endif
 
-#ifdef _GLIBCXX_USE_NOEXCEPT
-#define TORRENT_EXCEPTION_THROW_SPECIFIER _GLIBCXX_USE_NOEXCEPT
-#else
-#if __cplusplus <= 199711L || defined BOOST_NO_CXX11_NOEXCEPT
-#define TORRENT_EXCEPTION_THROW_SPECIFIER throw()
-#else
-#define TORRENT_EXCEPTION_THROW_SPECIFIER noexcept
-#endif
-#endif // __GLIBC__
-
 #ifndef TORRENT_ICONV_ARG
 #define TORRENT_ICONV_ARG (char**)
 #endif
@@ -542,14 +470,6 @@ int snprintf(char* buf, int len, char const* fmt, ...)
 #define TORRENT_USE_I2P 1
 #endif
 
-#if !defined TORRENT_IOV_MAX
-#ifdef IOV_MAX
-#define TORRENT_IOV_MAX IOV_MAX
-#else
-#define TORRENT_IOV_MAX INT_MAX
-#endif
-#endif
-
 #if !defined(TORRENT_READ_HANDLER_MAX_SIZE)
 # ifdef _GLIBCXX_DEBUG
 #  define TORRENT_READ_HANDLER_MAX_SIZE 400

include/libtorrent/debug.hpp

@@ -157,7 +157,7 @@ namespace libtorrent
 		{
 			if (i->second.refs <= _async_ops_nthreads - 1) continue;
 			ret += i->second.refs;
-			printf("%s: (%d)\n%s\n", i->first.c_str(), i->second.refs, i->second.stack.c_str());
+			std::printf("%s: (%d)\n%s\n", i->first.c_str(), i->second.refs, i->second.stack.c_str());
 		}
 		return ret;
 	}

include/libtorrent/file.hpp

@@ -70,6 +70,8 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <sys/types.h>
 #include <dirent.h> // for DIR
 
+#include "libtorrent/aux_/max_path.hpp" // for TORRENT_MAX_PATH
+
 #undef _FILE_OFFSET_BITS
 
 #endif

include/libtorrent/fingerprint.hpp

@@ -97,7 +97,7 @@ namespace libtorrent
 		std::string to_string() const
 		{
 			char s[100];
-			snprintf(s, 100, "-%c%c%c%c%c%c-"
+			std::snprintf(s, 100, "-%c%c%c%c%c%c-"
 				, name[0], name[1]
 				, version_to_char(major_version)
 				, version_to_char(minor_version)

include/libtorrent/lazy_entry.hpp

@@ -40,6 +40,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <cstring>
 #include <algorithm>
+#include <limits>
 #include "libtorrent/config.hpp"
 #include "libtorrent/assert.hpp"
 #include "libtorrent/error_code.hpp"
@@ -106,7 +107,7 @@ namespace libtorrent
 		// construct a string pointing to the characters at ``p``
 		// of length ``l`` characters. No NULL termination is required.
 		pascal_string(char const* p, int l): len(l), ptr(p) {}
-		
+
 		// the number of characters in the string.
 		int len;
 
@@ -319,10 +320,10 @@ namespace libtorrent
 		void set_end(char const* end)
 		{
 			TORRENT_ASSERT(end > m_begin);
-			TORRENT_ASSERT(end - m_begin < INT_MAX);
+			TORRENT_ASSERT(end - m_begin < (std::numeric_limits<int>::max)());
 			m_len = int(end - m_begin);
 		}
-		
+
 		// internal
 		void clear();
 

include/libtorrent/piece_picker.hpp

@@ -839,7 +839,7 @@ namespace libtorrent
 #ifdef TORRENT_OPTIMIZE_MEMORY_USAGE
 		enum { max_pieces = piece_pos::we_have_index - 1 };
 #else
-		enum { max_pieces = INT_MAX - 1 };
+		enum { max_pieces = (std::numeric_limits<int>::max)() - 1 };
 #endif
 
 	};

include/libtorrent/session.hpp

@@ -37,16 +37,9 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <vector>
 #include <thread>
 
-#include "libtorrent/aux_/disable_warnings_push.hpp"
-
-#include <boost/limits.hpp>
-
-#include "libtorrent/aux_/disable_warnings_pop.hpp"
-
 #include "libtorrent/config.hpp"
 #include "libtorrent/version.hpp"
 #include "libtorrent/build_config.hpp"
-#include "libtorrent/settings_pack.hpp"
 #include "libtorrent/io_service.hpp"
 
 #include "libtorrent/storage.hpp"
@@ -54,7 +47,9 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/session_handle.hpp"
 
 #ifndef TORRENT_NO_DEPRECATE
+#include "libtorrent/settings_pack.hpp"
 #include "libtorrent/fingerprint.hpp"
+#include <cstdio> // for snprintf
 #endif
 
 #ifdef TORRENT_USE_OPENSSL
@@ -240,7 +235,7 @@ namespace libtorrent
 			char if_string[100];
 
 			if (listen_interface == NULL) listen_interface = "0.0.0.0";
-			snprintf(if_string, sizeof(if_string), "%s:%d", listen_interface, listen_port_range.first);
+			std::snprintf(if_string, sizeof(if_string), "%s:%d", listen_interface, listen_port_range.first);
 			pack.set_str(settings_pack::listen_interfaces, if_string);
 
 			if ((flags & start_default_features) == 0)

simulation/create_torrent.cpp

@@ -41,7 +41,7 @@ std::string save_path(int idx)
 {
 	int swarm_id = test_counter();
 	char path[200];
-	snprintf(path, sizeof(path), "swarm-%04d-peer-%02d"
+	std::snprintf(path, sizeof(path), "swarm-%04d-peer-%02d"
 		, swarm_id, idx);
 	return path;
 }
@@ -53,11 +53,11 @@ lt::add_torrent_params create_torrent(int idx, bool seed)
 	lt::add_torrent_params params;
 	int swarm_id = test_counter();
 	char name[200];
-	snprintf(name, sizeof(name), "temp-%02d", swarm_id);
+	std::snprintf(name, sizeof(name), "temp-%02d", swarm_id);
 	std::string path = save_path(idx);
 	lt::error_code ec;
 	lt::create_directory(path, ec);
-	if (ec) fprintf(stderr, "failed to create directory: \"%s\": %s\n"
+	if (ec) std::fprintf(stderr, "failed to create directory: \"%s\": %s\n"
 		, path.c_str(), ec.message().c_str());
 	std::ofstream file(lt::combine_path(path, name).c_str());
 	params.ti = ::create_torrent(&file, name, 0x4000, 9 + idx, false);

simulation/fake_peer.hpp

@@ -34,6 +34,8 @@ POSSIBILITY OF SUCH DAMAGE.
 #define SIMULATION_FAKE_PEER_HPP
 
 #include <array>
+#include <cstdio> // for snprintf
+
 #include "test.hpp"
 #include "simulator/simulator.hpp"
 #include "libtorrent/session.hpp"
@@ -94,7 +96,7 @@ private:
 	void write_handshake(boost::system::error_code const& ec, lt::sha1_hash ih)
 	{
 		asio::ip::tcp::endpoint ep = m_out_socket.remote_endpoint();
-		printf("fake_peer::connect (%s) -> (%d) %s\n"
+		std::printf("fake_peer::connect (%s) -> (%d) %s\n"
 			, lt::print_endpoint(ep).c_str(), ec.value()
 			, ec.message().c_str());
 		static char const handshake[]
@@ -109,7 +111,7 @@ private:
 		asio::async_write(m_out_socket, asio::const_buffers_1(&m_out_buffer[0]
 			, len), [=](boost::system::error_code const& ec, size_t bytes_transferred)
 		{
-			printf("fake_peer::write_handshake(%s) -> (%d) %s\n"
+			std::printf("fake_peer::write_handshake(%s) -> (%d) %s\n"
 				, lt::print_endpoint(ep).c_str(), ec.value()
 				, ec.message().c_str());
 			this->m_out_socket.close();
@@ -131,7 +133,7 @@ inline void add_fake_peers(lt::torrent_handle h)
 	for (int i = 0; i < 5; ++i)
 	{
 		char ep[30];
-		snprintf(ep, sizeof(ep), "60.0.0.%d", i);
+		std::snprintf(ep, sizeof(ep), "60.0.0.%d", i);
 		h.connect_peer(lt::tcp::endpoint(
 			lt::address_v4::from_string(ep), 6881));
 	}

simulation/setup_dht.cpp

@@ -206,7 +206,7 @@ struct dht_node final : lt::dht::udp_socket_interface
 			if (n.first == id) continue;
 			int const bucket = 159 - dht::distance_exp(id, n.first);
 
-/*			printf("%s ^ %s = %s %d\n"
+/*			std::printf("%s ^ %s = %s %d\n"
 				, to_hex(id.to_string()).c_str()
 				, to_hex(n.first.to_string()).c_str()
 				, to_hex(dht::distance(id, n.first).to_string()).c_str()
@@ -230,9 +230,9 @@ struct dht_node final : lt::dht::udp_socket_interface
 /*
 		for (int i = 0; i < 40; ++i)
 		{
-			printf("%d ", nodes_per_bucket[i]);
+			std::printf("%d ", nodes_per_bucket[i]);
 		}
-		printf("\n");
+		std::printf("\n");
 */
 //#error add invalid IPs as well, to simulate churn
 	}
@@ -313,7 +313,7 @@ void print_routing_table(std::vector<lt::dht_routing_bucket> const& rt)
 			"################################"
 			"################################";
 		char const* short_progress_bar = "--------";
-		printf("%3d [%3d, %d] %s%s\n"
+		std::printf("%3d [%3d, %d] %s%s\n"
 			, bucket, i->num_nodes, i->num_replacements
 			, progress_bar + (128 - i->num_nodes)
 			, short_progress_bar + (8 - (std::min)(8, i->num_replacements)));

simulation/setup_swarm.cpp

@@ -101,7 +101,7 @@ sim::route dsl_config::outgoing_route(asio::ip::address ip)
 std::string save_path(int swarm_id, int idx)
 {
 	char path[200];
-	snprintf(path, sizeof(path), "swarm-%04d-peer-%02d"
+	std::snprintf(path, sizeof(path), "swarm-%04d-peer-%02d"
 		, swarm_id, idx);
 	return path;
 }
@@ -115,7 +115,7 @@ void add_extra_peers(lt::session& ses)
 	for (int i = 0; i < 30; ++i)
 	{
 		char ep[30];
-		snprintf(ep, sizeof(ep), "60.0.0.%d", i + 1);
+		std::snprintf(ep, sizeof(ep), "60.0.0.%d", i + 1);
 		h.connect_peer(lt::tcp::endpoint(addr(ep), 6881));
 	}
 }
@@ -245,7 +245,7 @@ void setup_swarm(int num_nodes
 	int swarm_id = test_counter();
 	std::string path = save_path(swarm_id, 0);
 	lt::create_directory(path, ec);
-	if (ec) fprintf(stderr, "failed to create directory: \"%s\": %s\n"
+	if (ec) std::fprintf(stderr, "failed to create directory: \"%s\": %s\n"
 		, path.c_str(), ec.message().c_str());
 	std::ofstream file(lt::combine_path(path, "temporary").c_str());
 	auto ti = ::create_torrent(&file, "temporary", 0x4000, 9, false);
@@ -258,9 +258,9 @@ void setup_swarm(int num_nodes
 		// create a new io_service
 		std::vector<asio::ip::address> ips;
 		char ep[30];
-		snprintf(ep, sizeof(ep), "50.0.%d.%d", (i + 1) >> 8, (i + 1) & 0xff);
+		std::snprintf(ep, sizeof(ep), "50.0.%d.%d", (i + 1) >> 8, (i + 1) & 0xff);
 		ips.push_back(addr(ep));
-		snprintf(ep, sizeof(ep), "2000::%X%X", (i + 1) >> 8, (i + 1) & 0xff);
+		std::snprintf(ep, sizeof(ep), "2000::%X%X", (i + 1) >> 8, (i + 1) & 0xff);
 		ips.push_back(addr(ep));
 		io_service.push_back(boost::make_shared<sim::asio::io_service>(
 			boost::ref(sim), ips));
@@ -328,7 +328,7 @@ void setup_swarm(int num_nodes
 					// only print alerts from the session under test
 					lt::time_duration d = a->timestamp() - start_time;
 					boost::uint32_t millis = lt::duration_cast<lt::milliseconds>(d).count();
-					printf("%4d.%03d: %-25s %s\n", millis / 1000, millis % 1000
+					std::printf("%4d.%03d: %-25s %s\n", millis / 1000, millis % 1000
 						, a->what()
 						, a->message().c_str());
 
@@ -345,7 +345,7 @@ void setup_swarm(int num_nodes
 							// string and an integer is common. It should probably be
 							// factored out into its own function
 							char ep[30];
-							snprintf(ep, sizeof(ep), "50.0.%d.%d", (k + 1) >> 8, (k + 1) & 0xff);
+							std::snprintf(ep, sizeof(ep), "50.0.%d.%d", (k + 1) >> 8, (k + 1) & 0xff);
 							h.connect_peer(lt::tcp::endpoint(addr(ep), 6881));
 						}
 					}
@@ -378,7 +378,7 @@ void setup_swarm(int num_nodes
 
 		if (shut_down)
 		{
-			printf("TERMINATING\n");
+			std::printf("TERMINATING\n");
 
 			// terminate simulation
 			for (int i = 0; i < int(nodes.size()); ++i)

simulation/test_auto_manage.cpp

@@ -52,7 +52,7 @@ using sim::asio::ip::address_v4;
 std::unique_ptr<sim::asio::io_service> make_io_service(sim::simulation& sim, int i)
 {
 	char ep[30];
-	snprintf(ep, sizeof(ep), "50.0.%d.%d", (i + 1) >> 8, (i + 1) & 0xff);
+	std::snprintf(ep, sizeof(ep), "50.0.%d.%d", (i + 1) >> 8, (i + 1) & 0xff);
 	return std::unique_ptr<sim::asio::io_service>(new sim::asio::io_service(
 		sim, asio::ip::address_v4::from_string(ep)));
 }
@@ -127,7 +127,7 @@ TORRENT_TEST(dont_count_slow_torrents)
 			int num_started = 0;
 			for (alert* a : alerts)
 			{
-				printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				if (alert_cast<torrent_resumed_alert>(a) == nullptr) continue;
 
@@ -186,7 +186,7 @@ TORRENT_TEST(count_slow_torrents)
 			int num_started = 0;
 			for (alert* a : alerts)
 			{
-				printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				if (alert_cast<torrent_resumed_alert>(a) == nullptr) continue;
 				++num_started;
@@ -236,7 +236,7 @@ TORRENT_TEST(force_stopped_download)
 
 			for (alert* a : alerts)
 			{
-				printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				// we don't expect any torrents being started or stopped, since
 				// they're all force stopped
@@ -284,7 +284,7 @@ TORRENT_TEST(force_started)
 
 			for (alert* a : alerts)
 			{
-				printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				// we don't expect any torrents being started or stopped, since
 				// they're all force started
@@ -336,13 +336,13 @@ TORRENT_TEST(seed_limit)
 			int num_seeding = 0;
 			for (alert* a : alerts)
 			{
-				fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				if (alert_cast<torrent_resumed_alert>(a))
 				{
 					++num_started;
 
-					fprintf(stderr, "started: %d checking: %d seeding: %d\n"
+					std::fprintf(stderr, "started: %d checking: %d seeding: %d\n"
 						, num_started, num_checking, num_seeding);
 				}
 				else if (alert_cast<torrent_paused_alert>(a))
@@ -350,7 +350,7 @@ TORRENT_TEST(seed_limit)
 					TEST_CHECK(num_started > 0);
 					--num_started;
 
-					fprintf(stderr, "started: %d checking: %d seeding: %d\n"
+					std::fprintf(stderr, "started: %d checking: %d seeding: %d\n"
 						, num_started, num_checking, num_seeding);
 				}
 				else if (state_changed_alert* sc = alert_cast<state_changed_alert>(a))
@@ -365,7 +365,7 @@ TORRENT_TEST(seed_limit)
 					else if (sc->state == torrent_status::seeding)
 						++num_seeding;
 
-					fprintf(stderr, "started: %d checking: %d seeding: %d\n"
+					std::fprintf(stderr, "started: %d checking: %d seeding: %d\n"
 						, num_started, num_checking, num_seeding);
 
 					// while at least one torrent is checking, there may be another
@@ -425,13 +425,13 @@ TORRENT_TEST(download_limit)
 			int num_downloading = 0;
 			for (alert* a : alerts)
 			{
-				fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				if (alert_cast<torrent_resumed_alert>(a))
 				{
 					++num_started;
 
-					fprintf(stderr, "started: %d checking: %d downloading: %d\n"
+					std::fprintf(stderr, "started: %d checking: %d downloading: %d\n"
 						, num_started, num_checking, num_downloading);
 				}
 				else if (alert_cast<torrent_paused_alert>(a))
@@ -439,7 +439,7 @@ TORRENT_TEST(download_limit)
 					TEST_CHECK(num_started > 0);
 					--num_started;
 
-					fprintf(stderr, "started: %d checking: %d downloading: %d\n"
+					std::fprintf(stderr, "started: %d checking: %d downloading: %d\n"
 						, num_started, num_checking, num_downloading);
 				}
 				else if (state_changed_alert* sc = alert_cast<state_changed_alert>(a))
@@ -454,7 +454,7 @@ TORRENT_TEST(download_limit)
 					else if (sc->state == torrent_status::downloading)
 						++num_downloading;
 
-					fprintf(stderr, "started: %d checking: %d downloading: %d\n"
+					std::fprintf(stderr, "started: %d checking: %d downloading: %d\n"
 						, num_started, num_checking, num_downloading);
 
 					// while at least one torrent is checking, there may be another
@@ -521,7 +521,7 @@ TORRENT_TEST(checking_announce)
 			int num_announce = 0;
 			for (alert* a : alerts)
 			{
-				fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				if (alert_cast<tracker_announce_alert>(a))
 					++num_announce;
@@ -571,7 +571,7 @@ TORRENT_TEST(paused_checking)
 
 			for (alert* a : alerts)
 			{
-				fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				if (state_changed_alert* sc = alert_cast<state_changed_alert>(a))
 				{
@@ -620,7 +620,7 @@ TORRENT_TEST(stop_when_ready)
 			int num_paused = 0;
 			for (alert* a : alerts)
 			{
-				fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::fprintf(stderr, "%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 
 				if (alert_cast<torrent_paused_alert>(a))
@@ -692,7 +692,7 @@ TORRENT_TEST(resume_reject_when_paused)
 
 			for (alert* a : alerts)
 			{
-				fprintf(stderr, "%-3d %-25s %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::fprintf(stderr, "%-3d %-25s %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count())
 					, a->what()
 					, a->message().c_str());
@@ -763,7 +763,7 @@ TORRENT_TEST(no_resume_when_paused)
 
 			for (alert* a : alerts)
 			{
-				fprintf(stderr, "%-3d %-25s %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::fprintf(stderr, "%-3d %-25s %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count())
 					, a->what()
 					, a->message().c_str());
@@ -825,7 +825,7 @@ TORRENT_TEST(no_resume_when_started)
 
 			for (alert* a : alerts)
 			{
-				fprintf(stderr, "%-3d %-25s %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::fprintf(stderr, "%-3d %-25s %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count())
 					, a->what()
 					, a->message().c_str());
@@ -881,7 +881,7 @@ TORRENT_TEST(pause_completed_torrents)
 			lt::time_point paused;
 			for (alert* a : alerts)
 			{
-				printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
+				std::printf("%-3d %s\n", int(duration_cast<lt::seconds>(a->timestamp()
 						- start_time).count()), a->message().c_str());
 				if (alert_cast<torrent_resumed_alert>(a))
 					++num_started;

simulation/test_dht.cpp

@@ -136,7 +136,7 @@ TORRENT_TEST(dht_bootstrap)
 			}
 			if (ticks > 2)
 			{
-				printf("depth: %d nodes: %d\n", routing_table_depth, num_nodes);
+				std::printf("depth: %d nodes: %d\n", routing_table_depth, num_nodes);
 				TEST_CHECK(routing_table_depth >= 9);
 				TEST_CHECK(num_nodes >= 115);
 				dht.stop();

simulation/test_dht_rate_limit.cpp

@@ -186,7 +186,7 @@ TORRENT_TEST(dht_rate_limit)
 	float const average_upload_rate = (num_bytes_received - target_upload_rate)
 		/ (duration_cast<chrono::milliseconds>(end - start).count() * 0.001f);
 
-	printf("send %d packets. received %d packets (%d bytes). average rate: %f (target: %f)\n"
+	std::printf("send %d packets. received %d packets (%d bytes). average rate: %f (target: %f)\n"
 		, num_packets_sent, num_packets_received, num_bytes_received
 		, average_upload_rate, target_upload_rate);
 

simulation/test_http_connection.cpp

@@ -96,7 +96,7 @@ std::string chunk_string(std::string s)
 	{
 		i = std::min(i, s.size());
 		char header[50];
-		snprintf(header, sizeof(header), "%x\r\n", int(i));
+		std::snprintf(header, sizeof(header), "%x\r\n", int(i));
 		ret += header;
 		ret += s.substr(0, i);
 		s.erase(s.begin(), s.begin() + i);
@@ -118,14 +118,14 @@ boost::shared_ptr<http_connection> test_request(io_service& ios
 	, int* handler_called
 	, std::string const& auth = std::string())
 {
-	fprintf(stderr, " ===== TESTING: %s =====\n", url.c_str());
+	std::fprintf(stderr, " ===== TESTING: %s =====\n", url.c_str());
 
 	auto h = boost::make_shared<http_connection>(ios
 		, res
 		, [=](error_code const& ec, http_parser const& parser
 			, char const* data, const int size, http_connection& c)
 		{
-			printf("RESPONSE: %s\n", url.c_str());
+			std::printf("RESPONSE: %s\n", url.c_str());
 			++*handler_called;
 
 			// this is pretty gross. Since boost.asio is a header-only library, when this test is
@@ -138,7 +138,7 @@ boost::shared_ptr<http_connection> test_request(io_service& ios
 
 			if (!error_ok)
 			{
-				printf("ERROR: %s (expected: %s)\n"
+				std::printf("ERROR: %s (expected: %s)\n"
 					, ec.message().c_str()
 					, expected_error.message().c_str());
 			}
@@ -165,7 +165,7 @@ boost::shared_ptr<http_connection> test_request(io_service& ios
 		{
 			++*connect_handler_called;
 			TEST_CHECK(c.socket().is_open());
-			printf("CONNECTED: %s\n", url.c_str());
+			std::printf("CONNECTED: %s\n", url.c_str());
 		});
 
 	h->get(url, seconds(1), 0, &ps, 5, "test/user-agent", address_v4::any()
@@ -178,7 +178,7 @@ void print_http_header(std::map<std::string, std::string> const& headers)
 	for (std::map<std::string, std::string>::const_iterator i
 		= headers.begin(), end(headers.end()); i != end; ++i)
 	{
-		printf("%s: %s\n", i->first.c_str(), i->second.c_str());
+		std::printf("%s: %s\n", i->first.c_str(), i->second.c_str());
 	}
 }
 
@@ -401,7 +401,7 @@ void run_test(lt::aux::proxy_settings ps, std::string url, int expect_size, int
 	TEST_EQUAL(counters.size(), expect_counters.size());
 	for (int i = 0; i < int(counters.size()); ++i)
 	{
-		if (counters[i] != expect_counters[i]) fprintf(stderr, "i=%d\n", i);
+		if (counters[i] != expect_counters[i]) std::fprintf(stderr, "i=%d\n", i);
 		TEST_EQUAL(counters[i], expect_counters[i]);
 	}
 }

simulation/test_optimistic_unchoke.cpp

@@ -98,7 +98,7 @@ TORRENT_TEST(optimistic_unchoke)
 		{
 			// create a new io_service
 			char ep[30];
-			snprintf(ep, sizeof(ep), "50.0.%d.%d", (i + 1) >> 8, (i + 1) & 0xff);
+			std::snprintf(ep, sizeof(ep), "50.0.%d.%d", (i + 1) >> 8, (i + 1) & 0xff);
 			io_service.push_back(std::make_shared<sim::asio::io_service>(
 				std::ref(sim), addr(ep)));
 			peers.push_back(std::make_shared<peer_conn>(std::ref(*io_service.back())

simulation/test_pe_crypto.cpp

@@ -56,11 +56,11 @@ char const* pe_policy(boost::uint8_t policy)
 
 void display_pe_settings(libtorrent::settings_pack const& s)
 {
-	fprintf(stderr, "out_enc_policy - %s\tin_enc_policy - %s\n"
+	std::fprintf(stderr, "out_enc_policy - %s\tin_enc_policy - %s\n"
 		, pe_policy(s.get_int(settings_pack::out_enc_policy))
 		, pe_policy(s.get_int(settings_pack::in_enc_policy)));
 
-	fprintf(stderr, "enc_level - %s\t\tprefer_rc4 - %s\n"
+	std::fprintf(stderr, "enc_level - %s\t\tprefer_rc4 - %s\n"
 		, s.get_int(settings_pack::allowed_enc_level) == settings_pack::pe_plaintext ? "plaintext"
 		: s.get_int(settings_pack::allowed_enc_level) == settings_pack::pe_rc4 ? "rc4"
 		: s.get_int(settings_pack::allowed_enc_level) == settings_pack::pe_both ? "both" : "unknown"
@@ -191,7 +191,7 @@ TORRENT_TEST(disabled_failing)
 #else
 TORRENT_TEST(disabled)
 {
-	fprintf(stderr, "PE test not run because it's disabled\n");
+	std::fprintf(stderr, "PE test not run because it's disabled\n");
 }
 #endif
 

simulation/test_socks5.cpp

@@ -54,7 +54,7 @@ namespace lt = libtorrent;
 std::unique_ptr<sim::asio::io_service> make_io_service(sim::simulation& sim, int i)
 {
 	char ep[30];
-	snprintf(ep, sizeof(ep), "50.0.%d.%d", (i + 1) >> 8, (i + 1) & 0xff);
+	std::snprintf(ep, sizeof(ep), "50.0.%d.%d", (i + 1) >> 8, (i + 1) & 0xff);
 	return std::unique_ptr<sim::asio::io_service>(new sim::asio::io_service(
 		sim, address_v4::from_string(ep)));
 }
@@ -99,7 +99,7 @@ void run_test(Setup const& setup
 	// happened
 	sim::timer t(sim, lt::seconds(100), [&](boost::system::error_code const& ec)
 	{
-		fprintf(stderr, "shutting down\n");
+		std::fprintf(stderr, "shutting down\n");
 		// shut down
 		ses->set_alert_notify([] {});
 		zombie = ses->abort();

simulation/test_swarm.cpp

@@ -76,7 +76,7 @@ TORRENT_TEST(plain)
 				return true;
 			}
 			if (!is_seed(ses)) return false;
-			printf("completed in %d ticks\n", ticks);
+			std::printf("completed in %d ticks\n", ticks);
 			return true;
 		});
 }
@@ -117,7 +117,7 @@ TORRENT_TEST(session_stats)
 				return true;
 			}
 			if (!is_seed(ses)) return false;
-			printf("completed in %d ticks\n", ticks);
+			std::printf("completed in %d ticks\n", ticks);
 			return true;
 		});
 }
@@ -143,7 +143,7 @@ TORRENT_TEST(suggest)
 				return true;
 			}
 			if (!is_seed(ses)) return false;
-			printf("completed in %d ticks\n", ticks);
+			std::printf("completed in %d ticks\n", ticks);
 			return true;
 		});
 }
@@ -201,7 +201,7 @@ void test_stop_start_download(swarm_test type, bool graceful)
 			if (auto tp = lt::alert_cast<lt::torrent_paused_alert>(a))
 			{
 				TEST_EQUAL(resumed, false);
-				printf("\nSTART\n\n");
+				std::printf("\nSTART\n\n");
 				tp->handle.resume();
 				resumed = true;
 			}
@@ -218,14 +218,14 @@ void test_stop_start_download(swarm_test type, bool graceful)
 
 				if (limit_reached)
 				{
-					printf("\nSTOP\n\n");
+					std::printf("\nSTOP\n\n");
 					auto h = ses.get_torrents()[0];
 					h.pause(graceful ? torrent_handle::graceful_pause : 0);
 					paused_once = true;
 				}
 			}
 
-			printf("tick: %d\n", ticks);
+			std::printf("tick: %d\n", ticks);
 
 			const int timeout = type == swarm_test::download ? 20 : 91;
 			if (ticks > timeout)
@@ -235,7 +235,7 @@ void test_stop_start_download(swarm_test type, bool graceful)
 			}
 			if (type == swarm_test::upload) return false;
 			if (!is_seed(ses)) return false;
-			printf("completed in %d ticks\n", ticks);
+			std::printf("completed in %d ticks\n", ticks);
 			return true;
 		});
 
@@ -268,7 +268,7 @@ TORRENT_TEST(stop_start_download_graceful_no_peers)
 			if (auto tp = lt::alert_cast<lt::torrent_paused_alert>(a))
 			{
 				TEST_EQUAL(resumed, false);
-				printf("\nSTART\n\n");
+				std::printf("\nSTART\n\n");
 				tp->handle.resume();
 				resumed = true;
 			}
@@ -279,13 +279,13 @@ TORRENT_TEST(stop_start_download_graceful_no_peers)
 			if (paused_once == false
 				&& ticks == 6)
 			{
-				printf("\nSTOP\n\n");
+				std::printf("\nSTOP\n\n");
 				auto h = ses.get_torrents()[0];
 				h.pause(torrent_handle::graceful_pause);
 				paused_once = true;
 			}
 
-			printf("tick: %d\n", ticks);
+			std::printf("tick: %d\n", ticks);
 
 			// when there's only one node (i.e. no peers) we won't ever download
 			// the torrent. It's just a test to make sure we still get the
@@ -352,7 +352,7 @@ TORRENT_TEST(delete_files)
 	file_status st;
 	error_code ec;
 	stat_file(combine_path(save_path, "temporary"), &st, ec);
-	printf("expecting \"%s/temporary\" to NOT exist [%s | %s]\n"
+	std::printf("expecting \"%s/temporary\" to NOT exist [%s | %s]\n"
 		, save_path.c_str()
 		, ec.category().name()
 		, ec.message().c_str());
@@ -383,7 +383,7 @@ TORRENT_TEST(delete_partfile)
 	file_status st;
 	error_code ec;
 	stat_file(combine_path(save_path, "temporary"), &st, ec);
-	printf("expecting \"%s/temporary\" to exist [%s]\n", save_path.c_str()
+	std::printf("expecting \"%s/temporary\" to exist [%s]\n", save_path.c_str()
 		, ec.message().c_str());
 	TEST_CHECK(!ec);
 }

simulation/test_tracker.cpp

@@ -76,7 +76,7 @@ void test_interval(int interval)
 		announces.push_back(seconds);
 
 		char response[500];
-		int size = snprintf(response, sizeof(response), "d8:intervali%de5:peers0:e", interval);
+		int size = std::snprintf(response, sizeof(response), "d8:intervali%de5:peers0:e", interval);
 		return sim::send_response(200, "OK", size) + response;
 	});
 
@@ -144,7 +144,7 @@ TORRENT_TEST(event_completed)
 		announces.push_back({timestamp, req});
 
 		char response[500];
-		int size = snprintf(response, sizeof(response), "d8:intervali%de5:peers0:e", interval);
+		int size = std::snprintf(response, sizeof(response), "d8:intervali%de5:peers0:e", interval);
 		return sim::send_response(200, "OK", size) + response;
 	});
 
@@ -192,7 +192,7 @@ TORRENT_TEST(event_completed)
 		// we there can only be one event
 		const bool has_event = str.find("&event=") != std::string::npos;
 
-		fprintf(stderr, "- %s\n", str.c_str());
+		std::fprintf(stderr, "- %s\n", str.c_str());
 
 		// there is exactly 0 or 1 events.
 		TEST_EQUAL(int(has_start) + int(has_completed) + int(has_stopped)
@@ -269,7 +269,7 @@ void on_alert_notify(lt::session* ses)
 		{
 			lt::time_duration d = a->timestamp().time_since_epoch();
 			boost::uint32_t millis = lt::duration_cast<lt::milliseconds>(d).count();
-			printf("%4d.%03d: %s\n", millis / 1000, millis % 1000,
+			std::printf("%4d.%03d: %s\n", millis / 1000, millis % 1000,
 				a->message().c_str());
 		}
 	});
@@ -301,7 +301,7 @@ TORRENT_TEST(ipv6_support)
 		TEST_EQUAL(method, "GET");
 
 		char response[500];
-		int size = snprintf(response, sizeof(response), "d8:intervali1800e5:peers0:e");
+		int size = std::snprintf(response, sizeof(response), "d8:intervali1800e5:peers0:e");
 		return sim::send_response(200, "OK", size) + response;
 	});
 
@@ -313,7 +313,7 @@ TORRENT_TEST(ipv6_support)
 		TEST_EQUAL(method, "GET");
 
 		char response[500];
-		int size = snprintf(response, sizeof(response), "d8:intervali1800e5:peers0:e");
+		int size = std::snprintf(response, sizeof(response), "d8:intervali1800e5:peers0:e");
 		return sim::send_response(200, "OK", size) + response;
 	});
 
@@ -468,7 +468,7 @@ TORRENT_TEST(test_error)
 			TEST_EQUAL(method, "GET");
 
 			char response[500];
-			int size = snprintf(response, sizeof(response), "d14:failure reason4:teste");
+			int size = std::snprintf(response, sizeof(response), "d14:failure reason4:teste");
 			return sim::send_response(200, "OK", size) + response;
 		}
 		, [](announce_entry const& ae)
@@ -491,7 +491,7 @@ TORRENT_TEST(test_warning)
 			TEST_EQUAL(method, "GET");
 
 			char response[500];
-			int size = snprintf(response, sizeof(response), "d5:peers6:aaaaaa15:warning message5:test2e");
+			int size = std::snprintf(response, sizeof(response), "d5:peers6:aaaaaa15:warning message5:test2e");
 			return sim::send_response(200, "OK", size) + response;
 		}
 		, [](announce_entry const& ae)
@@ -513,7 +513,7 @@ TORRENT_TEST(test_scrape_data_in_announce)
 			TEST_EQUAL(method, "GET");
 
 			char response[500];
-			int size = snprintf(response, sizeof(response),
+			int size = std::snprintf(response, sizeof(response),
 				"d5:peers6:aaaaaa8:completei1e10:incompletei2e10:downloadedi3e11:downloadersi4ee");
 			return sim::send_response(200, "OK", size) + response;
 		}
@@ -539,7 +539,7 @@ TORRENT_TEST(test_scrape)
 			TEST_EQUAL(method, "GET");
 
 			char response[500];
-			int size = snprintf(response, sizeof(response),
+			int size = std::snprintf(response, sizeof(response),
 				"d5:filesd20:ababababababababababd8:completei1e10:downloadedi3e10:incompletei2eeee");
 			return sim::send_response(200, "OK", size) + response;
 		}
@@ -587,7 +587,7 @@ TORRENT_TEST(test_interval)
 		{
 			TEST_EQUAL(method, "GET");
 			char response[500];
-			int size = snprintf(response, sizeof(response)
+			int size = std::snprintf(response, sizeof(response)
 				, "d10:tracker id8:testteste");
 			return sim::send_response(200, "OK", size) + response;
 		}
@@ -611,7 +611,7 @@ TORRENT_TEST(test_invalid_bencoding)
 		{
 			TEST_EQUAL(method, "GET");
 			char response[500];
-			int size = snprintf(response, sizeof(response)
+			int size = std::snprintf(response, sizeof(response)
 				, "d10:tracer idteste");
 			return sim::send_response(200, "OK", size) + response;
 		}
@@ -650,7 +650,7 @@ TORRENT_TEST(try_next)
 
 			char response[500];
 			// respond with an empty peer list
-			int size = snprintf(response, sizeof(response), "d5:peers0:e");
+			int size = std::snprintf(response, sizeof(response), "d5:peers0:e");
 			return sim::send_response(200, "OK", size) + response;
 		}
 		, [](torrent_handle h) {}
@@ -665,7 +665,7 @@ TORRENT_TEST(try_next)
 
 			for (int i = 0; i < int(tr.size()); ++i)
 			{
-				fprintf(stderr, "tracker \"%s\"\n", tr[i].url.c_str());
+				std::fprintf(stderr, "tracker \"%s\"\n", tr[i].url.c_str());
 				if (tr[i].url == "http://tracker.com:8080/announce")
 				{
 					TEST_EQUAL(tr[i].fails, 0);

simulation/test_transfer.cpp

@@ -355,7 +355,7 @@ TORRENT_TEST(auto_disk_cache_size)
 			TEST_EQUAL(is_seed(*ses[0]), true);
 
 			int const cache_size = get_cache_size(*ses[0]);
-			printf("cache size: %d\n", cache_size);
+			std::printf("cache size: %d\n", cache_size);
 			// this assumes the test torrent is at least 4 blocks
 			TEST_CHECK(cache_size > 4);
 		}
@@ -372,7 +372,7 @@ TORRENT_TEST(disable_disk_cache)
 			TEST_EQUAL(is_seed(*ses[0]), true);
 
 			int const cache_size = get_cache_size(*ses[0]);
-			printf("cache size: %d\n", cache_size);
+			std::printf("cache size: %d\n", cache_size);
 			TEST_EQUAL(cache_size, 0);
 		}
 	);

simulation/utils.cpp

@@ -134,7 +134,7 @@ void print_alerts(lt::session& ses
 
 		for (lt::alert const* a : alerts)
 		{
-			printf("%-3d [0] %s\n", int(lt::duration_cast<lt::seconds>(a->timestamp()
+			std::printf("%-3d [0] %s\n", int(lt::duration_cast<lt::seconds>(a->timestamp()
 				- start_time).count()), a->message().c_str());
 			// call the user handler
 			on_alert(ses, a);

src/ConvertUTF.cpp

@@ -155,7 +155,7 @@ ConversionResult ConvertUTF16toUTF32 (
 	*targetStart = target;
 #ifdef CVTUTF_DEBUG
 if (result == sourceIllegal) {
-	fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
+	std::fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
 	fflush(stderr);
 }
 #endif

src/alert.cpp

@@ -31,6 +31,8 @@ POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include <string>
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
 
 #include "libtorrent/config.hpp"
 #include "libtorrent/alert.hpp"
@@ -47,6 +49,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/piece_picker.hpp" // for piece_block
 
 #include "libtorrent/aux_/escape_string.hpp" // for convert_from_native
+#include "libtorrent/aux_/max_path.hpp" // for TORRENT_MAX_PATH
 
 #include <boost/bind.hpp>
 
@@ -162,13 +165,13 @@ namespace libtorrent {
 		char msg[200];
 		if (ec)
 		{
-			snprintf(msg, sizeof(msg), "%s: read_piece %u failed: %s"
+			std::snprintf(msg, sizeof(msg), "%s: read_piece %u failed: %s"
 				, torrent_alert::message().c_str() , piece
 				, convert_from_native(ec.message()).c_str());
 		}
 		else
 		{
-			snprintf(msg, sizeof(msg), "%s: read_piece %u successful"
+			std::snprintf(msg, sizeof(msg), "%s: read_piece %u successful"
 				, torrent_alert::message().c_str() , piece);
 		}
 		return msg;
@@ -184,7 +187,7 @@ namespace libtorrent {
 	std::string file_completed_alert::message() const
 	{
 		char msg[200 + TORRENT_MAX_PATH];
-		snprintf(msg, sizeof(msg), "%s: file %d finished downloading"
+		std::snprintf(msg, sizeof(msg), "%s: file %d finished downloading"
 			, torrent_alert::message().c_str(), index);
 		return msg;
 	}
@@ -213,7 +216,7 @@ namespace libtorrent {
 	std::string file_renamed_alert::message() const
 	{
 		char msg[200 + TORRENT_MAX_PATH * 2];
-		snprintf(msg, sizeof(msg), "%s: file %d renamed to %s"
+		std::snprintf(msg, sizeof(msg), "%s: file %d renamed to %s"
 			, torrent_alert::message().c_str(), index, new_name());
 		return msg;
 	}
@@ -230,7 +233,7 @@ namespace libtorrent {
 	std::string file_rename_failed_alert::message() const
 	{
 		char ret[200 + TORRENT_MAX_PATH * 2];
-		snprintf(ret, sizeof(ret), "%s: failed to rename file %d: %s"
+		std::snprintf(ret, sizeof(ret), "%s: failed to rename file %d: %s"
 			, torrent_alert::message().c_str(), index, convert_from_native(error.message()).c_str());
 		return ret;
 	}
@@ -314,7 +317,7 @@ namespace libtorrent {
 	std::string tracker_error_alert::message() const
 	{
 		char ret[400];
-		snprintf(ret, sizeof(ret), "%s (%d) %s \"%s\" (%d)"
+		std::snprintf(ret, sizeof(ret), "%s (%d) %s \"%s\" (%d)"
 			, tracker_alert::message().c_str(), status_code
 			, convert_from_native(error.message()).c_str(), error_message()
 			, times_in_row);
@@ -363,7 +366,7 @@ namespace libtorrent {
 	std::string scrape_reply_alert::message() const
 	{
 		char ret[400];
-		snprintf(ret, sizeof(ret), "%s scrape reply: %u %u"
+		std::snprintf(ret, sizeof(ret), "%s scrape reply: %u %u"
 			, tracker_alert::message().c_str(), incomplete, complete);
 		return ret;
 	}
@@ -424,7 +427,7 @@ namespace libtorrent {
 	std::string tracker_reply_alert::message() const
 	{
 		char ret[400];
-		snprintf(ret, sizeof(ret), "%s received peers: %u"
+		std::snprintf(ret, sizeof(ret), "%s received peers: %u"
 			, tracker_alert::message().c_str(), num_peers);
 		return ret;
 	}
@@ -439,7 +442,7 @@ namespace libtorrent {
 	std::string dht_reply_alert::message() const
 	{
 		char ret[400];
-		snprintf(ret, sizeof(ret), "%s received DHT peers: %u"
+		std::snprintf(ret, sizeof(ret), "%s received DHT peers: %u"
 			, tracker_alert::message().c_str(), num_peers);
 		return ret;
 	}
@@ -474,7 +477,7 @@ namespace libtorrent {
 	std::string hash_failed_alert::message() const
 	{
 		char ret[400];
-		snprintf(ret, sizeof(ret), "%s hash for piece %u failed"
+		std::snprintf(ret, sizeof(ret), "%s hash for piece %u failed"
 			, torrent_alert::message().c_str(), piece_index);
 		return ret;
 	}
@@ -526,7 +529,7 @@ namespace libtorrent {
 	std::string invalid_request_alert::message() const
 	{
 		char ret[200];
-		snprintf(ret, sizeof(ret), "%s peer sent an invalid piece request "
+		std::snprintf(ret, sizeof(ret), "%s peer sent an invalid piece request "
 			"(piece: %u start: %u len: %u)%s"
 			, peer_alert::message().c_str(), request.piece, request.start
 			, request.length
@@ -558,7 +561,7 @@ namespace libtorrent {
 	std::string piece_finished_alert::message() const
 	{
 		char ret[200];
-		snprintf(ret, sizeof(ret), "%s piece: %u finished downloading"
+		std::snprintf(ret, sizeof(ret), "%s piece: %u finished downloading"
 			, torrent_alert::message().c_str(), piece_index);
 		return ret;
 	}
@@ -576,7 +579,7 @@ namespace libtorrent {
 	std::string request_dropped_alert::message() const
 	{
 		char ret[200];
-		snprintf(ret, sizeof(ret), "%s peer dropped block ( piece: %u block: %u)"
+		std::snprintf(ret, sizeof(ret), "%s peer dropped block ( piece: %u block: %u)"
 			, torrent_alert::message().c_str(), piece_index, block_index);
 		return ret;
 	}
@@ -594,7 +597,7 @@ namespace libtorrent {
 	std::string block_timeout_alert::message() const
 	{
 		char ret[200];
-		snprintf(ret, sizeof(ret), "%s peer timed out request ( piece: %u block: %u)"
+		std::snprintf(ret, sizeof(ret), "%s peer timed out request ( piece: %u block: %u)"
 			, torrent_alert::message().c_str(), piece_index, block_index);
 		return ret;
 	}
@@ -612,7 +615,7 @@ namespace libtorrent {
 	std::string block_finished_alert::message() const
 	{
 		char ret[200];
-		snprintf(ret, sizeof(ret), "%s block finished downloading (piece: %u block: %u)"
+		std::snprintf(ret, sizeof(ret), "%s block finished downloading (piece: %u block: %u)"
 			, torrent_alert::message().c_str(), piece_index, block_index);
 		return ret;
 	}
@@ -633,7 +636,7 @@ namespace libtorrent {
 	std::string block_downloading_alert::message() const
 	{
 		char ret[200];
-		snprintf(ret, sizeof(ret), "%s requested block (piece: %u block: %u)"
+		std::snprintf(ret, sizeof(ret), "%s requested block (piece: %u block: %u)"
 			, torrent_alert::message().c_str(), piece_index, block_index);
 		return ret;
 	}
@@ -651,7 +654,7 @@ namespace libtorrent {
 	std::string unwanted_block_alert::message() const
 	{
 		char ret[200];
-		snprintf(ret, sizeof(ret), "%s received block not in download queue (piece: %u block: %u)"
+		std::snprintf(ret, sizeof(ret), "%s received block not in download queue (piece: %u block: %u)"
 			, torrent_alert::message().c_str(), piece_index, block_index);
 		return ret;
 	}
@@ -856,7 +859,7 @@ namespace libtorrent {
 			"bind_to_device"
 		};
 		char ret[300];
-		snprintf(ret, sizeof(ret), "listening on %s (device: %s) failed: [%s] [%s] %s"
+		std::snprintf(ret, sizeof(ret), "listening on %s (device: %s) failed: [%s] [%s] %s"
 			, print_endpoint(endpoint).c_str()
 			, listen_interface()
 			, op_str[operation]
@@ -921,7 +924,7 @@ namespace libtorrent {
 	{
 		char const* type_str[] = { "TCP", "SSL/TCP", "UDP", "i2p", "socks5", "SSL/uTP" };
 		char ret[200];
-		snprintf(ret, sizeof(ret), "successfully listening on [%s] %s"
+		std::snprintf(ret, sizeof(ret), "successfully listening on [%s] %s"
 			, type_str[sock_type], print_endpoint(endpoint).c_str());
 		return ret;
 	}
@@ -949,7 +952,7 @@ namespace libtorrent {
 	std::string portmap_alert::message() const
 	{
 		char ret[200];
-		snprintf(ret, sizeof(ret), "successfully mapped port using %s. external port: %s/%u"
+		std::snprintf(ret, sizeof(ret), "successfully mapped port using %s. external port: %s/%u"
 			, nat_type_str[map_type], protocol_str[protocol], external_port);
 		return ret;
 	}
@@ -977,7 +980,7 @@ namespace libtorrent {
 	std::string portmap_log_alert::message() const
 	{
 		char ret[600];
-		snprintf(ret, sizeof(ret), "%s: %s", nat_type_str[map_type]
+		std::snprintf(ret, sizeof(ret), "%s: %s", nat_type_str[map_type]
 			, log_message());
 		return ret;
 	}
@@ -1042,7 +1045,7 @@ namespace libtorrent {
 			"invalid_local_interface"
 		};
 
-		snprintf(ret, sizeof(ret), "%s: blocked peer: %s [%s]"
+		std::snprintf(ret, sizeof(ret), "%s: blocked peer: %s [%s]"
 			, torrent_alert::message().c_str(), ip.to_string(ec).c_str()
 			, reason_str[reason]);
 		return ret;
@@ -1062,7 +1065,7 @@ namespace libtorrent {
 		char ih_hex[41];
 		to_hex(info_hash.data(), 20, ih_hex);
 		char msg[200];
-		snprintf(msg, sizeof(msg), "incoming dht announce: %s:%u (%s)"
+		std::snprintf(msg, sizeof(msg), "incoming dht announce: %s:%u (%s)"
 			, ip.to_string(ec).c_str(), port, ih_hex);
 		return msg;
 	}
@@ -1077,7 +1080,7 @@ namespace libtorrent {
 		char ih_hex[41];
 		to_hex(info_hash.data(), 20, ih_hex);
 		char msg[200];
-		snprintf(msg, sizeof(msg), "incoming dht get_peers: %s", ih_hex);
+		std::snprintf(msg, sizeof(msg), "incoming dht get_peers: %s", ih_hex);
 		return msg;
 	}
 
@@ -1109,7 +1112,7 @@ namespace libtorrent {
 	std::string stats_alert::message() const
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), "%s: [%d] %d %d %d %d %d %d"
+		std::snprintf(msg, sizeof(msg), "%s: [%d] %d %d %d %d %d %d"
 #ifndef TORRENT_NO_DEPRECATE
 			" %d %d %d %d"
 #endif
@@ -1148,7 +1151,7 @@ namespace libtorrent {
 		char const* msgs[] = {
 			"tracker is not anonymous, set a proxy"
 		};
-		snprintf(msg, sizeof(msg), "%s: %s: %s"
+		std::snprintf(msg, sizeof(msg), "%s: %s: %s"
 			, torrent_alert::message().c_str()
 			, msgs[kind], str.c_str());
 		return msg;
@@ -1162,7 +1165,7 @@ namespace libtorrent {
 	std::string lsd_peer_alert::message() const
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), "%s: received peer from local service discovery"
+		std::snprintf(msg, sizeof(msg), "%s: received peer from local service discovery"
 			, peer_alert::message().c_str());
 		return msg;
 	}
@@ -1216,7 +1219,7 @@ namespace libtorrent {
 	std::string torrent_error_alert::message() const
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), " ERROR: %s", convert_from_native(error.message()).c_str());
+		std::snprintf(msg, sizeof(msg), " ERROR: %s", convert_from_native(error.message()).c_str());
 		return torrent_alert::message() + msg;
 	}
 
@@ -1266,7 +1269,7 @@ namespace libtorrent {
 	{
 		char msg[600];
 		error_code ec;
-		snprintf(msg, sizeof(msg), "incoming connection from %s (%s)"
+		std::snprintf(msg, sizeof(msg), "incoming connection from %s (%s)"
 			, print_endpoint(ip).c_str(), socket_type_str[socket_type]);
 		return msg;
 	}
@@ -1281,7 +1284,7 @@ namespace libtorrent {
 	{
 		char msg[600];
 		error_code ec;
-		snprintf(msg, sizeof(msg), "%s connecting to peer (%s)"
+		std::snprintf(msg, sizeof(msg), "%s connecting to peer (%s)"
 			, peer_alert::message().c_str(), socket_type_str[socket_type]);
 		return msg;
 	}
@@ -1305,13 +1308,13 @@ namespace libtorrent {
 
 		if (error)
 		{
-			snprintf(msg, sizeof(msg), "failed to add torrent \"%s\": [%s] %s"
+			std::snprintf(msg, sizeof(msg), "failed to add torrent \"%s\": [%s] %s"
 				, torrent_name, error.category().name()
 				, convert_from_native(error.message()).c_str());
 		}
 		else
 		{
-			snprintf(msg, sizeof(msg), "added torrent: %s", torrent_name);
+			std::snprintf(msg, sizeof(msg), "added torrent: %s", torrent_name);
 		}
 		return msg;
 	}
@@ -1324,7 +1327,7 @@ namespace libtorrent {
 	std::string state_update_alert::message() const
 	{
 		char msg[600];
-		snprintf(msg, sizeof(msg), "state updates for %d torrents", int(status.size()));
+		std::snprintf(msg, sizeof(msg), "state updates for %d torrents", int(status.size()));
 		return msg;
 	}
 
@@ -1335,7 +1338,7 @@ namespace libtorrent {
 	std::string mmap_cache_alert::message() const
 	{
 		char msg[600];
-		snprintf(msg, sizeof(msg), "mmap cache failed: (%d) %s", error.value()
+		std::snprintf(msg, sizeof(msg), "mmap cache failed: (%d) %s", error.value()
 			, convert_from_native(error.message()).c_str());
 		return msg;
 	}
@@ -1355,7 +1358,7 @@ namespace libtorrent {
 	std::string peer_error_alert::message() const
 	{
 		char buf[200];
-		snprintf(buf, sizeof(buf), "%s peer error [%s] [%s]: %s"
+		std::snprintf(buf, sizeof(buf), "%s peer error [%s] [%s]: %s"
 			, peer_alert::message().c_str()
 			, operation_name(operation), error.category().name()
 			, convert_from_native(error.message()).c_str());
@@ -1402,7 +1405,7 @@ namespace libtorrent {
 	std::string torrent_update_alert::message() const
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), " torrent changed info-hash from: %s to %s"
+		std::snprintf(msg, sizeof(msg), " torrent changed info-hash from: %s to %s"
 			, to_hex(old_ih.to_string()).c_str()
 			, to_hex(new_ih.to_string()).c_str());
 		return torrent_alert::message() + msg;
@@ -1427,7 +1430,7 @@ namespace libtorrent {
 	std::string peer_disconnected_alert::message() const
 	{
 		char buf[600];
-		snprintf(buf, sizeof(buf), "%s disconnecting (%s) [%s] [%s]: %s (reason: %d)"
+		std::snprintf(buf, sizeof(buf), "%s disconnecting (%s) [%s] [%s]: %s (reason: %d)"
 			, peer_alert::message().c_str()
 			, socket_type_str[socket_type]
 			, operation_name(operation), error.category().name()
@@ -1454,7 +1457,7 @@ namespace libtorrent {
 			op = 0;
 
 		char msg[600];
-		snprintf(msg, sizeof(msg), "DHT error [%s] (%d) %s"
+		std::snprintf(msg, sizeof(msg), "DHT error [%s] (%d) %s"
 			, operation_names[op]
 			, error.value()
 			, convert_from_native(error.message()).c_str());
@@ -1469,7 +1472,7 @@ namespace libtorrent {
 	std::string dht_immutable_item_alert::message() const
 	{
 		char msg[1050];
-		snprintf(msg, sizeof(msg), "DHT immutable item %s [ %s ]"
+		std::snprintf(msg, sizeof(msg), "DHT immutable item %s [ %s ]"
 			, to_hex(target.to_string()).c_str()
 			, item.to_string().c_str());
 		return msg;
@@ -1490,7 +1493,7 @@ namespace libtorrent {
 	std::string dht_mutable_item_alert::message() const
 	{
 		char msg[1050];
-		snprintf(msg, sizeof(msg), "DHT mutable item (key=%s salt=%s seq=%" PRId64 " %s) [ %s ]"
+		std::snprintf(msg, sizeof(msg), "DHT mutable item (key=%s salt=%s seq=%" PRId64 " %s) [ %s ]"
 			, to_hex(std::string(&key[0], 32)).c_str()
 			, salt.c_str()
 			, seq
@@ -1524,7 +1527,7 @@ namespace libtorrent {
 		char msg[1050];
 		if (target.is_all_zeros())
 		{
-			snprintf(msg, sizeof(msg), "DHT put complete (success=%d key=%s sig=%s salt=%s seq=%" PRId64 ")"
+			std::snprintf(msg, sizeof(msg), "DHT put complete (success=%d key=%s sig=%s salt=%s seq=%" PRId64 ")"
 				, num_success
 				, to_hex(std::string(&public_key[0], 32)).c_str()
 				, to_hex(std::string(&signature[0], 64)).c_str()
@@ -1533,7 +1536,7 @@ namespace libtorrent {
 			return msg;
 		}
 
-		snprintf(msg, sizeof(msg), "DHT put commplete (success=%d hash=%s)"
+		std::snprintf(msg, sizeof(msg), "DHT put commplete (success=%d hash=%s)"
 			, num_success
 			, to_hex(target.to_string()).c_str());
 		return msg;
@@ -1546,7 +1549,7 @@ namespace libtorrent {
 	std::string i2p_alert::message() const
 	{
 		char msg[600];
-		snprintf(msg, sizeof(msg), "i2p_error: [%s] %s"
+		std::snprintf(msg, sizeof(msg), "i2p_error: [%s] %s"
 			, error.category().name(), convert_from_native(error.message()).c_str());
 		return msg;
 	}
@@ -1566,10 +1569,10 @@ namespace libtorrent {
 		obf[0] = '\0';
 		if (obfuscated_info_hash != info_hash)
 		{
-			snprintf(obf, sizeof(obf), " [obfuscated: %s]"
+			std::snprintf(obf, sizeof(obf), " [obfuscated: %s]"
 			, to_hex(obfuscated_info_hash.to_string()).c_str());
 		}
-		snprintf(msg, sizeof(msg), "outgoing dht get_peers : %s%s -> %s"
+		std::snprintf(msg, sizeof(msg), "outgoing dht get_peers : %s%s -> %s"
 			, to_hex(info_hash.to_string()).c_str()
 			, obf
 			, print_endpoint(ip).c_str());
@@ -1658,13 +1661,13 @@ namespace libtorrent {
 		// this specific output is parsed by tools/parse_session_stats.py
 		// if this is changed, that parser should also be changed
 		char msg[100];
-		snprintf(msg, sizeof(msg), "session stats (%d values): "
+		std::snprintf(msg, sizeof(msg), "session stats (%d values): "
 			, int(sizeof(values)/sizeof(values[0])));
 		std::string ret = msg;
 		bool first = true;
 		for (int i = 0; i < sizeof(values)/sizeof(values[0]); ++i)
 		{
-			snprintf(msg, sizeof(msg), first ? "%" PRIu64 : ", %" PRIu64, values[i]);
+			std::snprintf(msg, sizeof(msg), first ? "%" PRIu64 : ", %" PRIu64, values[i]);
 			first = false;
 			ret += msg;
 		}
@@ -1682,7 +1685,7 @@ namespace libtorrent {
 	std::string dht_stats_alert::message() const
 	{
 		char buf[2048];
-		snprintf(buf, sizeof(buf), "DHT stats: reqs: %d buckets: %d"
+		std::snprintf(buf, sizeof(buf), "DHT stats: reqs: %d buckets: %d"
 			, int(active_requests.size())
 			, int(routing_table.size()));
 		return buf;
@@ -1772,7 +1775,7 @@ namespace libtorrent {
 	std::string incoming_request_alert::message() const
 	{
 		char msg[1024];
-		snprintf(msg, sizeof(msg), "%s: incoming request [ piece: %d start: %d length: %d ]"
+		std::snprintf(msg, sizeof(msg), "%s: incoming request [ piece: %d start: %d length: %d ]"
 			, peer_alert::message().c_str(), req.piece, req.start, req.length);
 		return msg;
 	}
@@ -1801,7 +1804,7 @@ namespace libtorrent {
 		};
 
 		char ret[900];
-		snprintf(ret, sizeof(ret), "DHT %s: %s", dht_modules[module]
+		std::snprintf(ret, sizeof(ret), "DHT %s: %s", dht_modules[module]
 			, log_message());
 		return ret;
 	}
@@ -1838,7 +1841,7 @@ namespace libtorrent {
 
 		char const* prefix[2] = { "<==", "==>"};
 		char buf[1024];
-		snprintf(buf, sizeof(buf), "%s [%s] %s", prefix[dir]
+		std::snprintf(buf, sizeof(buf), "%s [%s] %s", prefix[dir]
 			, print_endpoint(node).c_str(), msg.c_str());
 
 		return buf;
@@ -1874,7 +1877,7 @@ namespace libtorrent {
 		char ih_hex[41];
 		to_hex(info_hash.data(), 20, ih_hex);
 		char msg[200];
-		snprintf(msg, sizeof(msg), "incoming dht get_peers reply: %s, peers %d", ih_hex, m_num_peers);
+		std::snprintf(msg, sizeof(msg), "incoming dht get_peers reply: %s, peers %d", ih_hex, m_num_peers);
 		return msg;
 	}
 
@@ -1922,7 +1925,7 @@ namespace libtorrent {
 	std::string dht_direct_response_alert::message() const
 	{
 		char msg[1050];
-		snprintf(msg, sizeof(msg), "DHT direct response (address=%s) [ %s ]"
+		std::snprintf(msg, sizeof(msg), "DHT direct response (address=%s) [ %s ]"
 			, addr.address().to_string().c_str()
 			, m_response_size ? std::string(m_alloc.get().ptr(m_response_idx), m_response_size).c_str() : "");
 		return msg;
@@ -2004,7 +2007,7 @@ namespace libtorrent {
 		for (int i = 0; i < int(b.size()); ++i)
 		{
 			char buf[50];
-			snprintf(buf, sizeof(buf), "(%d,%d) "
+			std::snprintf(buf, sizeof(buf), "(%d,%d) "
 				, b[i].piece_index, b[i].block_index);
 			ret += buf;
 		}

src/allocator.cpp

@@ -147,7 +147,7 @@ namespace libtorrent
 #undef mprotect
 #undef PROT_READ
 #endif
-//		fprintf(stderr, "malloc: %p head: %p tail: %p size: %d\n", ret + page, ret, ret + page + bytes, int(bytes));
+//		std::fprintf(stderr, "malloc: %p head: %p tail: %p size: %d\n", ret + page, ret, ret + page + bytes, int(bytes));
 
 		return static_cast<char*>(ret) + page;
 #else
@@ -173,7 +173,7 @@ namespace libtorrent
 		const int num_pages = (h->size + (page-1)) / page + 2;
 		TORRENT_ASSERT(h->magic == 0x1337);
 		mprotect(block + (num_pages-2) * page, page, PROT_READ | PROT_WRITE);
-//		fprintf(stderr, "free: %p head: %p tail: %p size: %d\n", block, block - page, block + h->size, int(h->size));
+//		std::fprintf(stderr, "free: %p head: %p tail: %p size: %d\n", block, block - page, block + h->size, int(h->size));
 		h->magic = 0;
 		block -= page;
 

src/assert.cpp

@@ -52,7 +52,9 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <cstring>
 #include <stdlib.h>
-#include <stdarg.h>
+#include <cstdarg>
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
 #include <array>
 
 #include "libtorrent/aux_/disable_warnings_pop.hpp"
@@ -133,7 +135,7 @@ TORRENT_EXPORT void print_backtrace(char* out, int len, int max_depth, void*)
 
 	for (int i = 1; i < size && len > 0; ++i)
 	{
-		int ret = snprintf(out, len, "%d: %s\n", i, demangle(symbols[i]).c_str());
+		int ret = std::snprintf(out, len, "%d: %s\n", i, demangle(symbols[i]).c_str());
 		out += ret;
 		len -= ret;
 		if (i - 1 == max_depth && max_depth > 0) break;
@@ -225,25 +227,25 @@ TORRENT_EXPORT void print_backtrace(char* out, int len, int max_depth
 		BOOL const has_line = SymGetLineFromAddr64(GetCurrentProcess(), frame_ptr,
 			&line_displacement, &line);
 
-		int ret = snprintf(out, len, "%2d: %p", i, stack[i]);
+		int ret = std::snprintf(out, len, "%2d: %p", i, stack[i]);
 		out += ret; len -= ret; if (len <= 0) break;
 
 		if (has_symbol)
 		{
-			ret = snprintf(out, len, " %s +%-4" PRId64 " "
+			ret = std::snprintf(out, len, " %s +%-4" PRId64
 				, demangle(symbol.Name).c_str(), displacement);
 			out += ret; len -= ret; if (len <= 0) break;
 		}
 
 		if (has_line)
 		{
-			ret = snprintf(out, len, " %s:%d"
+			ret = std::snprintf(out, len, " %s:%d"
 				, line.FileName, line.LineNumber);
 			out += ret; len -= ret; if (len <= 0) break;
 		}
 
 
-		ret = snprintf(out, len, "\n");
+		ret = std::snprintf(out, len, "\n");
 		out += ret;
 		len -= ret;
 

src/bandwidth_limit.cpp

@@ -50,7 +50,7 @@ namespace libtorrent
 		TORRENT_ASSERT(limit < INT_MAX);
 		m_limit = limit;
 	}
-	
+
 	int bandwidth_channel::quota_left() const
 	{
 		if (m_limit == 0) return inf;
@@ -63,9 +63,6 @@ namespace libtorrent
 		m_quota_left += (m_limit * dt_milliseconds + 500) / 1000;
 		if (m_quota_left > m_limit * 3) m_quota_left = m_limit * 3;
 		distribute_quota = int((std::max)(m_quota_left, boost::int64_t(0)));
-//		fprintf(stderr, "%p: [%d]: + %"PRId64" limit: %"PRId64" quota_left: %"PRId64"\n", this
-//			, dt_milliseconds, (m_limit * dt_milliseconds + 500) / 1000, m_limit
-//			, m_quota_left);
 	}
 
 	// this is used when connections disconnect with
@@ -85,8 +82,6 @@ namespace libtorrent
 		TORRENT_ASSERT(m_limit >= 0);
 		if (m_limit == 0) return;
 
-//		fprintf(stderr, "%p: - %"PRId64" limit: %"PRId64" quota_left: %"PRId64"\n", this
-//			, amount, m_limit, m_quota_left);
 		m_quota_left -= amount;
 	}
 

src/bdecode.cpp

@@ -35,6 +35,8 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <boost/system/error_code.hpp>
 #include <limits>
 #include <cstring> // for memset
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
 
 #ifndef BOOST_SYSTEM_NOEXCEPT
 #define BOOST_SYSTEM_NOEXCEPT throw()
@@ -974,7 +976,7 @@ done:
 			else
 			{
 				char tmp[5];
-				snprintf(tmp, sizeof(tmp), "\\x%02x", std::uint8_t(str[i]));
+				std::snprintf(tmp, sizeof(tmp), "\\x%02x", std::uint8_t(str[i]));
 				ret += tmp;
 			}
 		}
@@ -1036,7 +1038,7 @@ done:
 			case bdecode_node::int_t:
 			{
 				char str[100];
-				snprintf(str, sizeof(str), "%" PRId64, e.int_value());
+				std::snprintf(str, sizeof(str), "%" PRId64, e.int_value());
 				return str;
 			}
 			case bdecode_node::string_t:

src/block_cache.cpp

@@ -158,7 +158,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #if __cplusplus >= 201103L || defined __clang__
 
 #if DEBUG_CACHE
-#define DLOG(...) fprintf(__VA_ARGS__)
+#define DLOG(...) std::fprintf(__VA_ARGS__)
 #else
 #define DLOG(...) do {} while (false)
 #endif
@@ -181,10 +181,10 @@ void log_refcounts(cached_piece_entry const* pe)
 	char out[4096];
 	char* ptr = out;
 	char* end = ptr + sizeof(out);
-	ptr += snprintf(ptr, end - ptr, "piece: %d [ ", int(pe->piece));
+	ptr += std::snprintf(ptr, end - ptr, "piece: %d [ ", int(pe->piece));
 	for (int i = 0; i < pe->blocks_in_piece; ++i)
 	{
-		ptr += snprintf(ptr, end - ptr, "%d ", int(pe->blocks[i].refcount));
+		ptr += std::snprintf(ptr, end - ptr, "%d ", int(pe->blocks[i].refcount));
 	}
 	strncpy(ptr, "]\n", end - ptr);
 	DLOG(stderr, out);
@@ -252,11 +252,11 @@ static_assert(sizeof(job_action_name)/sizeof(job_action_name[0])
 		{
 			if (piece_log[i].block == -1)
 			{
-				printf("%d: %s\n", i, job_name(piece_log[i].job));
+				std::printf("%d: %s\n", i, job_name(piece_log[i].job));
 			}
 			else
 			{
-				printf("%d: %s %d\n", i, job_name(piece_log[i].job), piece_log[i].block);
+				std::printf("%d: %s %d\n", i, job_name(piece_log[i].job), piece_log[i].block);
 			}
 		}
 	}

src/broadcast_socket.cpp

@@ -210,7 +210,7 @@ namespace libtorrent
 #endif
 			open_multicast_socket(ios, i->interface_address, loopback, ec);
 #ifdef TORRENT_DEBUG
-			fprintf(stderr, "broadcast socket [ if: %s group: %s mask: %s ] %s\n"
+			std::fprintf(stderr, "broadcast socket [ if: %s group: %s mask: %s ] %s\n"
 				, i->interface_address.to_string().c_str()
 				, m_multicast_endpoint.address().to_string().c_str()
 				, i->netmask.to_string().c_str()

src/disk_io_thread.cpp

@@ -112,7 +112,7 @@ namespace libtorrent
 		va_end(v);
 		char buf[2300];
 		int t = total_milliseconds(clock_type::now() - start);
-		snprintf(buf, sizeof(buf), "%05d: [%p] %s", t, pthread_self(), usr);
+		std::snprintf(buf, sizeof(buf), "%05d: [%p] %s", t, pthread_self(), usr);
 		prepend_time = (usr[len-1] == '\n');
 		std::unique_lock<std::mutex> l(log_mutex);
 		fputs(buf, stderr);
@@ -1785,7 +1785,7 @@ namespace libtorrent
 
 		disk_io_job* j = allocate_job(disk_io_job::move_storage);
 		j->storage = storage->shared_from_this();
-		j->buffer.string = strdup(p.c_str());
+		j->buffer.string = allocate_string_copy(p.c_str());
 		j->callback = handler;
 		j->flags = flags;
 
@@ -1890,7 +1890,7 @@ namespace libtorrent
 		disk_io_job* j = allocate_job(disk_io_job::rename_file);
 		j->storage = storage->shared_from_this();
 		j->piece = index;
-		j->buffer.string = strdup(name.c_str());
+		j->buffer.string = allocate_string_copy(name.c_str());
 		j->callback = handler;
 		add_fence_job(storage, j);
 	}

src/escape_string.cpp

@@ -32,18 +32,12 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "libtorrent/config.hpp"
 
-#include "libtorrent/aux_/disable_warnings_push.hpp"
-
 #include <string>
 #include <cctype>
 #include <algorithm>
 #include <mutex>
-#include <boost/limits.hpp>
 #include <cstring>
-
-#include <boost/optional.hpp>
 #include <array>
-#include <boost/tuple/tuple.hpp>
 
 #ifdef TORRENT_WINDOWS
 #ifndef WIN32_LEAN_AND_MEAN
@@ -57,14 +51,13 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <locale.h>
 #endif
 
-#include "libtorrent/aux_/disable_warnings_pop.hpp"
-
 #include "libtorrent/assert.hpp"
 #include "libtorrent/parse_url.hpp"
 #include "libtorrent/random.hpp"
 
 #include "libtorrent/utf8.hpp"
 #include "libtorrent/aux_/escape_string.hpp"
+#include "libtorrent/aux_/max_path.hpp" // for TORRENT_MAX_PATH
 #include "libtorrent/string_util.hpp" // for to_string
 
 namespace libtorrent
@@ -228,13 +221,13 @@ namespace libtorrent
 		error_code ec;
 		boost::tie(protocol, auth, host, port, path) = parse_url_components(url, ec);
 		if (ec) return url;
-		
+
 		// first figure out if this url contains unencoded characters
 		if (!need_encoding(path.c_str(), int(path.size())))
 			return url;
 
 		char msg[TORRENT_MAX_PATH*4];
-		snprintf(msg, sizeof(msg), "%s://%s%s%s%s%s%s", protocol.c_str(), auth.c_str()
+		std::snprintf(msg, sizeof(msg), "%s://%s%s%s%s%s%s", protocol.c_str(), auth.c_str()
 			, auth.empty()?"":"@", host.c_str()
 			, port == -1 ? "" : ":"
 			, port == -1 ? "" : to_string(port).data()

src/file.cpp

@@ -65,6 +65,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/allocator.hpp" // page_size
 #include "libtorrent/file.hpp"
 #include "libtorrent/error_code.hpp"
+#include "libtorrent/aux_/max_path.hpp" // for TORRENT_MAX_PATH
 #include <cstring>
 #include <vector>
 
@@ -85,6 +86,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 #include <sys/stat.h>
+#include <limits.h> // for IOV_MAX
 
 #ifdef TORRENT_WINDOWS
 // windows part
@@ -967,7 +969,7 @@ namespace libtorrent
 		std::string ret;
 		int target_size = int(lhs.size() + rhs.size() + 2);
 		ret.resize(target_size);
-		target_size = snprintf(&ret[0], target_size, "%s%s%s", lhs.c_str()
+		target_size = std::snprintf(&ret[0], target_size, "%s%s%s", lhs.c_str()
 			, (need_sep?TORRENT_SEPARATOR:""), rhs.c_str());
 		ret.resize(target_size);
 		return ret;
@@ -1571,7 +1573,7 @@ namespace libtorrent
 	void file::print_info(FILE* out) const
 	{
 		if (!is_open()) return;
-		fprintf(out, "\n===> FILE: %s\n", m_file_path.c_str());
+		std::fprintf(out, "\n===> FILE: %s\n", m_file_path.c_str());
 	}
 #endif
 
@@ -1749,7 +1751,12 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER {
 		int ret = 0;
 		while (num_bufs > 0)
 		{
-			int nbufs = (std::min)(num_bufs, TORRENT_IOV_MAX);
+#ifdef IOV_MAX
+			int const nbufs = (std::min)(num_bufs, IOV_MAX);
+#else
+			int const nbufs = num_bufs;
+#endif
+
 			int tmp_ret = 0;
 			tmp_ret = f(fd, bufs, nbufs, file_offset);
 			if (tmp_ret < 0)
@@ -2347,7 +2354,7 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER {
 	{
 		FILE* out = fopen("open_files.log", "a+");
 		std::lock_guard<std::mutex> l(file_handle_mutex);
-		fprintf(out, "\n\nEVENT: %s TORRENT: %s\n\n", event, name);
+		std::fprintf(out, "\n\nEVENT: %s TORRENT: %s\n\n", event, name);
 		for (std::set<file_handle*>::iterator i = global_file_handles.begin()
 			, end(global_file_handles.end()); i != end; ++i)
 		{
@@ -2358,7 +2365,7 @@ typedef struct _FILE_ALLOCATED_RANGE_BUFFER {
 
 			if (!h->is_open()) continue;
 			h->print_info(out);
-			fprintf(out, "\n%s\n\n", h.stack);
+			std::fprintf(out, "\n%s\n\n", h.stack);
 		}
 		fclose(out);
 	}

src/file_storage.cpp

@@ -1065,7 +1065,7 @@ namespace libtorrent
 		e.size = size;
 		e.offset = offset;
 		char name[30];
-		snprintf(name, sizeof(name), ".____padding_file/%d", pad_file_counter);
+		std::snprintf(name, sizeof(name), ".____padding_file/%d", pad_file_counter);
 		std::string path = combine_path(m_name, name);
 		e.set_name(path.c_str());
 		e.pad_file = true;

src/http_connection.cpp

@@ -169,9 +169,9 @@ void http_connection::get(std::string const& url, time_duration timeout, int pri
 	char* end = request + sizeof(request);
 	char* ptr = request;
 
-#define APPEND_FMT(fmt) ptr += snprintf(ptr, end - ptr, fmt)
+#define APPEND_FMT(fmt) ptr += std::snprintf(ptr, end - ptr, fmt)
-#define APPEND_FMT1(fmt, arg) ptr += snprintf(ptr, end - ptr, fmt, arg)
+#define APPEND_FMT1(fmt, arg) ptr += std::snprintf(ptr, end - ptr, fmt, arg)
-#define APPEND_FMT2(fmt, arg1, arg2) ptr += snprintf(ptr, end - ptr, fmt, arg1, arg2)
+#define APPEND_FMT2(fmt, arg1, arg2) ptr += std::snprintf(ptr, end - ptr, fmt, arg1, arg2)
 
 	// exclude ssl here, because SSL assumes CONNECT support in the
 	// proxy and is handled at the lower layer

src/http_parser.cpp

@@ -259,7 +259,7 @@ restart_response:
 					// we're done once we reach the end of the headers
 //					if (!m_method.empty()) m_finished = true;
 					// the HTTP header should always be < 2 GB
-					TORRENT_ASSERT(m_recv_pos < INT_MAX);
+					TORRENT_ASSERT(m_recv_pos < (std::numeric_limits<int>::max)());
 					m_body_start_pos = int(m_recv_pos);
 					break;
 				}
@@ -337,7 +337,7 @@ restart_response:
 					boost::int64_t payload = m_cur_chunk_end - m_recv_pos;
 					if (payload > 0)
 					{
-						TORRENT_ASSERT(payload < INT_MAX);
+						TORRENT_ASSERT(payload < (std::numeric_limits<int>::max)());
 						m_recv_pos += payload;
 						boost::get<0>(ret) += int(payload);
 						incoming -= int(payload);
@@ -362,7 +362,7 @@ restart_response:
 						}
 						header_size -= m_partial_chunk_header;
 						m_partial_chunk_header = 0;
-//						fprintf(stderr, "parse_chunk_header(%d, -> %d, -> %d) -> %d\n"
+//						std::fprintf(stderr, "parse_chunk_header(%d, -> %d, -> %d) -> %d\n"
 //							"  incoming = %d\n  m_recv_pos = %d\n  m_cur_chunk_end = %d\n"
 //							"  content-length = %d\n"
 //							, buf.left(), int(chunk_size), header_size, 1, incoming, int(m_recv_pos)
@@ -373,7 +373,7 @@ restart_response:
 						m_partial_chunk_header += incoming;
 						header_size = incoming;
 						
-//						fprintf(stderr, "parse_chunk_header(%d, -> %d, -> %d) -> %d\n"
+//						std::fprintf(stderr, "parse_chunk_header(%d, -> %d, -> %d) -> %d\n"
 //							"  incoming = %d\n  m_recv_pos = %d\n  m_cur_chunk_end = %d\n"
 //							"  content-length = %d\n"
 //							, buf.left(), int(chunk_size), header_size, 0, incoming, int(m_recv_pos)
@@ -397,7 +397,8 @@ restart_response:
 				if (payload_received > m_content_length
 					&& m_content_length >= 0)
 				{
-					TORRENT_ASSERT(m_content_length - m_recv_pos + m_body_start_pos < INT_MAX);
+					TORRENT_ASSERT(m_content_length - m_recv_pos + m_body_start_pos
+						< (std::numeric_limits<int>::max)());
 					incoming = int(m_content_length - m_recv_pos + m_body_start_pos);
 				}
 
@@ -415,7 +416,7 @@ restart_response:
 		}
 		return ret;
 	}
-	
+
 	bool http_parser::parse_chunk_header(buffer::const_interval buf
 		, boost::int64_t* chunk_size, int* header_size)
 	{
@@ -494,7 +495,7 @@ restart_response:
 				++separator;
 			std::string value = line.substr(separator, std::string::npos);
 			tail_headers.insert(std::make_pair(name, value));
-//			fprintf(stderr, "tail_header: %s: %s\n", name.c_str(), value.c_str());
+//			std::fprintf(stderr, "tail_header: %s: %s\n", name.c_str(), value.c_str());
 
 			newline = std::find(pos, buf.end, '\n');
 		}
@@ -551,7 +552,7 @@ restart_response:
 		for (std::vector<std::pair<boost::int64_t, boost::int64_t> >::const_iterator i = c.begin()
 			, end(c.end()); i != end; ++i)
 		{
-			TORRENT_ASSERT(i->second - i->first < INT_MAX);
+			TORRENT_ASSERT(i->second - i->first < (std::numeric_limits<int>::max)());
 			TORRENT_ASSERT(i->second - offset <= size);
 			int len = int(i->second - i->first);
 			if (i->first - offset + len > size) len = size - int(i->first) + offset;

src/http_seed_connection.cpp

@@ -34,12 +34,14 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "libtorrent/aux_/disable_warnings_push.hpp"
 
-#include <vector>
-#include <boost/limits.hpp>
 #include <boost/bind.hpp>
 
 #include "libtorrent/aux_/disable_warnings_pop.hpp"
 
+#include <vector>
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
+
 #include "libtorrent/http_seed_connection.hpp"
 #include "libtorrent/session.hpp"
 #include "libtorrent/identify_client.hpp"

src/http_tracker_connection.cpp

@@ -36,14 +36,16 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "libtorrent/aux_/disable_warnings_push.hpp"
 
+#include <boost/bind.hpp>
+
+#include "libtorrent/aux_/disable_warnings_pop.hpp"
+
 #include <vector>
 #include <list>
 #include <cctype>
 #include <algorithm>
-
+#include <cstdio> // for snprintf
-#include <boost/bind.hpp>
+#include <cinttypes> // for PRId64 et.al.
-
-#include "libtorrent/aux_/disable_warnings_pop.hpp"
 
 #include "libtorrent/tracker_manager.hpp"
 #include "libtorrent/http_tracker_connection.hpp"
@@ -119,7 +121,7 @@ namespace libtorrent
 
 			char str[1024];
 			const bool stats = tracker_req().send_stats;
-			snprintf(str, sizeof(str)
+			std::snprintf(str, sizeof(str)
 				, "&peer_id=%s"
 				"&port=%d"
 				"&uploaded=%" PRId64

src/i2p_stream.cpp

@@ -259,7 +259,7 @@ namespace libtorrent
 		ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
 		async_write(m_sock, boost::asio::buffer(cmd, sizeof(cmd) - 1)
 			, boost::bind(&i2p_stream::start_read_line, this, _1, h));
-//		fprintf(stderr, ">>> %s", cmd);
+//		std::fprintf(stderr, ">>> %s", cmd);
 	}
 
 	void i2p_stream::start_read_line(error_code const& e, boost::shared_ptr<handler_type> h)
@@ -336,7 +336,7 @@ namespace libtorrent
 				break;
 		}
 
-//		fprintf(stderr, "<<< %s\n", &m_buffer[0]);
+//		std::fprintf(stderr, "<<< %s\n", &m_buffer[0]);
 		ptr = string_tokenize(next, ' ', &next);
 		if (ptr == 0 || expect1 == 0 || strcmp(expect1, ptr)) { handle_error(invalid_response, h); return; }
 		ptr = string_tokenize(next, ' ', &next);
@@ -350,10 +350,10 @@ namespace libtorrent
 		{
 			char* name = string_tokenize(next, '=', &next);
 			if (name == 0) break;
-//			fprintf(stderr, "name=\"%s\"\n", name);
+//			std::fprintf(stderr, "name=\"%s\"\n", name);
 			char* ptr2 = string_tokenize(next, ' ', &next);
 			if (ptr2 == 0) { handle_error(invalid_response, h); return; }
-//			fprintf(stderr, "value=\"%s\"\n", ptr2);
+//			std::fprintf(stderr, "value=\"%s\"\n", ptr2);
 
 			if (strcmp("RESULT", name) == 0)
 			{
@@ -453,9 +453,9 @@ namespace libtorrent
 		TORRENT_ASSERT(m_magic == 0x1337);
 		m_state = read_connect_response;
 		char cmd[1024];
-		int size = snprintf(cmd, sizeof(cmd), "STREAM CONNECT ID=%s DESTINATION=%s\n"
+		int size = std::snprintf(cmd, sizeof(cmd), "STREAM CONNECT ID=%s DESTINATION=%s\n"
 			, m_id, m_dest.c_str());
-//		fprintf(stderr, ">>> %s", cmd);
+//		std::fprintf(stderr, ">>> %s", cmd);
 		ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
 		async_write(m_sock, boost::asio::buffer(cmd, size)
 			, boost::bind(&i2p_stream::start_read_line, this, _1, h));
@@ -466,8 +466,8 @@ namespace libtorrent
 		TORRENT_ASSERT(m_magic == 0x1337);
 		m_state = read_accept_response;
 		char cmd[400];
-		int size = snprintf(cmd, sizeof(cmd), "STREAM ACCEPT ID=%s\n", m_id);
+		int size = std::snprintf(cmd, sizeof(cmd), "STREAM ACCEPT ID=%s\n", m_id);
-//		fprintf(stderr, ">>> %s", cmd);
+//		std::fprintf(stderr, ">>> %s", cmd);
 		ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
 		async_write(m_sock, boost::asio::buffer(cmd, size)
 			, boost::bind(&i2p_stream::start_read_line, this, _1, h));
@@ -478,9 +478,9 @@ namespace libtorrent
 		TORRENT_ASSERT(m_magic == 0x1337);
 		m_state = read_session_create_response;
 		char cmd[400];
-		int size = snprintf(cmd, sizeof(cmd), "SESSION CREATE STYLE=STREAM ID=%s DESTINATION=TRANSIENT\n"
+		int size = std::snprintf(cmd, sizeof(cmd), "SESSION CREATE STYLE=STREAM ID=%s DESTINATION=TRANSIENT\n"
 			, m_id);
-//		fprintf(stderr, ">>> %s", cmd);
+//		std::fprintf(stderr, ">>> %s", cmd);
 		ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
 		async_write(m_sock, boost::asio::buffer(cmd, size)
 			, boost::bind(&i2p_stream::start_read_line, this, _1, h));
@@ -491,8 +491,8 @@ namespace libtorrent
 		TORRENT_ASSERT(m_magic == 0x1337);
 		m_state = read_name_lookup_response;
 		char cmd[1024];
-		int size = snprintf(cmd, sizeof(cmd), "NAMING LOOKUP NAME=%s\n", m_name_lookup.c_str());
+		int size = std::snprintf(cmd, sizeof(cmd), "NAMING LOOKUP NAME=%s\n", m_name_lookup.c_str());
-//		fprintf(stderr, ">>> %s", cmd);
+//		std::fprintf(stderr, ">>> %s", cmd);
 		ADD_OUTSTANDING_ASYNC("i2p_stream::start_read_line");
 		async_write(m_sock, boost::asio::buffer(cmd, size)
 			, boost::bind(&i2p_stream::start_read_line, this, _1, h));

src/identify_client.cpp

@@ -322,12 +322,12 @@ namespace
 			name = temp;
 		}
 
-		int num_chars = snprintf(identity, sizeof(identity), "%s %u.%u.%u", name
+		int num_chars = std::snprintf(identity, sizeof(identity), "%s %u.%u.%u", name
 			, f.major_version, f.minor_version, f.revision_version);
 
 		if (f.tag_version != 0)
 		{
-			snprintf(identity + num_chars, sizeof(identity) - num_chars
+			std::snprintf(identity + num_chars, sizeof(identity) - num_chars
 				, ".%u", f.tag_version);
 		}
 

src/kademlia/dht_storage.cpp

@@ -379,7 +379,7 @@ namespace
 				m_counters.immutable_data += 1;
 			}
 
-//			fprintf(stderr, "added immutable item (%d)\n", int(m_immutable_table.size()));
+//			std::fprintf(stderr, "added immutable item (%d)\n", int(m_immutable_table.size()));
 
 			touch_item(&i->second, addr);
 		}
@@ -462,7 +462,7 @@ namespace
 					std::make_pair(target, to_add));
 				m_counters.mutable_data += 1;
 
-//				fprintf(stderr, "added mutable item (%d)\n", int(m_mutable_table.size()));
+//				std::fprintf(stderr, "added mutable item (%d)\n", int(m_mutable_table.size()));
 			}
 			else
 			{

src/kademlia/item.cpp

@@ -35,6 +35,9 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <libtorrent/bencode.hpp>
 #include <libtorrent/ed25519.hpp>
 
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
+
 #ifdef TORRENT_DEBUG
 #include "libtorrent/bdecode.hpp"
 #endif
@@ -63,13 +66,13 @@ namespace
 		int left = canonical_length - (ptr - out);
 		if (salt.second > 0)
 		{
-			ptr += snprintf(ptr, left, "4:salt%d:", salt.second);
+			ptr += std::snprintf(ptr, left, "4:salt%d:", salt.second);
 			left = canonical_length - (ptr - out);
 			memcpy(ptr, salt.first, (std::min)(salt.second, left));
 			ptr += (std::min)(salt.second, left);
 			left = canonical_length - (ptr - out);
 		}
-		ptr += snprintf(ptr, canonical_length - (ptr - out)
+		ptr += std::snprintf(ptr, canonical_length - (ptr - out)
 			, "3:seqi%" PRId64 "e1:v", seq);
 		left = canonical_length - (ptr - out);
 		memcpy(ptr, v.first, (std::min)(v.second, left));

src/kademlia/msg.cpp

@@ -56,7 +56,7 @@ bool verify_message(bdecode_node const& message, key_desc_t const desc[]
 
 	if (msg.type() != bdecode_node::dict_t)
 	{
-		snprintf(error, error_size, "not a dictionary");
+		std::snprintf(error, error_size, "not a dictionary");
 		return false;
 	}
 	++stack_ptr;
@@ -65,7 +65,7 @@ bool verify_message(bdecode_node const& message, key_desc_t const desc[]
 	{
 		key_desc_t const& k = desc[i];
 
-		//		fprintf(stderr, "looking for %s in %s\n", k.name, print_entry(*msg).c_str());
+		//		std::fprintf(stderr, "looking for %s in %s\n", k.name, print_entry(*msg).c_str());
 
 		ret[i] = msg.dict_find(k.name);
 		// none_t means any type
@@ -74,7 +74,7 @@ bool verify_message(bdecode_node const& message, key_desc_t const desc[]
 		if (ret[i] == 0 && (k.flags & key_desc_t::optional) == 0)
 		{
 			// the key was not found, and it's not an optional key
-			snprintf(error, error_size, "missing '%s' key", k.name);
+			std::snprintf(error, error_size, "missing '%s' key", k.name);
 			return false;
 		}
 
@@ -94,7 +94,7 @@ bool verify_message(bdecode_node const& message, key_desc_t const desc[]
 				ret[i].clear();
 				if ((k.flags & key_desc_t::optional) == 0)
 				{
-					snprintf(error, error_size, "invalid value for '%s'", k.name);
+					std::snprintf(error, error_size, "invalid value for '%s'", k.name);
 					return false;
 				}
 			}

src/kademlia/node.cpp

@@ -35,6 +35,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/aux_/disable_warnings_push.hpp"
 
 #include <utility>
+#include <cinttypes> // for PRId64 et.al.
 #include <boost/bind.hpp>
 #include <boost/function/function1.hpp>
 
@@ -1030,7 +1031,7 @@ void node::incoming_request(msg const& m, entry& e)
 		else
 			target = item_target_id(buf);
 
-//		fprintf(stderr, "%s PUT target: %s salt: %s key: %s\n"
+//		std::fprintf(stderr, "%s PUT target: %s salt: %s key: %s\n"
 //			, mutable_put ? "mutable":"immutable"
 //			, to_hex(target.to_string()).c_str()
 //			, salt.second > 0 ? std::string(salt.first, salt.second).c_str() : ""
@@ -1141,7 +1142,7 @@ void node::incoming_request(msg const& m, entry& e)
 		m_counters.inc_stats_counter(counters::dht_get_in);
 		sha1_hash target(msg_keys[1].string_ptr());
 
-//		fprintf(stderr, "%s GET target: %s\n"
+//		std::fprintf(stderr, "%s GET target: %s\n"
 //			, msg_keys[1] ? "mutable":"immutable"
 //			, to_hex(target.to_string()).c_str());
 

src/kademlia/routing_table.cpp

@@ -35,6 +35,8 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <algorithm> // std::copy, std::remove_copy_if
 #include <functional>
 #include <numeric>
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
 
 #include "libtorrent/config.hpp"
 
@@ -256,7 +258,7 @@ void routing_table::print_state(std::ostream& os) const
 	std::vector<char> buf(2048);
 	int cursor = 0;
 
-	cursor += snprintf(&buf[cursor], buf.size() - cursor
+	cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 		, "kademlia routing table state\n"
 		"bucket_size: %d\n"
 		"global node count: %" PRId64 "\n"
@@ -272,27 +274,27 @@ void routing_table::print_state(std::ostream& os) const
 	for (table_t::const_iterator i = m_buckets.begin(), end(m_buckets.end());
 		i != end; ++i, ++idx)
 	{
-		cursor += snprintf(&buf[cursor], buf.size() - cursor
+		cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 			, "%2d: ", idx);
 		for (int k = 0; k < int(i->live_nodes.size()); ++k)
-			cursor += snprintf(&buf[cursor], buf.size() - cursor, "#");
+			cursor += std::snprintf(&buf[cursor], buf.size() - cursor, "#");
 		for (int k = 0; k < int(i->replacements.size()); ++k)
-			cursor += snprintf(&buf[cursor], buf.size() - cursor, "-");
+			cursor += std::snprintf(&buf[cursor], buf.size() - cursor, "-");
-		cursor += snprintf(&buf[cursor], buf.size() - cursor, "\n");
+		cursor += std::snprintf(&buf[cursor], buf.size() - cursor, "\n");
 
 		if (cursor > buf.size() - 500) buf.resize(buf.size() * 3 / 2);
 	}
 
 	time_point now = aux::time_now();
 
-	cursor += snprintf(&buf[cursor], buf.size() - cursor
+	cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 		, "\nnodes:");
 
 	int bucket_index = 0;
 	for (table_t::const_iterator i = m_buckets.begin(), end(m_buckets.end());
 		i != end; ++i, ++bucket_index)
 	{
-		cursor += snprintf(&buf[cursor], buf.size() - cursor
+		cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 			, "\n=== BUCKET == %d == %d|%d ==== \n"
 			, bucket_index, int(i->live_nodes.size())
 			, int(i->replacements.size()));
@@ -323,23 +325,23 @@ void routing_table::print_state(std::ostream& os) const
 			node_id id = j->id;
 			id <<= id_shift;
 
-			cursor += snprintf(&buf[cursor], buf.size() - cursor
+			cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 				, " prefix: %2x id: %s"
 				, ((id[0] & top_mask) >> mask_shift)
 				, to_hex(j->id.to_string()).c_str());
 
 			if (j->rtt == 0xffff)
 			{
-				cursor += snprintf(&buf[cursor], buf.size() - cursor
+				cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 					, " rtt:     ");
 			}
 			else
 			{
-				cursor += snprintf(&buf[cursor], buf.size() - cursor
+				cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 					, " rtt: %4d", j->rtt);
 			}
 
-			cursor += snprintf(&buf[cursor], buf.size() - cursor
+			cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 				, " fail: %4d ping: %d dist: %3d"
 				, j->fail_count()
 				, j->pinged()
@@ -347,22 +349,22 @@ void routing_table::print_state(std::ostream& os) const
 
 			if (j->last_queried == min_time())
 			{
-				cursor += snprintf(&buf[cursor], buf.size() - cursor
+				cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 					, " query:    ");
 			}
 			else
 			{
-				cursor += snprintf(&buf[cursor], buf.size() - cursor
+				cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 					, " query: %3d", int(total_seconds(now - j->last_queried)));
 			}
 
-			cursor += snprintf(&buf[cursor], buf.size() - cursor
+			cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 				, " ip: %s\n", print_endpoint(j->ep()).c_str());
 			if (cursor > buf.size() - 500) buf.resize(buf.size() * 3 / 2);
 		}
 	}
 
-	cursor += snprintf(&buf[cursor], buf.size() - cursor
+	cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 		, "\nnode spread per bucket:\n");
 	bucket_index = 0;
 	for (table_t::const_iterator i = m_buckets.begin(), end(m_buckets.end());
@@ -407,15 +409,15 @@ void routing_table::print_state(std::ostream& os) const
 			sub_buckets[b] = true;
 		}
 
-		cursor += snprintf(&buf[cursor], buf.size() - cursor
+		cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 			, "%2d mask: %2x: [", bucket_index, (top_mask >> mask_shift));
 
 		for (int j = 0; j < bucket_size_limit; ++j)
 		{
-			cursor += snprintf(&buf[cursor], buf.size() - cursor
+			cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 				, (sub_buckets[j] ? "X" : " "));
 		}
-		cursor += snprintf(&buf[cursor], buf.size() - cursor
+		cursor += std::snprintf(&buf[cursor], buf.size() - cursor
 			, "]\n");
 		if (cursor > buf.size() - 500) buf.resize(buf.size() * 3 / 2);
 	}

src/kademlia/rpc_manager.cpp

@@ -60,6 +60,10 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <libtorrent/time.hpp>
 #include <libtorrent/aux_/time.hpp> // for aux::time_now
 
+#ifndef TORRENT_DISABLE_LOGGING
+#include <cinttypes> // for PRId64 et.al.
+#endif
+
 namespace libtorrent { namespace dht
 {
 

src/lazy_bdecode.cpp

@@ -37,6 +37,8 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/bdecode.hpp" // for error codes
 #include <cstring>
 #include <limits> // for numeric_limits
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
 
 namespace
 {
@@ -551,7 +553,7 @@ namespace libtorrent
 			else
 			{
 				char tmp[5];
-				snprintf(tmp, sizeof(tmp), "\\x%02x", boost::uint8_t(str[i]));
+				std::snprintf(tmp, sizeof(tmp), "\\x%02x", boost::uint8_t(str[i]));
 				ret += tmp;
 			}
 		}
@@ -610,7 +612,7 @@ namespace libtorrent
 			case lazy_entry::int_t:
 			{
 				char str[100];
-				snprintf(str, sizeof(str), "%" PRId64, e.int_value());
+				std::snprintf(str, sizeof(str), "%" PRId64, e.int_value());
 				return str;
 			}
 			case lazy_entry::string_t:

src/lsd.cpp

@@ -58,7 +58,7 @@ int render_lsd_packet(char* dst, int len, int listen_port
 	, char const* info_hash_hex, int m_cookie, char const* host)
 {
 	TORRENT_ASSERT(len > 0);
-	return snprintf(dst, len,
+	return std::snprintf(dst, len,
 		"BT-SEARCH * HTTP/1.1\r\n"
 		"Host: %s:6771\r\n"
 		"Port: %d\r\n"

src/natpmp.cpp

@@ -43,6 +43,8 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "libtorrent/aux_/disable_warnings_pop.hpp"
 
+#include <cstdio> // for snprintf
+
 #include "libtorrent/natpmp.hpp"
 #include "libtorrent/io.hpp"
 #include "libtorrent/assert.hpp"
@@ -90,7 +92,7 @@ void natpmp::start()
 	if (ec)
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), "failed to find default route: %s"
+		std::snprintf(msg, sizeof(msg), "failed to find default route: %s"
 			, convert_from_native(ec.message()).c_str());
 		log(msg);
 		disable(ec);
@@ -104,7 +106,7 @@ void natpmp::start()
 	m_nat_endpoint = nat_endpoint;
 
 	char msg[200];
-	snprintf(msg, sizeof(msg), "found router at: %s"
+	std::snprintf(msg, sizeof(msg), "found router at: %s"
 		, print_address(m_nat_endpoint.address()).c_str());
 	log(msg);
 
@@ -351,7 +353,7 @@ void natpmp::send_map_request(int i)
 	write_uint32(ttl, out); // port mapping lifetime
 
 	char msg[200];
-	snprintf(msg, sizeof(msg), "==> port map [ mapping: %d action: %s"
+	std::snprintf(msg, sizeof(msg), "==> port map [ mapping: %d action: %s"
 		" proto: %s local: %u external: %u ttl: %u ]"
 		, i, m.action == mapping_t::action_add ? "add" : "delete"
 		, m.protocol == udp ? "udp" : "tcp"
@@ -413,7 +415,7 @@ void natpmp::on_reply(error_code const& e
 	if (e)
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), "error on receiving reply: %s"
+		std::snprintf(msg, sizeof(msg), "error on receiving reply: %s"
 			, convert_from_native(e.message()).c_str());
 		log(msg);
 		return;
@@ -439,7 +441,7 @@ void natpmp::on_reply(error_code const& e
 	if (m_remote != m_nat_endpoint)
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), "received packet from wrong IP: %s"
+		std::snprintf(msg, sizeof(msg), "received packet from wrong IP: %s"
 			, print_endpoint(m_remote).c_str());
 		log(msg);
 		return;
@@ -451,7 +453,7 @@ void natpmp::on_reply(error_code const& e
 	if (bytes_transferred < 12)
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), "received packet of invalid size: %d", int(bytes_transferred));
+		std::snprintf(msg, sizeof(msg), "received packet of invalid size: %d", int(bytes_transferred));
 		log(msg);
 		return;
 	}
@@ -468,7 +470,7 @@ void natpmp::on_reply(error_code const& e
 		m_external_ip = read_v4_address(in);
 
 		char msg[200];
-		snprintf(msg, sizeof(msg), "<== public IP address [ %s ]", print_address(m_external_ip).c_str());
+		std::snprintf(msg, sizeof(msg), "<== public IP address [ %s ]", print_address(m_external_ip).c_str());
 		log(msg);
 		return;
 
@@ -477,7 +479,7 @@ void natpmp::on_reply(error_code const& e
 	if (bytes_transferred < 16)
 	{
 		char msg[200];
-		snprintf(msg, sizeof(msg), "received packet of invalid size: %d", int(bytes_transferred));
+		std::snprintf(msg, sizeof(msg), "received packet of invalid size: %d", int(bytes_transferred));
 		log(msg);
 		return;
 	}
@@ -491,14 +493,14 @@ void natpmp::on_reply(error_code const& e
 	int protocol = (cmd - 128 == 1)?udp:tcp;
 
 	char msg[200];
-	int num_chars = snprintf(msg, sizeof(msg), "<== port map ["
+	int num_chars = std::snprintf(msg, sizeof(msg), "<== port map ["
 		" protocol: %s local: %u external: %u ttl: %u ]"
 		, (cmd - 128 == 1 ? "udp" : "tcp")
 		, private_port, public_port, lifetime);
 
 	if (version != 0)
 	{
-		snprintf(msg + num_chars, sizeof(msg) - num_chars, "unexpected version: %u"
+		std::snprintf(msg + num_chars, sizeof(msg) - num_chars, "unexpected version: %u"
 			, version);
 		log(msg);
 	}
@@ -519,7 +521,7 @@ void natpmp::on_reply(error_code const& e
 
 	if (m == 0)
 	{
-		snprintf(msg + num_chars, sizeof(msg) - num_chars, " not found in map table");
+		std::snprintf(msg + num_chars, sizeof(msg) - num_chars, " not found in map table");
 		log(msg);
 		return;
 	}
@@ -604,7 +606,7 @@ void natpmp::update_expiration_timer()
 		if (i->expires < now)
 		{
 			char msg[200];
-			snprintf(msg, sizeof(msg), "mapping %u expired", index);
+			std::snprintf(msg, sizeof(msg), "mapping %u expired", index);
 			log(msg);
 			i->action = mapping_t::action_add;
 			if (m_next_refresh == index) m_next_refresh = -1;
@@ -644,7 +646,7 @@ void natpmp::mapping_expired(error_code const& e, int i)
 	COMPLETE_ASYNC("natpmp::mapping_expired");
 	if (e) return;
 	char msg[200];
-	snprintf(msg, sizeof(msg), "mapping %u expired", i);
+	std::snprintf(msg, sizeof(msg), "mapping %u expired", i);
 	log(msg);
 	m_mappings[i].action = mapping_t::action_add;
 	if (m_next_refresh == i) m_next_refresh = -1;

src/peer_connection.cpp

@@ -2871,7 +2871,7 @@ namespace libtorrent
 		bool was_finished = picker.is_piece_finished(p.piece);
 		// did we request this block from any other peers?
 		bool multi = picker.num_peers(block_finished) > 1;
-//		fprintf(stderr, "peer_connection mark_as_writing peer: %p piece: %d block: %d\n"
+//		std::fprintf(stderr, "peer_connection mark_as_writing peer: %p piece: %d block: %d\n"
 //			, peer_info_struct(), block_finished.piece_index, block_finished.block_index);
 		picker.mark_as_writing(block_finished, peer_info_struct());
 
@@ -3037,7 +3037,7 @@ namespace libtorrent
 			picker.mark_as_canceled(block_finished, peer_info_struct());
 			return;
 		}
-//		fprintf(stderr, "peer_connection mark_as_finished peer: %p piece: %d block: %d\n"
+//		std::fprintf(stderr, "peer_connection mark_as_finished peer: %p piece: %d block: %d\n"
 //			, peer_info_struct(), block_finished.piece_index, block_finished.block_index);
 		picker.mark_as_finished(block_finished, peer_info_struct());
 
@@ -6562,7 +6562,7 @@ namespace libtorrent
 
 			if (m_outstanding_bytes != outstanding_bytes)
 			{
-				fprintf(stderr, "m_outstanding_bytes = %d\noutstanding_bytes = %d\n"
+				std::fprintf(stderr, "m_outstanding_bytes = %d\noutstanding_bytes = %d\n"
 					, m_outstanding_bytes, outstanding_bytes);
 			}
 

src/piece_picker.cpp

@@ -2470,10 +2470,10 @@ get_out:
 					, piece_block(i->index, j));
 				if (k != interesting_blocks.end()) continue;
 
-				fprintf(stderr, "interesting blocks:\n");
+				std::fprintf(stderr, "interesting blocks:\n");
 				for (k = interesting_blocks.begin(); k != interesting_blocks.end(); ++k)
-					fprintf(stderr, "(%d, %d)", k->piece_index, k->block_index);
+					std::fprintf(stderr, "(%d, %d)", k->piece_index, k->block_index);
-				fprintf(stderr, "\nnum_blocks: %d\n", num_blocks);
+				std::fprintf(stderr, "\nnum_blocks: %d\n", num_blocks);
 
 				for (std::vector<downloading_piece>::const_iterator l
 					= m_downloads[piece_pos::piece_downloading].begin()
@@ -2481,11 +2481,11 @@ get_out:
 					l != end2; ++l)
 				{
 					block_info const* binfo2 = blocks_for_piece(*l);
-					fprintf(stderr, "%d : ", l->index);
+					std::fprintf(stderr, "%d : ", l->index);
 					const int cnt = blocks_in_piece(l->index);
 					for (int m = 0; m < cnt; ++m)
-						fprintf(stderr, "%d", binfo2[m].state);
+						std::fprintf(stderr, "%d", binfo2[m].state);
-					fprintf(stderr, "\n");
+					std::fprintf(stderr, "\n");
 				}
 
 				TORRENT_ASSERT_FAIL();

src/puff.cpp

@@ -834,10 +834,10 @@ int main(int argc, char **argv)
     sourcelen = len;
     ret = puff(NIL, &destlen, source, &sourcelen);
     if (ret)
-        printf("puff() failed with return code %d\n", ret);
+        std::printf("puff() failed with return code %d\n", ret);
     else {
-        printf("puff() succeeded uncompressing %lu bytes\n", destlen);
+        std::printf("puff() succeeded uncompressing %lu bytes\n", destlen);
-        if (sourcelen < len) printf("%lu compressed bytes unused\n",
+        if (sourcelen < len) std::printf("%lu compressed bytes unused\n",
                                     len - sourcelen);
     }
     free(source);

src/random.cpp

@@ -48,7 +48,8 @@ namespace libtorrent
 	{
 		// make sure random numbers are deterministic. Seed with a fixed number
 		static mt19937 random_engine(4040);
-		return uniform_int_distribution<boost::uint32_t>(0, UINT_MAX)(random_engine);
+		return uniform_int_distribution<boost::uint32_t>(0
+			, (std::numeric_limits<boost::uint32_t>::max)())(random_engine);
 	}
 
 #else
@@ -59,7 +60,8 @@ namespace libtorrent
 		// not generate thread safe initialization of statics
 		static random_device dev;
 		static mt19937 random_engine(dev());
-		return uniform_int_distribution<boost::uint32_t>(0, UINT_MAX)(random_engine);
+		return uniform_int_distribution<boost::uint32_t>(0
+			, (std::numeric_limits<boost::uint32_t>::max)())(random_engine);
 	}
 
 #endif // TORRENT_BUILD_SIMULATOR

src/session.cpp

@@ -382,12 +382,12 @@ namespace libtorrent
 		{
 			sleep(1000);
 			++counter;
-			printf("\x1b[2J\x1b[0;0H\x1b[33m==== Waiting to shut down: %d ==== \x1b[0m\n\n"
+			std::printf("\x1b[2J\x1b[0;0H\x1b[33m==== Waiting to shut down: %d ==== \x1b[0m\n\n"
 				, counter);
 		}
 		async_dec_threads();
 
-		fprintf(stderr, "\n\nEXPECTS NO MORE ASYNC OPS\n\n\n");
+		std::fprintf(stderr, "\n\nEXPECTS NO MORE ASYNC OPS\n\n\n");
 #endif
 
 		if (m_thread && m_thread.unique())

src/session_call.cpp

@@ -65,7 +65,7 @@ void dump_call_profile()
 	for (std::map<int, std::string>::const_reverse_iterator i = profile.rbegin()
 		, end(profile.rend()); i != end; ++i)
 	{
-		fprintf(out, "\n\n%d\n%s\n", i->first, i->second.c_str());
+		std::fprintf(out, "\n\n%d\n%s\n", i->first, i->second.c_str());
 	}
 	fclose(out);
 #endif

src/session_impl.cpp

@@ -151,9 +151,9 @@ namespace
 		{
 			gcry_check_version(0);
 			gcry_error_t e = gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
-			if (e != 0) fprintf(stderr, "libcrypt ERROR: %s\n", gcry_strerror(e));
+			if (e != 0) std::fprintf(stderr, "libcrypt ERROR: %s\n", gcry_strerror(e));
 			e = gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
-			if (e != 0) fprintf(stderr, "initialization finished error: %s\n", gcry_strerror(e));
+			if (e != 0) std::fprintf(stderr, "initialization finished error: %s\n", gcry_strerror(e));
 		}
 	} gcrypt_global_constructor;
 }
@@ -3073,7 +3073,7 @@ namespace aux {
 				return;
 			}
 #if defined TORRENT_ASIO_DEBUGGING
-			fprintf(stderr, "uTP sockets: %d ssl-uTP sockets: %d undead-peers left: %d\n"
+			std::fprintf(stderr, "uTP sockets: %d ssl-uTP sockets: %d undead-peers left: %d\n"
 				, m_utp_socket_manager.num_sockets()
 #ifdef TORRENT_USE_OPENSSL
 				, m_ssl_utp_socket_manager.num_sockets()
@@ -3245,7 +3245,7 @@ namespace aux {
 		// --------------------------------------------------------------
 
 #if TORRENT_DEBUG_STREAMING > 0
-		printf("\033[2J\033[0;0H");
+		std::printf("\033[2J\033[0;0H");
 #endif
 
 		std::vector<torrent*>& want_tick = m_torrent_lists[torrent_want_tick];
@@ -5857,12 +5857,12 @@ namespace aux {
 			time_point prev = m;
 			boost::uint64_t prev_csw = 0;
 			if (!_wakeups.empty()) prev_csw = _wakeups[0].context_switches;
-			fprintf(f, "abs. time\trel. time\tctx switch\tidle-wakeup\toperation\n");
+			std::fprintf(f, "abs. time\trel. time\tctx switch\tidle-wakeup\toperation\n");
 			for (int i = 0; i < _wakeups.size(); ++i)
 			{
 				wakeup_t const& w = _wakeups[i];
 				bool idle_wakeup = w.context_switches > prev_csw;
-				fprintf(f, "%" PRId64 "\t%" PRId64 "\t%" PRId64 "\t%c\t%s\n"
+				std::fprintf(f, "%" PRId64 "\t%" PRId64 "\t%" PRId64 "\t%c\t%s\n"
 					, total_microseconds(w.timestamp - m)
 					, total_microseconds(w.timestamp - prev)
 					, w.context_switches

src/sha1.cpp

@@ -121,7 +121,7 @@ namespace
 	void SHAPrintContext(sha_ctx *context, char *msg)
 	{
 		using namespace std;
-		printf("%s (%d,%d) %x %x %x %x %x\n"
+		std::printf("%s (%d,%d) %x %x %x %x %x\n"
 			, msg, (unsigned int)context->count[0]
 			, (unsigned int)context->count[1]
 			, (unsigned int)context->state[0]

src/smart_ban.cpp

@@ -79,7 +79,7 @@ void log_hash_block(FILE** f, libtorrent::torrent const& t, int piece, int block
 	if (*f == NULL)
 	{
 		char filename[1024];
-		snprintf(filename, sizeof(filename), "hash_failures/%s.log"
+		std::snprintf(filename, sizeof(filename), "hash_failures/%s.log"
 			, to_hex(t.info_hash().to_string()).c_str());
 		*f = fopen(filename, "w");
 	}
@@ -93,15 +93,15 @@ void log_hash_block(FILE** f, libtorrent::torrent const& t, int piece, int block
 	int offset = 0;
 	for (int i = 0; i < files.size(); ++i)
 	{
-		offset += snprintf(filename+offset, sizeof(filename)-offset
+		offset += std::snprintf(filename+offset, sizeof(filename)-offset
 			, "%s[%" PRId64 ",%d]", libtorrent::filename(fn).c_str(), files[i].offset, int(files[i].size));
 		if (offset >= sizeof(filename)) break;
 	}
 
-	fprintf(*f, "%s\t%04d\t%04d\t%s\t%s\t%s\n", to_hex(t.info_hash().to_string()).c_str(), piece
+	std::fprintf(*f, "%s\t%04d\t%04d\t%s\t%s\t%s\n", to_hex(t.info_hash().to_string()).c_str(), piece
 		, block, corrupt ? " bad" : "good", print_address(a).c_str(), filename);
 
-	snprintf(filename, sizeof(filename), "hash_failures/%s_%d_%d_%s.block"
+	std::snprintf(filename, sizeof(filename), "hash_failures/%s_%d_%d_%s.block"
 		, to_hex(t.info_hash().to_string()).c_str(), piece, block, corrupt ? "bad" : "good");
 	FILE* data = fopen(filename, "w+");
 	fwrite(bytes, 1, len, data);

src/socket_io.cpp

@@ -71,10 +71,10 @@ namespace libtorrent
 		address const& addr = ep.address();
 #if TORRENT_USE_IPV6
 		if (addr.is_v6())
-			snprintf(buf, sizeof(buf), "[%s]:%d", addr.to_string(ec).c_str(), ep.port());
+			std::snprintf(buf, sizeof(buf), "[%s]:%d", addr.to_string(ec).c_str(), ep.port());
 		else
 #endif
-			snprintf(buf, sizeof(buf), "%s:%d", addr.to_string(ec).c_str(), ep.port());
+			std::snprintf(buf, sizeof(buf), "%s:%d", addr.to_string(ec).c_str(), ep.port());
 		return buf;
 	}
 

src/storage.cpp

@@ -93,13 +93,13 @@ POSSIBILITY OF SUCH DAMAGE.
 #if __cplusplus >= 201103L || defined __clang__
 
 #if DEBUG_STORAGE
-#define DLOG(...) fprintf(__VA_ARGS__)
+#define DLOG(...) std::fprintf(__VA_ARGS__)
 #else
 #define DLOG(...) do {} while (false)
 #endif
 
 #if DEBUG_DELETE_FILES
-#define DFLOG(...) fprintf(__VA_ARGS__)
+#define DFLOG(...) std::fprintf(__VA_ARGS__)
 #else
 #define DFLOG(...) do {} while (false)
 #endif
@@ -215,7 +215,7 @@ namespace libtorrent
 		l.unlock();
 		if (ret != sizeof(event))
 		{
-			fprintf(stderr, "ERROR writing to disk access log: (%d) %s\n"
+			std::fprintf(stderr, "ERROR writing to disk access log: (%d) %s\n"
 				, errno, strerror(errno));
 		}
 	}

src/torrent.cpp

@@ -34,7 +34,7 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "libtorrent/aux_/disable_warnings_push.hpp"
 
-#include <stdarg.h> // for va_list
+#include <cstdarg> // for va_list
 #include <ctime>
 #include <algorithm>
 #include <set>
@@ -43,6 +43,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <cctype>
 #include <numeric>
 #include <limits> // for numeric_limits
+#include <cstdio> // for snprintf
 
 #include <boost/bind.hpp>
 #include <boost/make_shared.hpp>
@@ -1340,7 +1341,7 @@ namespace libtorrent
 
 		schedule_storage_tick();
 
-//		fprintf(stderr, "torrent::on_disk_write_complete ret:%d piece:%d block:%d\n"
+//		std::fprintf(stderr, "torrent::on_disk_write_complete ret:%d piece:%d block:%d\n"
 //			, j->ret, j->piece, j->offset/0x4000);
 
 		INVARIANT_CHECK;
@@ -1651,7 +1652,7 @@ namespace libtorrent
 		SSL_CTX_set_cert_store(ssl_ctx, cert_store);
 #if 0
 		char filename[100];
-		snprintf(filename, sizeof(filename), "/tmp/%u.pem", random());
+		std::snprintf(filename, sizeof(filename), "/tmp/%u.pem", random());
 		FILE* f = fopen(filename, "w+");
 		fwrite(cert.c_str(), cert.size(), 1, f);
 		fclose(f);
@@ -3890,11 +3891,11 @@ namespace libtorrent
 		{
 			// Thist happens when a piece has been downloaded completely
 			// but not yet verified against the hash
-			fprintf(stderr, "num_have: %d\nunfinished:\n", num_have());
+			std::fprintf(stderr, "num_have: %d\nunfinished:\n", num_have());
 			for (std::vector<piece_picker::downloading_piece>::const_iterator i =
 				dl_queue.begin(); i != dl_queue.end(); ++i)
 			{
-				fprintf(stderr, "  %d ", i->index);
+				std::fprintf(stderr, "  %d ", i->index);
 				piece_picker::block_info* info = m_picker->blocks_for_piece(*i);
 				for (int j = 0; j < blocks_per_piece; ++j)
 				{
@@ -3910,7 +3911,7 @@ namespace libtorrent
 			for (std::map<piece_block, int>::iterator i = downloading_piece.begin();
 				i != downloading_piece.end(); ++i)
 			{
-				fprintf(stderr, "   %d:%d  %d\n", int(i->first.piece_index), int(i->first.block_index), i->second);
+				std::fprintf(stderr, "   %d:%d  %d\n", int(i->first.piece_index), int(i->first.block_index), i->second);
 			}
 
 		}
@@ -4140,7 +4141,7 @@ namespace libtorrent
 		debug_log("PIECE_PASSED (%d)", num_passed());
 #endif
 
-//		fprintf(stderr, "torrent::piece_passed piece:%d\n", index);
+//		std::fprintf(stderr, "torrent::piece_passed piece:%d\n", index);
 
 		TORRENT_ASSERT(index >= 0);
 		TORRENT_ASSERT(index < m_torrent_file->num_pieces());
@@ -8380,24 +8381,24 @@ namespace libtorrent
 				{
 					if (picker_count != count)
 					{
-						fprintf(stderr, "picker count discrepancy: "
+						std::fprintf(stderr, "picker count discrepancy: "
 							"picker: %d != peerlist: %d\n", picker_count, count);
 
 						for (const_peer_iterator j = this->begin(); j != this->end(); ++j)
 						{
 							peer_connection const& p = *(*j);
-							fprintf(stderr, "peer: %s\n", print_endpoint(p.remote()).c_str());
+							std::fprintf(stderr, "peer: %s\n", print_endpoint(p.remote()).c_str());
 							for (std::vector<pending_block>::const_iterator k = p.request_queue().begin()
 								, end2(p.request_queue().end()); k != end2; ++k)
 							{
-								fprintf(stderr, "  rq: (%d, %d) %s %s %s\n", k->block.piece_index
+								std::fprintf(stderr, "  rq: (%d, %d) %s %s %s\n", k->block.piece_index
 									, k->block.block_index, k->not_wanted ? "not-wanted" : ""
 									, k->timed_out ? "timed-out" : "", k->busy ? "busy": "");
 							}
 							for (std::vector<pending_block>::const_iterator k = p.download_queue().begin()
 								, end2(p.download_queue().end()); k != end2; ++k)
 							{
-								fprintf(stderr, "  dq: (%d, %d) %s %s %s\n", k->block.piece_index
+								std::fprintf(stderr, "  dq: (%d, %d) %s %s %s\n", k->block.piece_index
 									, k->block.block_index, k->not_wanted ? "not-wanted" : ""
 									, k->timed_out ? "timed-out" : "", k->busy ? "busy": "");
 							}
@@ -8713,7 +8714,7 @@ namespace libtorrent
 		if (ec)
 		{
 			char buf[1024];
-			snprintf(buf, sizeof(buf), "error %s: %s", ec.message().c_str()
+			std::snprintf(buf, sizeof(buf), "error %s: %s", ec.message().c_str()
 				, resolve_filename(error_file).c_str());
 			log_to_all_peers(buf);
 		}
@@ -9564,7 +9565,7 @@ namespace libtorrent
 		std::sort(queue.begin(), queue.end(), boost::bind(&partial_piece_info::piece_index, _1)
 			< boost::bind(&partial_piece_info::piece_index, _2));
 
-		printf("average piece download time: %.2f s (+/- %.2f s)\n"
+		std::printf("average piece download time: %.2f s (+/- %.2f s)\n"
 			, m_average_piece_time / 1000.f
 			, m_piece_time_deviation / 1000.f);
 		for (std::vector<partial_piece_info>::iterator i = queue.begin()
@@ -9949,7 +9950,7 @@ namespace libtorrent
 
 		int num_blocks = pp->blocks_in_piece;
 
-		printf("%5d: [", piece);
+		std::printf("%5d: [", piece);
 		for (int j = 0; j < num_blocks; ++j)
 		{
 			int index = pp ? peer_index(pp->blocks[j].peer(), peers) % 36 : -1;
@@ -9974,14 +9975,14 @@ namespace libtorrent
 			else if (pp->blocks[j].state == block_info::requested) color = esc("0");
 			else { color = esc("0"); chr = ' '; }
 
-			printf("%s%s%c%s", color, multi_req, chr, esc("0"));
+			std::printf("%s%s%c%s", color, multi_req, chr, esc("0"));
 		}
-		printf("%s]", esc("0"));
+		std::printf("%s]", esc("0"));
 		if (deadline != 0.f)
-			printf(" deadline: %f last-req: %f timed_out: %d\n"
+			std::printf(" deadline: %f last-req: %f timed_out: %d\n"
 				, deadline, last_request, timed_out);
 		else
-			printf("\n");
+			std::printf("\n");
 	}
 #endif // TORRENT_DEBUG_STREAMING
 
@@ -10033,11 +10034,11 @@ namespace libtorrent
 			++busy_count;
 
 #if TORRENT_DEBUG_STREAMING > 1
-			printf(" [%d (%d)]", b.block_index, info[k].num_peers);
+			std::printf(" [%d (%d)]", b.block_index, info[k].num_peers);
 #endif
 		}
 #if TORRENT_DEBUG_STREAMING > 1
-		printf("\n");
+		std::printf("\n");
 #endif
 
 		// then sort blocks by the number of peers with requests
@@ -10077,7 +10078,7 @@ namespace libtorrent
 			if (!peers.empty() && peers[0]->download_queue_time() > milliseconds(2000))
 			{
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("queue time: %d ms, done\n"
+				std::printf("queue time: %d ms, done\n"
 					, int(total_milliseconds(peers[0]->download_queue_time())));
 #endif
 				break;
@@ -10092,7 +10093,7 @@ namespace libtorrent
 			if (p == peers.end())
 			{
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("out of peers, done\n");
+				std::printf("out of peers, done\n");
 #endif
 				break;
 			}
@@ -10121,7 +10122,7 @@ namespace libtorrent
 				busy_mode = true;
 
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("interesting_blocks.empty()\n");
+				std::printf("interesting_blocks.empty()\n");
 #endif
 
 				// there aren't any free blocks to pick, and the piece isn't
@@ -10130,13 +10131,13 @@ namespace libtorrent
 				if (timed_out == 0)
 				{
 #if TORRENT_DEBUG_STREAMING > 1
-					printf("not timed out, moving on to next piece\n");
+					std::printf("not timed out, moving on to next piece\n");
 #endif
 					break;
 				}
 
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("pick busy blocks\n");
+				std::printf("pick busy blocks\n");
 #endif
 
 				pick_busy_blocks(picker, i->piece, blocks_in_piece, timed_out
@@ -10168,7 +10169,7 @@ namespace libtorrent
 				ignore_peers.push_back(*p);
 				peers.erase(p);
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("piece already requested by peer, try next peer\n");
+				std::printf("piece already requested by peer, try next peer\n");
 #endif
 				// try next peer
 				continue;
@@ -10184,7 +10185,7 @@ namespace libtorrent
 				if (!c.make_time_critical(b))
 				{
 #if TORRENT_DEBUG_STREAMING > 1
-					printf("piece already time-critical and in queue for peer, trying next peer\n");
+					std::printf("piece already time-critical and in queue for peer, trying next peer\n");
 #endif
 					ignore_peers.push_back(*p);
 					peers.erase(p);
@@ -10193,7 +10194,7 @@ namespace libtorrent
 				i->last_requested = now;
 
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("piece already in queue for peer, making time-critical\n");
+				std::printf("piece already in queue for peer, making time-critical\n");
 #endif
 
 				// we inserted a new block in the request queue, this
@@ -10206,7 +10207,7 @@ namespace libtorrent
 					| (busy_mode ? peer_connection::req_busy : 0)))
 				{
 #if TORRENT_DEBUG_STREAMING > 1
-					printf("failed to request block [%d, %d]\n"
+					std::printf("failed to request block [%d, %d]\n"
 						, b.piece_index, b.block_index);
 #endif
 					ignore_peers.push_back(*p);
@@ -10215,7 +10216,7 @@ namespace libtorrent
 				}
 
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("requested block [%d, %d]\n"
+				std::printf("requested block [%d, %d]\n"
 					, b.piece_index, b.block_index);
 #endif
 				peers_with_requests.insert(peers_with_requests.begin(), &c);
@@ -10228,7 +10229,7 @@ namespace libtorrent
 			if (!c.can_request_time_critical())
 			{
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("peer cannot pick time critical pieces\n");
+				std::printf("peer cannot pick time critical pieces\n");
 #endif
 				peers.erase(p);
 				// try next peer
@@ -10301,13 +10302,13 @@ namespace libtorrent
 			, end(m_time_critical_pieces.end()); i != end; ++i)
 		{
 #if TORRENT_DEBUG_STREAMING > 1
-			printf("considering %d\n", i->piece);
+			std::printf("considering %d\n", i->piece);
 #endif
 
 			if (peers.empty())
 			{
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("out of peers, done\n");
+				std::printf("out of peers, done\n");
 #endif
 				break;
 			}
@@ -10322,7 +10323,7 @@ namespace libtorrent
 				// this is one of the termination conditions. We don't want to
 				// send requests for all pieces in the torrent right away
 #if TORRENT_DEBUG_STREAMING > 0
-				printf("reached deadline horizon [%f + %f * 4 + 1]\n"
+				std::printf("reached deadline horizon [%f + %f * 4 + 1]\n"
 					, m_average_piece_time / 1000.f
 					, m_piece_time_deviation / 1000.f);
 #endif
@@ -10364,7 +10365,7 @@ namespace libtorrent
 				if (pi.requested == 0 || timed_out == 0)
 				{
 #if TORRENT_DEBUG_STREAMING > 1
-					printf("skipping %d (full) [req: %d timed_out: %d ]\n"
+					std::printf("skipping %d (full) [req: %d timed_out: %d ]\n"
 						, i->piece, pi.requested
 						, timed_out);
 #endif
@@ -10380,7 +10381,7 @@ namespace libtorrent
 				// it's been too long since we requested the last block from
 				// this piece. Allow re-requesting blocks from this piece
 #if TORRENT_DEBUG_STREAMING > 1
-				printf("timed out [average-piece-time: %d ms ]\n"
+				std::printf("timed out [average-piece-time: %d ms ]\n"
 					, m_average_piece_time);
 #endif
 			}

src/torrent_info.cpp

@@ -736,7 +736,7 @@ namespace libtorrent
 				{
 					++cnt;
 					char new_ext[50];
-					snprintf(new_ext, sizeof(new_ext), ".%d%s", cnt, ext.c_str());
+					std::snprintf(new_ext, sizeof(new_ext), ".%d%s", cnt, ext.c_str());
 					filename = base + new_ext;
 				}
 				while (!files.insert(filename).second);

src/udp_tracker_connection.cpp

@@ -258,7 +258,7 @@ namespace libtorrent
 					char const* tracker_address_type = target.address().is_v4() ? "IPv4" : "IPv6";
 					char const* bind_address_type = bind_interface().is_v4() ? "IPv4" : "IPv6";
 					char msg[200];
-					snprintf(msg, sizeof(msg)
+					std::snprintf(msg, sizeof(msg)
 						, "the tracker only resolves to an %s  address, and you're "
 						"listening on an %s socket. This may prevent you from receiving "
 						"incoming connections."

src/upnp.cpp

@@ -52,6 +52,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/aux_/disable_warnings_pop.hpp"
 
 #include <cstdlib>
+#include <cstdio> // for snprintf
 
 namespace libtorrent {
 
@@ -141,7 +142,7 @@ void upnp::discover_device_impl()
 	if (ec)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "broadcast failed: %s. Aborting."
+		std::snprintf(msg, sizeof(msg), "broadcast failed: %s. Aborting."
 			, convert_from_native(ec.message()).c_str());
 		log(msg);
 		disable(ec);
@@ -165,7 +166,7 @@ int upnp::add_mapping(upnp::protocol_type p, int external_port, int local_port)
 	TORRENT_ASSERT(external_port != 0);
 
 	char msg[500];
-	snprintf(msg, sizeof(msg), "adding port map: [ protocol: %s ext_port: %u "
+	std::snprintf(msg, sizeof(msg), "adding port map: [ protocol: %s ext_port: %u "
 		"local_port: %u ] %s", (p == tcp?"tcp":"udp"), external_port
 		, local_port, m_disabled ? "DISABLED": "");
 	log(msg);
@@ -217,7 +218,7 @@ void upnp::delete_mapping(int mapping)
 	global_mapping_t& m = m_mappings[mapping];
 
 	char msg[500];
-	snprintf(msg, sizeof(msg), "deleting port map: [ protocol: %s ext_port: %u "
+	std::snprintf(msg, sizeof(msg), "deleting port map: [ protocol: %s ext_port: %u "
 		"local_port: %u ]", (m.protocol == tcp?"tcp":"udp"), m.external_port
 		, m.local_port);
 	log(msg);
@@ -285,7 +286,7 @@ void upnp::resend_request(error_code const& ec)
 			TORRENT_TRY
 			{
 				char msg[500];
-				snprintf(msg, sizeof(msg), "connecting to: %s", d.url.c_str());
+				std::snprintf(msg, sizeof(msg), "connecting to: %s", d.url.c_str());
 				log(msg);
 				if (d.upnp_connection) d.upnp_connection->close();
 				d.upnp_connection.reset(new http_connection(m_io_service
@@ -298,7 +299,7 @@ void upnp::resend_request(error_code const& ec)
 			{
 				TORRENT_DECLARE_DUMMY(std::exception, exc);
 				char msg[500];
-				snprintf(msg, sizeof(msg), "connection failed to: %s %s", d.url.c_str(), exc.what());
+				std::snprintf(msg, sizeof(msg), "connection failed to: %s %s", d.url.c_str(), exc.what());
 				log(msg);
 				d.disabled = true;
 			}
@@ -347,7 +348,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 		if (ec)
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "when receiving response from: %s: %s"
+			std::snprintf(msg, sizeof(msg), "when receiving response from: %s: %s"
 				, print_endpoint(from).c_str(), convert_from_native(ec.message()).c_str());
 			log(msg);
 		}
@@ -357,7 +358,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 	if (!ec && !in_local_network(m_interfaces, from.address()))
 	{
 		char msg[400];
-		int num_chars = snprintf(msg, sizeof(msg)
+		int num_chars = std::snprintf(msg, sizeof(msg)
 			, "ignoring response from: %s. IP is not on local network. "
 			, print_endpoint(from).c_str());
 
@@ -365,7 +366,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 		for (std::vector<ip_interface>::const_iterator i = net.begin()
 			, end(net.end()); i != end && num_chars < int(sizeof(msg)); ++i)
 		{
-			num_chars += snprintf(msg + num_chars, sizeof(msg) - num_chars, "(%s,%s) "
+			num_chars += std::snprintf(msg + num_chars, sizeof(msg) - num_chars, "(%s,%s) "
 				, print_address(i->interface_address).c_str(), print_address(i->netmask).c_str());
 		}
 		log(msg);
@@ -384,7 +385,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 			if (ec)
 			{
 				char msg[500];
-				snprintf(msg, sizeof(msg), "failed to enumerate routes when "
+				std::snprintf(msg, sizeof(msg), "failed to enumerate routes when "
 					"receiving response from: %s: %s"
 					, print_endpoint(from).c_str(), convert_from_native(ec.message()).c_str());
 				log(msg);
@@ -392,13 +393,13 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 			else
 			{
 				char msg[400];
-				int num_chars = snprintf(msg, sizeof(msg), "SSDP response from: "
+				int num_chars = std::snprintf(msg, sizeof(msg), "SSDP response from: "
 					"%s: IP is not a router. "
 					, print_endpoint(from).c_str());
 				for (std::vector<ip_route>::const_iterator i = routes.begin()
 					, end(routes.end()); i != end && num_chars < int(sizeof(msg)); ++i)
 				{
-					num_chars += snprintf(msg + num_chars, sizeof(msg) - num_chars, "(%s,%s) "
+					num_chars += std::snprintf(msg + num_chars, sizeof(msg) - num_chars, "(%s,%s) "
 						, print_address(i->gateway).c_str(), print_address(i->netmask).c_str());
 				}
 				log(msg);
@@ -414,7 +415,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 	if (error)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "received malformed HTTP from: %s"
+		std::snprintf(msg, sizeof(msg), "received malformed HTTP from: %s"
 			, print_endpoint(from).c_str());
 		log(msg);
 		return;
@@ -425,14 +426,14 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 		if (p.method().empty())
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "HTTP status %u from %s"
+			std::snprintf(msg, sizeof(msg), "HTTP status %u from %s"
 				, p.status_code(), print_endpoint(from).c_str());
 			log(msg);
 		}
 		else
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "HTTP method %s from %s"
+			std::snprintf(msg, sizeof(msg), "HTTP method %s from %s"
 				, p.method().c_str(), print_endpoint(from).c_str());
 			log(msg);
 		}
@@ -442,7 +443,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 	if (!p.header_finished())
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "incomplete HTTP packet from %s"
+		std::snprintf(msg, sizeof(msg), "incomplete HTTP packet from %s"
 			, print_endpoint(from).c_str());
 		log(msg);
 		return;
@@ -452,7 +453,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 	if (url.empty())
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "missing location header from %s"
+		std::snprintf(msg, sizeof(msg), "missing location header from %s"
 			, print_endpoint(from).c_str());
 		log(msg);
 		return;
@@ -475,7 +476,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 		if (ec)
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "invalid URL %s from %s: %s"
+			std::snprintf(msg, sizeof(msg), "invalid URL %s from %s: %s"
 				, d.url.c_str(), print_endpoint(from).c_str(), convert_from_native(ec.message()).c_str());
 			log(msg);
 			return;
@@ -487,7 +488,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 		if (protocol != "http")
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "unsupported protocol %s from %s"
+			std::snprintf(msg, sizeof(msg), "unsupported protocol %s from %s"
 				, protocol.c_str(), print_endpoint(from).c_str());
 			log(msg);
 			return;
@@ -496,7 +497,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 		if (d.port == 0)
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "URL with port 0 from %s"
+			std::snprintf(msg, sizeof(msg), "URL with port 0 from %s"
 				, print_endpoint(from).c_str());
 			log(msg);
 			return;
@@ -504,7 +505,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "found rootdevice: %s (%d)"
+			std::snprintf(msg, sizeof(msg), "found rootdevice: %s (%d)"
 				, d.url.c_str(), int(m_devices.size()));
 			log(msg);
 		}
@@ -512,7 +513,7 @@ void upnp::on_reply(udp::endpoint const& from, char* buffer
 		if (m_devices.size() >= 50)
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "too many rootdevices: (%d). Ignoring %s"
+			std::snprintf(msg, sizeof(msg), "too many rootdevices: (%d). Ignoring %s"
 				, int(m_devices.size()), d.url.c_str());
 			log(msg);
 			return;
@@ -576,7 +577,7 @@ void upnp::try_map_upnp(bool timer)
 		if (override_ignore_non_routers)
 		{
 			char msg[500];
-			snprintf(msg, sizeof(msg), "overriding ignore non-routers");
+			std::snprintf(msg, sizeof(msg), "overriding ignore non-routers");
 			log(msg);
 		}
 	}
@@ -601,7 +602,7 @@ void upnp::try_map_upnp(bool timer)
 			TORRENT_TRY
 			{
 				char msg[500];
-				snprintf(msg, sizeof(msg), "connecting to: %s"
+				std::snprintf(msg, sizeof(msg), "connecting to: %s"
 					, d.url.c_str());
 				log(msg);
 
@@ -616,7 +617,7 @@ void upnp::try_map_upnp(bool timer)
 			{
 				TORRENT_DECLARE_DUMMY(std::exception, exc);
 				char msg[500];
-				snprintf(msg, sizeof(msg), "connection failed to: %s %s"
+				std::snprintf(msg, sizeof(msg), "connection failed to: %s %s"
 					, d.url.c_str(), exc.what());
 				log(msg);
 				d.disabled = true;
@@ -633,7 +634,7 @@ void upnp::post(upnp::rootdevice const& d, char const* soap
 	TORRENT_ASSERT(d.upnp_connection);
 
 	char header[2048];
-	snprintf(header, sizeof(header), "POST %s HTTP/1.1\r\n"
+	std::snprintf(header, sizeof(header), "POST %s HTTP/1.1\r\n"
 		"Host: %s:%u\r\n"
 		"Content-Type: text/xml; charset=\"utf-8\"\r\n"
 		"Content-Length: %d\r\n"
@@ -646,7 +647,7 @@ void upnp::post(upnp::rootdevice const& d, char const* soap
 	d.upnp_connection->m_sendbuffer = header;
 
 	char msg[1024];
-	snprintf(msg, sizeof(msg), "sending: %s", header);
+	std::snprintf(msg, sizeof(msg), "sending: %s", header);
 	log(msg);
 }
 
@@ -660,7 +661,7 @@ void upnp::create_port_mapping(http_connection& c, rootdevice& d, int i)
 	{
 		TORRENT_ASSERT(d.disabled);
 		char msg[500];
-		snprintf(msg, sizeof(msg), "mapping %u aborted", i);
+		std::snprintf(msg, sizeof(msg), "mapping %u aborted", i);
 		log(msg);
 		return;
 	}
@@ -671,7 +672,7 @@ void upnp::create_port_mapping(http_connection& c, rootdevice& d, int i)
 	std::string local_endpoint = print_address(c.socket().local_endpoint(ec).address());
 
 	char soap[2048];
-	snprintf(soap, sizeof(soap), "<?xml version=\"1.0\"?>\n"
+	std::snprintf(soap, sizeof(soap), "<?xml version=\"1.0\"?>\n"
 		"<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
 		"s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
 		"<s:Body><u:%s xmlns:u=\"%s\">"
@@ -729,7 +730,7 @@ void upnp::update_map(rootdevice& d, int i)
 		|| m.protocol == none)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "mapping %u does not need updating, skipping", i);
+		std::snprintf(msg, sizeof(msg), "mapping %u does not need updating, skipping", i);
 		log(msg);
 		m.action = mapping_t::action_none;
 		next(d, i);
@@ -740,7 +741,7 @@ void upnp::update_map(rootdevice& d, int i)
 	TORRENT_ASSERT(d.service_namespace);
 
 	char msg[500];
-	snprintf(msg, sizeof(msg), "connecting to %s", d.hostname.c_str());
+	std::snprintf(msg, sizeof(msg), "connecting to %s", d.hostname.c_str());
 	log(msg);
 	if (m.action == mapping_t::action_add)
 	{
@@ -787,7 +788,7 @@ void upnp::delete_port_mapping(rootdevice& d, int i)
 	{
 		TORRENT_ASSERT(d.disabled);
 		char msg[500];
-		snprintf(msg, sizeof(msg), "unmapping %u aborted", i);
+		std::snprintf(msg, sizeof(msg), "unmapping %u aborted", i);
 		log(msg);
 		return;
 	}
@@ -796,7 +797,7 @@ void upnp::delete_port_mapping(rootdevice& d, int i)
 
 	char soap[2048];
 	error_code ec;
-	snprintf(soap, sizeof(soap), "<?xml version=\"1.0\"?>\n"
+	std::snprintf(soap, sizeof(soap), "<?xml version=\"1.0\"?>\n"
 		"<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
 		"s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
 		"<s:Body><u:%s xmlns:u=\"%s\">"
@@ -893,7 +894,7 @@ void upnp::on_upnp_xml(error_code const& e
 	if (e && e != boost::asio::error::eof)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while fetching control url from: %s: %s"
+		std::snprintf(msg, sizeof(msg), "error while fetching control url from: %s: %s"
 			, d.url.c_str(), convert_from_native(e.message()).c_str());
 		log(msg);
 		d.disabled = true;
@@ -903,7 +904,7 @@ void upnp::on_upnp_xml(error_code const& e
 	if (!p.header_finished())
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while fetching control url from: %s: incomplete HTTP message"
+		std::snprintf(msg, sizeof(msg), "error while fetching control url from: %s: incomplete HTTP message"
 			, d.url.c_str());
 		log(msg);
 		d.disabled = true;
@@ -913,7 +914,7 @@ void upnp::on_upnp_xml(error_code const& e
 	if (p.status_code() != 200)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while fetching control url from: %s: %s"
+		std::snprintf(msg, sizeof(msg), "error while fetching control url from: %s: %s"
 			, d.url.c_str(), convert_from_native(p.message()).c_str());
 		log(msg);
 		d.disabled = true;
@@ -926,7 +927,7 @@ void upnp::on_upnp_xml(error_code const& e
 	if (s.control_url.empty())
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "could not find a port mapping interface in response from: %s"
+		std::snprintf(msg, sizeof(msg), "could not find a port mapping interface in response from: %s"
 			, d.url.c_str());
 		log(msg);
 		d.disabled = true;
@@ -962,7 +963,7 @@ void upnp::on_upnp_xml(error_code const& e
 
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "found control URL: %s namespace %s "
+		std::snprintf(msg, sizeof(msg), "found control URL: %s namespace %s "
 			"urlbase: %s in response from %s"
 			, d.control_url.c_str(), d.service_namespace
 			, s.url_base.c_str(), d.url.c_str());
@@ -976,7 +977,7 @@ void upnp::on_upnp_xml(error_code const& e
 	if (ec)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "failed to parse URL '%s': %s"
+		std::snprintf(msg, sizeof(msg), "failed to parse URL '%s': %s"
 			, d.control_url.c_str(), convert_from_native(ec.message()).c_str());
 		log(msg);
 		d.disabled = true;
@@ -1002,7 +1003,7 @@ void upnp::get_ip_address(rootdevice& d)
 	{
 		TORRENT_ASSERT(d.disabled);
 		char msg[500];
-		snprintf(msg, sizeof(msg), "getting external IP address");
+		std::snprintf(msg, sizeof(msg), "getting external IP address");
 		log(msg);
 		return;
 	}
@@ -1011,7 +1012,7 @@ void upnp::get_ip_address(rootdevice& d)
 
 	char soap[2048];
 	error_code ec;
-	snprintf(soap, sizeof(soap), "<?xml version=\"1.0\"?>\n"
+	std::snprintf(soap, sizeof(soap), "<?xml version=\"1.0\"?>\n"
 		"<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
 		"s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
 		"<s:Body><u:%s xmlns:u=\"%s\">"
@@ -1140,7 +1141,7 @@ struct upnp_error_category : boost::system::error_category
 			return e->msg;
 		}
 		char msg[500];
-		snprintf(msg, sizeof(msg), "unknown UPnP error (%d)", ev);
+		std::snprintf(msg, sizeof(msg), "unknown UPnP error (%d)", ev);
 		return msg;
 	}
 
@@ -1176,7 +1177,7 @@ void upnp::on_upnp_get_ip_address_response(error_code const& e
 	if (e && e != boost::asio::error::eof)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while getting external IP address: %s"
+		std::snprintf(msg, sizeof(msg), "error while getting external IP address: %s"
 			, convert_from_native(e.message()).c_str());
 		log(msg);
 		if (num_mappings() > 0) update_map(d, 0);
@@ -1193,7 +1194,7 @@ void upnp::on_upnp_get_ip_address_response(error_code const& e
 	if (p.status_code() != 200)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while getting external IP address: %s"
+		std::snprintf(msg, sizeof(msg), "error while getting external IP address: %s"
 			, convert_from_native(p.message()).c_str());
 		log(msg);
 		if (num_mappings() > 0) update_map(d, 0);
@@ -1211,7 +1212,7 @@ void upnp::on_upnp_get_ip_address_response(error_code const& e
 
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "get external IP address response: %s"
+		std::snprintf(msg, sizeof(msg), "get external IP address response: %s"
 			, std::string(p.get_body().begin, p.get_body().end).c_str());
 		log(msg);
 	}
@@ -1222,14 +1223,14 @@ void upnp::on_upnp_get_ip_address_response(error_code const& e
 	if (s.error_code != -1)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while getting external IP address, code: %u"
+		std::snprintf(msg, sizeof(msg), "error while getting external IP address, code: %u"
 			, s.error_code);
 		log(msg);
 	}
 
 	if (!s.ip_address.empty()) {
 		char msg[500];
-		snprintf(msg, sizeof(msg), "got router external IP address %s", s.ip_address.c_str());
+		std::snprintf(msg, sizeof(msg), "got router external IP address %s", s.ip_address.c_str());
 		log(msg);
 		d.external_ip = address::from_string(s.ip_address.c_str(), ignore_error);
 	} else {
@@ -1256,7 +1257,7 @@ void upnp::on_upnp_map_response(error_code const& e
 	if (e && e != boost::asio::error::eof)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while adding port map: %s"
+		std::snprintf(msg, sizeof(msg), "error while adding port map: %s"
 			, convert_from_native(e.message()).c_str());
 		log(msg);
 		d.disabled = true;
@@ -1298,7 +1299,7 @@ void upnp::on_upnp_map_response(error_code const& e
 		)
 	{
 		char msg[300];
-		snprintf(msg, sizeof(msg), "error while adding port map: invalid content-type, \"%s\". Expected text/xml or application/soap+xml"
+		std::snprintf(msg, sizeof(msg), "error while adding port map: invalid content-type, \"%s\". Expected text/xml or application/soap+xml"
 			, ct.c_str());
 		log(msg);
 		next(d, mapping);
@@ -1316,7 +1317,7 @@ void upnp::on_upnp_map_response(error_code const& e
 	if (s.error_code != -1)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while adding port map, code: %u"
+		std::snprintf(msg, sizeof(msg), "error while adding port map, code: %u"
 			, s.error_code);
 		log(msg);
 	}
@@ -1353,7 +1354,7 @@ void upnp::on_upnp_map_response(error_code const& e
 	}
 
 	char msg[500];
-	snprintf(msg, sizeof(msg), "map response: %s"
+	std::snprintf(msg, sizeof(msg), "map response: %s"
 		, std::string(p.get_body().begin, p.get_body().end).c_str());
 	log(msg);
 
@@ -1420,7 +1421,7 @@ void upnp::on_upnp_unmap_response(error_code const& e
 	if (e && e != boost::asio::error::eof)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while deleting portmap: %s"
+		std::snprintf(msg, sizeof(msg), "error while deleting portmap: %s"
 			, convert_from_native(e.message()).c_str());
 		log(msg);
 	}
@@ -1431,14 +1432,14 @@ void upnp::on_upnp_unmap_response(error_code const& e
 	else if (p.status_code() != 200)
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "error while deleting portmap: %s"
+		std::snprintf(msg, sizeof(msg), "error while deleting portmap: %s"
 			, convert_from_native(p.message()).c_str());
 		log(msg);
 	}
 	else
 	{
 		char msg[500];
-		snprintf(msg, sizeof(msg), "unmap response: %s"
+		std::snprintf(msg, sizeof(msg), "unmap response: %s"
 			, std::string(p.get_body().begin, p.get_body().end).c_str());
 		log(msg);
 	}

src/utp_stream.cpp

@@ -79,7 +79,7 @@ void utp_log(char const* fmt, ...)
 
 	std::lock_guard<std::mutex> lock(log_file_holder.utp_log_mutex);
 	static time_point start = clock_type::now();
-	fprintf(log_file_holder.utp_log_file, "[%012" PRId64 "] ", total_microseconds(clock_type::now() - start));
+	std::fprintf(log_file_holder.utp_log_file, "[%012" PRId64 "] ", total_microseconds(clock_type::now() - start));
 	va_list l;
 	va_start(l, fmt);
 	vfprintf(log_file_holder.utp_log_file, fmt, l);
@@ -3216,13 +3216,13 @@ bool utp_socket_impl::incoming_packet(aux::array_view<boost::uint8_t const> buf
 			{
 				char their_delay_base[20];
 				if (m_their_delay_hist.initialized())
-					snprintf(their_delay_base, sizeof(their_delay_base), "%u", m_their_delay_hist.base());
+					std::snprintf(their_delay_base, sizeof(their_delay_base), "%u", m_their_delay_hist.base());
 				else
 					strcpy(their_delay_base, "-");
 
 				char our_delay_base[20];
 				if (m_delay_hist.initialized())
-					snprintf(our_delay_base, sizeof(our_delay_base), "%u", m_delay_hist.base());
+					std::snprintf(our_delay_base, sizeof(our_delay_base), "%u", m_delay_hist.base());
 				else
 					strcpy(our_delay_base, "-");
 

src/web_peer_connection.cpp

@@ -34,13 +34,15 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #include "libtorrent/aux_/disable_warnings_push.hpp"
 
-#include <vector>
-#include <boost/limits.hpp>
 #include <boost/bind.hpp>
-#include <stdlib.h>
 
 #include "libtorrent/aux_/disable_warnings_pop.hpp"
 
+#include <vector>
+#include <stdlib.h>
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
+
 #include "libtorrent/web_peer_connection.hpp"
 #include "libtorrent/session.hpp"
 #include "libtorrent/identify_client.hpp"

test/bdecode_benchmark.cpp

@@ -119,13 +119,13 @@ int main(int argc, char* argv[])
 	int ret = load_file(argv[1], buf, ec, 40 * 1000000);
 	if (ret == -1)
 	{
-		fprintf(stderr, "file too big, aborting\n");
+		std::fprintf(stderr, "file too big, aborting\n");
 		return 1;
 	}
 
 	if (ret != 0)
 	{
-		fprintf(stderr, "failed to load file: %s\n", ec.message().c_str());
+		std::fprintf(stderr, "failed to load file: %s\n", ec.message().c_str());
 		return 1;
 	}
 
@@ -140,7 +140,7 @@ int main(int argc, char* argv[])
 	}
 	ptime stop(time_now_hires());
 
-	fprintf(stderr, "(slow) bdecode done in %5d ns per message\n"
+	std::fprintf(stderr, "(slow) bdecode done in %5d ns per message\n"
 		, int(total_microseconds(stop - start) / 1000));
 	}
 
@@ -157,7 +157,7 @@ int main(int argc, char* argv[])
 	}
 	time_point stop(clock_type::now());
 
-	fprintf(stderr, "lazy_bdecode done in   %5d ns per message\n"
+	std::fprintf(stderr, "lazy_bdecode done in   %5d ns per message\n"
 		, int(total_microseconds(stop - start) / 1000));
 	}
 
@@ -175,7 +175,7 @@ int main(int argc, char* argv[])
 	}
 	ptime stop(time_now_hires());
 
-	fprintf(stderr, "bdecode done in        %5d ns per message\n"
+	std::fprintf(stderr, "bdecode done in        %5d ns per message\n"
 		, int(total_microseconds(stop - start) / 1000));
 	}
 

test/bittorrent_peer.cpp

@@ -261,7 +261,7 @@ void peer_conn::close(char const* fmt, error_code const& ec)
 {
 	end_time = clock_type::now();
 	char tmp[1024];
-	snprintf(tmp, sizeof(tmp), fmt, ec.message().c_str());
+	std::snprintf(tmp, sizeof(tmp), fmt, ec.message().c_str());
 	int time = int(total_milliseconds(end_time - start_time));
 	if (time == 0) time = 1;
 	float up = (boost::int64_t(blocks_sent) * 0x4000) / time / 1000.f;
@@ -272,13 +272,13 @@ void peer_conn::close(char const* fmt, error_code const& ec)
 	address const& addr = s.local_endpoint(e).address();
 #if TORRENT_USE_IPV6
 	if (addr.is_v6())
-		snprintf(ep_str, sizeof(ep_str), "[%s]:%d", addr.to_string(e).c_str()
+		std::snprintf(ep_str, sizeof(ep_str), "[%s]:%d", addr.to_string(e).c_str()
 			, s.local_endpoint(e).port());
 	else
 #endif
-		snprintf(ep_str, sizeof(ep_str), "%s:%d", addr.to_string(e).c_str()
+		std::snprintf(ep_str, sizeof(ep_str), "%s:%d", addr.to_string(e).c_str()
 			, s.local_endpoint(e).port());
-	printf("%s ep: %s sent: %d received: %d duration: %d ms up: %.1fMB/s down: %.1fMB/s\n"
+	std::printf("%s ep: %s sent: %d received: %d duration: %d ms up: %.1fMB/s down: %.1fMB/s\n"
 		, tmp, ep_str, blocks_sent, blocks_received, time, up, down);
 }
 
@@ -325,7 +325,7 @@ void peer_conn::on_msg_length(error_code const& ec, size_t bytes_transferred)
 	unsigned int length = read_uint32(ptr);
 	if (length > sizeof(buffer))
 	{
-		fprintf(stderr, "len: %u\n", length);
+		std::fprintf(stderr, "len: %u\n", length);
 		close("ERROR RECEIVE MESSAGE PREFIX: packet too big", error_code());
 		return;
 	}
@@ -478,7 +478,7 @@ void peer_conn::on_message(error_code const& ec, size_t bytes_transferred)
 				}
 			}
 			--outstanding_requests;
-			fprintf(stderr, "REJECT: [ piece: %d start: %d length: %d ]\n", piece, start, length);
+			std::fprintf(stderr, "REJECT: [ piece: %d start: %d length: %d ]\n", piece, start, length);
 		}
 		else if (msg == 0) // choke
 		{
@@ -516,7 +516,7 @@ bool peer_conn::verify_piece(int piece, int start, char const* ptr, int size)
 	{
 		if (buf[i] != fill)
 		{
-			fprintf(stderr, "received invalid block. piece %d block %d\n", piece, start / 0x4000);
+			std::fprintf(stderr, "received invalid block. piece %d block %d\n", piece, start / 0x4000);
 			exit(1);
 			return false;
 		}

test/dht_server.cpp

@@ -72,24 +72,24 @@ struct dht_server
 		m_socket.open(udp::v4(), ec);
 		if (ec)
 		{
-			fprintf(stderr, "Error opening listen DHT socket: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "Error opening listen DHT socket: %s\n", ec.message().c_str());
 			return;
 		}
 
 		m_socket.bind(udp::endpoint(address_v4::any(), 0), ec);
 		if (ec)
 		{
-			fprintf(stderr, "Error binding DHT socket to port 0: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "Error binding DHT socket to port 0: %s\n", ec.message().c_str());
 			return;
 		}
 		m_port = m_socket.local_endpoint(ec).port();
 		if (ec)
 		{
-			fprintf(stderr, "Error getting local endpoint of DHT socket: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "Error getting local endpoint of DHT socket: %s\n", ec.message().c_str());
 			return;
 		}
 
-		fprintf(stderr, "%s: DHT initialized on port %d\n", time_now_string(), m_port);
+		std::fprintf(stderr, "%s: DHT initialized on port %d\n", time_now_string(), m_port);
 
 		m_thread = boost::make_shared<std::thread>(&dht_server::thread_fun, this);
 	}
@@ -136,7 +136,7 @@ struct dht_server
 
 			if (ec)
 			{
-				fprintf(stderr, "Error receiving on DHT socket: %s\n", ec.message().c_str());
+				std::fprintf(stderr, "Error receiving on DHT socket: %s\n", ec.message().c_str());
 				return;
 			}
 
@@ -151,7 +151,7 @@ struct dht_server
 			}
 			catch (std::exception& e)
 			{
-				fprintf(stderr, "failed to decode DHT message: %s\n", e.what());
+				std::fprintf(stderr, "failed to decode DHT message: %s\n", e.what());
 			}
 		}
 	}

test/enum_if.cpp

@@ -45,26 +45,26 @@ int main()
 	address def_gw = get_default_gateway(ios, ec);
 	if (ec)
 	{
-		fprintf(stderr, "%s\n", ec.message().c_str());
+		std::fprintf(stderr, "%s\n", ec.message().c_str());
 		return 1;
 	}
 
-	printf("Default gateway: %s\n", def_gw.to_string(ec).c_str());
+	std::printf("Default gateway: %s\n", def_gw.to_string(ec).c_str());
 
-	printf("=========== Routes ===========\n");
+	std::printf("=========== Routes ===========\n");
 	std::vector<ip_route> routes = enum_routes(ios, ec);
 	if (ec)
 	{
-		printf("%s\n", ec.message().c_str());
+		std::printf("%s\n", ec.message().c_str());
 		return 1;
 	}
 
-	printf("%-18s%-18s%-35s%-7sinterface\n", "destination", "network", "gateway", "mtu");
+	std::printf("%-18s%-18s%-35s%-7sinterface\n", "destination", "network", "gateway", "mtu");
 
 	for (std::vector<ip_route>::const_iterator i = routes.begin()
 		, end(routes.end()); i != end; ++i)
 	{
-		printf("%-18s%-18s%-35s%-7d%s\n"
+		std::printf("%-18s%-18s%-35s%-7d%s\n"
 			, i->destination.to_string(ec).c_str()
 			, i->netmask.to_string(ec).c_str()
 			, i->gateway.to_string(ec).c_str()
@@ -72,21 +72,21 @@ int main()
 			, i->name);
 	}
 
-	printf("========= Interfaces =========\n");
+	std::printf("========= Interfaces =========\n");
 
 	std::vector<ip_interface> const& net = enum_net_interfaces(ios, ec);
 	if (ec)
 	{
-		printf("%s\n", ec.message().c_str());
+		std::printf("%s\n", ec.message().c_str());
 		return 1;
 	}
 
-	printf("%-30s%-45s%-20s%-8sflags\n", "address", "netmask", "name", "mtu");
+	std::printf("%-30s%-45s%-20s%-8sflags\n", "address", "netmask", "name", "mtu");
 
 	for (std::vector<ip_interface>::const_iterator i = net.begin()
 		, end(net.end()); i != end; ++i)
 	{
-		printf("%-30s%-45s%-20s%-8d%s%s%s\n"
+		std::printf("%-30s%-45s%-20s%-8d%s%s%s\n"
 			, i->interface_address.to_string(ec).c_str()
 			, i->netmask.to_string(ec).c_str()
 			, i->name

test/main.cpp

@@ -88,7 +88,7 @@ void output_test_log_to_terminal()
 	dup2(old_stderr, fileno(stderr));
 
 	fseek(current_test->output, 0, SEEK_SET);
-	fprintf(stderr, "\x1b[1m[%s]\x1b[0m\n\n", current_test->name);
+	std::fprintf(stderr, "\x1b[1m[%s]\x1b[0m\n\n", current_test->name);
 	char buf[4096];
 	int size = 0;
 	do {
@@ -144,7 +144,7 @@ LONG WINAPI seh_exception_handler(LPEXCEPTION_POINTERS p)
 #undef EXC
 	};
 
-	fprintf(stderr, "exception: (0x%x) %s caught:\n%s\n"
+	std::fprintf(stderr, "exception: (0x%x) %s caught:\n%s\n"
 		, code, name, stack_text);
 
 	output_test_log_to_terminal();
@@ -189,7 +189,7 @@ void sig_handler(int sig)
 #endif
 #undef SIG
 	};
-	fprintf(stderr, "signal: (%d) %s caught:\n%s\n"
+	std::fprintf(stderr, "signal: (%d) %s caught:\n%s\n"
 		, sig, name, stack_text);
 
 	output_test_log_to_terminal();
@@ -201,7 +201,7 @@ void sig_handler(int sig)
 
 void print_usage(char const* executable)
 {
-	printf("%s [options] [tests...]\n"
+	std::printf("%s [options] [tests...]\n"
 		"\n"
 		"OPTIONS:\n"
 		"-h,--help           show this help\n"
@@ -234,10 +234,10 @@ EXPORT int main(int argc, char const* argv[])
 
 		if (strcmp(argv[0], "-l") == 0 || strcmp(argv[0], "--list") == 0)
 		{
-			printf("TESTS:\n");
+			std::printf("TESTS:\n");
 			for (int i = 0; i < _g_num_unit_tests; ++i)
 			{
-				printf(" - %s\n", _g_unit_tests[i].name);
+				std::printf(" - %s\n", _g_unit_tests[i].name);
 			}
 			return 0;
 		}
@@ -305,13 +305,13 @@ EXPORT int main(int argc, char const* argv[])
 	process_id = getpid();
 #endif
 	char dir[40];
-	snprintf(dir, sizeof(dir), "test_tmp_%u", process_id);
+	std::snprintf(dir, sizeof(dir), "test_tmp_%u", process_id);
 	std::string test_dir = complete(dir);
 	error_code ec;
 	create_directory(test_dir, ec);
 	if (ec)
 	{
-		fprintf(stderr, "Failed to create test directory: %s\n", ec.message().c_str());
+		std::fprintf(stderr, "Failed to create test directory: %s\n", ec.message().c_str());
 		return 1;
 	}
 #ifdef TORRENT_WINDOWS
@@ -319,13 +319,13 @@ EXPORT int main(int argc, char const* argv[])
 #else
 	chdir(dir);
 #endif
-	fprintf(stderr, "cwd = \"%s\"\n", test_dir.c_str());
+	std::fprintf(stderr, "cwd = \"%s\"\n", test_dir.c_str());
 
 	int total_failures = 0;
 
 	if (_g_num_unit_tests == 0)
 	{
-		fprintf(stderr, "\x1b[31mERROR: no unit tests registered\x1b[0m\n");
+		std::fprintf(stderr, "\x1b[31mERROR: no unit tests registered\x1b[0m\n");
 		return 1;
 	}
 
@@ -360,13 +360,13 @@ EXPORT int main(int argc, char const* argv[])
 				}
 				else
 				{
-					fprintf(stderr, "failed to redirect output: (%d) %s\n"
+					std::fprintf(stderr, "failed to redirect output: (%d) %s\n"
 						, errno, strerror(errno));
 				}
 			}
 			else
 			{
-				fprintf(stderr, "failed to create temporary file for redirecting "
+				std::fprintf(stderr, "failed to create temporary file for redirecting "
 					"output: (%d) %s\n", errno, strerror(errno));
 			}
 		}
@@ -390,7 +390,7 @@ EXPORT int main(int argc, char const* argv[])
 		catch (boost::system::system_error const& e)
 		{
 			char buf[200];
-			snprintf(buf, sizeof(buf), "Terminated with system_error: (%d) [%s] \"%s\""
+			std::snprintf(buf, sizeof(buf), "Terminated with system_error: (%d) [%s] \"%s\""
 				, e.code().value()
 				, e.code().category().name()
 				, e.code().message().c_str());
@@ -399,7 +399,7 @@ EXPORT int main(int argc, char const* argv[])
 		catch (std::exception const& e)
 		{
 			char buf[200];
-			snprintf(buf, sizeof(buf), "Terminated with exception: \"%s\"", e.what());
+			std::snprintf(buf, sizeof(buf), "Terminated with exception: \"%s\"", e.what());
 			report_failure(buf, __FILE__, __LINE__);
 		}
 		catch (...)
@@ -434,17 +434,17 @@ EXPORT int main(int argc, char const* argv[])
 
 	if (!tests_to_run.empty())
 	{
-		fprintf(stderr, "\x1b[1mUNKONWN tests:\x1b[0m\n");
+		std::fprintf(stderr, "\x1b[1mUNKONWN tests:\x1b[0m\n");
 		for (std::set<std::string>::iterator i = tests_to_run.begin()
 			, end(tests_to_run.end()); i != end; ++i)
 		{
-			fprintf(stderr, "  %s\n", i->c_str());
+			std::fprintf(stderr, "  %s\n", i->c_str());
 		}
 	}
 
 	if (num_run == 0)
 	{
-		fprintf(stderr, "\x1b[31mERROR: no unit tests run\x1b[0m\n");
+		std::fprintf(stderr, "\x1b[31mERROR: no unit tests run\x1b[0m\n");
 		return 1;
 	}
 
@@ -468,7 +468,7 @@ EXPORT int main(int argc, char const* argv[])
 	{
 		remove_all(test_dir, ec);
 		if (ec)
-			fprintf(stderr, "failed to remove test dir: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "failed to remove test dir: %s\n", ec.message().c_str());
 	}
 #endif
 

test/make_torrent.cpp

@@ -101,7 +101,7 @@ boost::shared_ptr<libtorrent::torrent_info> make_test_torrent(
 				file_entry["attr"].string() += "x";
 
 			char filename[100];
-			snprintf(filename, sizeof(filename), "test_file-%d", i);
+			std::snprintf(filename, sizeof(filename), "test_file-%d", i);
 
 			std::string name = filename;
 			if (ent.find("name=") != std::string::npos)
@@ -197,7 +197,7 @@ void generate_files(libtorrent::torrent_info const& ti, std::string const& path
 		int ret = st.writev(&b, 1, i, 0, 0, ec);
 		if (ret != piece_size || ec)
 		{
-			fprintf(stderr, "ERROR writing files: (%d expected %d) %s\n"
+			std::fprintf(stderr, "ERROR writing files: (%d expected %d) %s\n"
 				, ret, piece_size, ec.ec.message().c_str());
 		}
 	}

test/peer_server.cpp

@@ -70,30 +70,30 @@ struct peer_server
 		m_acceptor.open(tcp::v4(), ec);
 		if (ec)
 		{
-			fprintf(stderr, "PEER Error opening peer listen socket: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "PEER Error opening peer listen socket: %s\n", ec.message().c_str());
 			return;
 		}
 
 		m_acceptor.bind(tcp::endpoint(address_v4::any(), 0), ec);
 		if (ec)
 		{
-			fprintf(stderr, "PEER Error binding peer socket to port 0: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "PEER Error binding peer socket to port 0: %s\n", ec.message().c_str());
 			return;
 		}
 		m_port = m_acceptor.local_endpoint(ec).port();
 		if (ec)
 		{
-			fprintf(stderr, "PEER Error getting local endpoint of peer socket: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "PEER Error getting local endpoint of peer socket: %s\n", ec.message().c_str());
 			return;
 		}
 		m_acceptor.listen(10, ec);
 		if (ec)
 		{
-			fprintf(stderr, "PEER Error listening on peer socket: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "PEER Error listening on peer socket: %s\n", ec.message().c_str());
 			return;
 		}
 
-		fprintf(stderr, "%s: PEER peer initialized on port %d\n", time_now_string(), m_port);
+		std::fprintf(stderr, "%s: PEER peer initialized on port %d\n", time_now_string(), m_port);
 
 		m_thread = std::make_shared<std::thread>(&peer_server::thread_fun, this);
 	}
@@ -136,11 +136,11 @@ struct peer_server
 
 			if (ec)
 			{
-				fprintf(stderr, "PEER Error accepting connection on peer socket: %s\n", ec.message().c_str());
+				std::fprintf(stderr, "PEER Error accepting connection on peer socket: %s\n", ec.message().c_str());
 				return;
 			}
 
-			fprintf(stderr, "%s: PEER incoming peer connection\n", time_now_string());
+			std::fprintf(stderr, "%s: PEER incoming peer connection\n", time_now_string());
 			++m_peer_requests;
 			socket.close(ec);
 		}

test/print_alerts.cpp

@@ -64,7 +64,7 @@ void print_alerts(libtorrent::session* ses, libtorrent::time_point start_time)
 #endif
 		lt::time_duration d = a->timestamp() - start_time;
 		boost::uint32_t millis = boost::uint32_t(lt::duration_cast<lt::milliseconds>(d).count());
-		printf("%4d.%03d: %-25s %s\n", millis / 1000, millis % 1000
+		std::printf("%4d.%03d: %-25s %s\n", millis / 1000, millis % 1000
 			, a->what()
 			, a->message().c_str());
 	}

test/setup_transfer.cpp

@@ -165,7 +165,7 @@ alert const* wait_for_alert(lt::session& ses, int type, char const* name)
 		for (std::vector<alert*>::iterator i = alerts.begin()
 			, end(alerts.end()); i != end; ++i)
 		{
-			fprintf(stderr, "%s: %s: [%s] %s\n", time_now_string(), name
+			std::fprintf(stderr, "%s: %s: [%s] %s\n", time_now_string(), name
 				, (*i)->what(), (*i)->message().c_str());
 			if ((*i)->type() == type && !ret)
 			{
@@ -245,7 +245,7 @@ void save_file(char const* filename, char const* data, int size)
 	TEST_CHECK(!ec);
 	if (ec)
 	{
-		fprintf(stderr, "ERROR opening file '%s': %s\n", filename, ec.message().c_str());
+		std::fprintf(stderr, "ERROR opening file '%s': %s\n", filename, ec.message().c_str());
 		return;
 	}
 	file::iovec_t b = { (void*)data, size_t(size) };
@@ -253,7 +253,7 @@ void save_file(char const* filename, char const* data, int size)
 	TEST_CHECK(!ec);
 	if (ec)
 	{
-		fprintf(stderr, "ERROR writing file '%s': %s\n", filename, ec.message().c_str());
+		std::fprintf(stderr, "ERROR writing file '%s': %s\n", filename, ec.message().c_str());
 		return;
 	}
 
@@ -275,14 +275,14 @@ bool print_alerts(lt::session& ses, char const* name
 		if (predicate && predicate(*i)) ret = true;
 		if (peer_disconnected_alert const* p = alert_cast<peer_disconnected_alert>(*i))
 		{
-			fprintf(stderr, "%s: %s: [%s] (%s): %s\n", time_now_string(), name, (*i)->what(), print_endpoint(p->ip).c_str(), p->message().c_str());
+			std::fprintf(stderr, "%s: %s: [%s] (%s): %s\n", time_now_string(), name, (*i)->what(), print_endpoint(p->ip).c_str(), p->message().c_str());
 		}
 		else if ((*i)->message() != "block downloading"
 			&& (*i)->message() != "block finished"
 			&& (*i)->message() != "piece finished"
 			&& !no_output)
 		{
-			fprintf(stderr, "%s: %s: [%s] %s\n", time_now_string(), name, (*i)->what(), (*i)->message().c_str());
+			std::fprintf(stderr, "%s: %s: [%s] %s\n", time_now_string(), name, (*i)->what(), (*i)->message().c_str());
 		}
 
 		TEST_CHECK(alert_cast<fastresume_rejected_alert>(*i) == 0 || allow_failed_fastresume);
@@ -290,7 +290,7 @@ bool print_alerts(lt::session& ses, char const* name
 		peer_error_alert const* pea = alert_cast<peer_error_alert>(*i);
 		if (pea)
 		{
-			fprintf(stderr, "%s: peer error: %s\n", time_now_string(), pea->error.message().c_str());
+			std::fprintf(stderr, "%s: peer error: %s\n", time_now_string(), pea->error.message().c_str());
 			TEST_CHECK((!handles.empty() && h.status().is_seeding)
 				|| pea->error.message() == "connecting to peer"
 				|| pea->error.message() == "closing connection to ourself"
@@ -308,7 +308,7 @@ bool print_alerts(lt::session& ses, char const* name
 		invalid_request_alert const* ira = alert_cast<invalid_request_alert>(*i);
 		if (ira)
 		{
-			fprintf(stderr, "peer error: %s\n", ira->message().c_str());
+			std::fprintf(stderr, "peer error: %s\n", ira->message().c_str());
 			TEST_CHECK(false);
 		}
 	}
@@ -361,7 +361,7 @@ void wait_for_downloading(lt::session& ses, char const* name)
 	} while (a);
 	if (!downloading_done)
 	{
-		fprintf(stderr, "%s: did not receive a state_changed_alert indicating "
+		std::fprintf(stderr, "%s: did not receive a state_changed_alert indicating "
 			"the torrent is downloading. waited: %d ms\n"
 			, name, int(total_milliseconds(clock_type::now() - start)));
 	}
@@ -374,7 +374,7 @@ void print_ses_rate(float time
 {
 	if (st1)
 	{
-		fprintf(stderr, "%3.1fs | %dkB/s %dkB/s %d%% %d cc:%d%s", time
+		std::fprintf(stderr, "%3.1fs | %dkB/s %dkB/s %d%% %d cc:%d%s", time
 			, int(st1->download_payload_rate / 1000)
 			, int(st1->upload_payload_rate / 1000)
 			, int(st1->progress * 100)
@@ -383,7 +383,7 @@ void print_ses_rate(float time
 			, st1->errc ? (" [" + st1->errc.message() + "]").c_str() : "");
 	}
 	if (st2)
-		fprintf(stderr, " : %3.1fs | %dkB/s %dkB/s %d%% %d cc:%d%s", time
+		std::fprintf(stderr, " : %3.1fs | %dkB/s %dkB/s %d%% %d cc:%d%s", time
 			, int(st2->download_payload_rate / 1000)
 			, int(st2->upload_payload_rate / 1000)
 			, int(st2->progress * 100)
@@ -391,7 +391,7 @@ void print_ses_rate(float time
 			, st2->connect_candidates
 			, st2->errc ? (" [" + st1->errc.message() + "]").c_str() : "");
 	if (st3)
-		fprintf(stderr, " : %3.1fs | %dkB/s %dkB/s %d%% %d cc:%d%s", time
+		std::fprintf(stderr, " : %3.1fs | %dkB/s %dkB/s %d%% %d cc:%d%s", time
 			, int(st3->download_payload_rate / 1000)
 			, int(st3->upload_payload_rate / 1000)
 			, int(st3->progress * 100)
@@ -399,7 +399,7 @@ void print_ses_rate(float time
 			, st3->connect_candidates
 			, st3->errc ? (" [" + st1->errc.message() + "]").c_str() : "");
 
-	fprintf(stderr, "\n");
+	std::fprintf(stderr, "\n");
 }
 
 void test_sleep(int milliseconds)
@@ -430,7 +430,7 @@ static std::map<int, proxy_t> running_proxies;
 
 void stop_proxy(int port)
 {
-	fprintf(stderr, "stopping proxy on port %d\n", port);
+	std::fprintf(stderr, "stopping proxy on port %d\n", port);
 	// don't shut down proxies until the test is
 	// completely done. This saves a lot of time.
 	// they're closed at the end of main() by
@@ -442,7 +442,7 @@ pid_type async_run(char const* cmdline)
 {
 #ifdef _WIN32
 	char buf[2048];
-	snprintf(buf, sizeof(buf), "%s", cmdline);
+	std::snprintf(buf, sizeof(buf), "%s", cmdline);
 
 	PROCESS_INFORMATION pi;
 	STARTUPINFOA startup;
@@ -456,7 +456,7 @@ pid_type async_run(char const* cmdline)
 	if (ret == 0)
 	{
 		int error = GetLastError();
-		fprintf(stderr, "failed (%d) %s\n", error, error_code(error, system_category()).message().c_str());
+		std::fprintf(stderr, "failed (%d) %s\n", error, error_code(error, system_category()).message().c_str());
 		return 0;
 	}
 	return pi.dwProcessId;
@@ -482,7 +482,7 @@ pid_type async_run(char const* cmdline)
 	int ret = posix_spawnp(&p, argv[0], NULL, NULL, &argv[0], NULL);
 	if (ret != 0)
 	{
-		fprintf(stderr, "failed (%d) %s\n", errno, strerror(errno));
+		std::fprintf(stderr, "failed (%d) %s\n", errno, strerror(errno));
 		return 0;
 	}
 	return p;
@@ -496,7 +496,7 @@ void stop_process(pid_type p)
 	TerminateProcess(proc, 138);
 	CloseHandle(proc);
 #else
-	printf("killing pid: %d\n", p);
+	std::printf("killing pid: %d\n", p);
 	kill(p, SIGKILL);
 #endif
 }
@@ -568,15 +568,15 @@ int start_proxy(int proxy_type)
 			break;
 	}
 	char buf[512];
-	snprintf(buf, sizeof(buf), "%s --port %d%s", cmd, port, auth);
+	std::snprintf(buf, sizeof(buf), "%s --port %d%s", cmd, port, auth);
 
-	fprintf(stderr, "%s starting proxy on port %d (%s %s)...\n", time_now_string(), port, type, auth);
+	std::fprintf(stderr, "%s starting proxy on port %d (%s %s)...\n", time_now_string(), port, type, auth);
-	fprintf(stderr, "%s\n", buf);
+	std::fprintf(stderr, "%s\n", buf);
 	pid_type r = async_run(buf);
 	if (r == 0) abort();
 	proxy_t t = { r, proxy_type };
 	running_proxies.insert(std::make_pair(port, t));
-	fprintf(stderr, "%s launched\n", time_now_string());
+	std::fprintf(stderr, "%s launched\n", time_now_string());
 	test_sleep(500);
 	return port;
 }
@@ -600,9 +600,9 @@ void create_random_files(std::string const& path, const int file_sizes[], int nu
 	{
 		std::generate(random_data, random_data + 300000, random_byte);
 		char filename[200];
-		snprintf(filename, sizeof(filename), "test%d", i);
+		std::snprintf(filename, sizeof(filename), "test%d", i);
 		char dirname[200];
-		snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
+		std::snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
 
 		std::string full_path = combine_path(path, dirname);
 		error_code ec;
@@ -611,7 +611,7 @@ void create_random_files(std::string const& path, const int file_sizes[], int nu
 
 		int to_write = file_sizes[i];
 		file f(full_path, file::write_only, ec);
-		if (ec) fprintf(stderr, "failed to create file \"%s\": (%d) %s\n"
+		if (ec) std::fprintf(stderr, "failed to create file \"%s\": (%d) %s\n"
 			, full_path.c_str(), ec.value(), ec.message().c_str());
 		boost::int64_t offset = 0;
 		while (to_write > 0)
@@ -619,7 +619,7 @@ void create_random_files(std::string const& path, const int file_sizes[], int nu
 			int s = (std::min)(to_write, 300000);
 			file::iovec_t b = { random_data, size_t(s)};
 			f.writev(offset, &b, 1, ec);
-			if (ec) fprintf(stderr, "failed to write file \"%s\": (%d) %s\n"
+			if (ec) std::fprintf(stderr, "failed to write file \"%s\": (%d) %s\n"
 				, full_path.c_str(), ec.value(), ec.message().c_str());
 			offset += s;
 			to_write -= s;
@@ -653,7 +653,7 @@ boost::shared_ptr<torrent_info> create_torrent(std::ostream* file
 		int res = load_file(ssl_certificate, file_buf, ec);
 		if (ec || res < 0)
 		{
-			fprintf(stderr, "failed to load SSL certificate: %s\n", ec.message().c_str());
+			std::fprintf(stderr, "failed to load SSL certificate: %s\n", ec.message().c_str());
 		}
 		else
 		{
@@ -767,7 +767,7 @@ setup_transfer(lt::session* ses1, lt::session* ses2, lt::session* ses3
 		}
 		char ih_hex[41];
 		to_hex((char const*)&t->info_hash()[0], 20, ih_hex);
-		fprintf(stderr, "generated torrent: %s tmp1%s/temporary\n", ih_hex, suffix.c_str());
+		std::fprintf(stderr, "generated torrent: %s tmp1%s/temporary\n", ih_hex, suffix.c_str());
 	}
 	else
 	{
@@ -788,7 +788,7 @@ setup_transfer(lt::session* ses1, lt::session* ses2, lt::session* ses3
 	torrent_handle tor1 = ses1->add_torrent(param, ec);
 	if (ec)
 	{
-		fprintf(stderr, "ses1.add_torrent: %s\n", ec.message().c_str());
+		std::fprintf(stderr, "ses1.add_torrent: %s\n", ec.message().c_str());
 		return boost::make_tuple(torrent_handle(), torrent_handle(), torrent_handle());
 	}
 	tor1.super_seeding(super_seeding);
@@ -841,16 +841,16 @@ setup_transfer(lt::session* ses1, lt::session* ses2, lt::session* ses3
 		if (use_ssl_ports)
 		{
 			port = ses2->ssl_listen_port();
-			fprintf(stderr, "%s: ses2->ssl_listen_port(): %d\n", time_now_string(), port);
+			std::fprintf(stderr, "%s: ses2->ssl_listen_port(): %d\n", time_now_string(), port);
 		}
 
 		if (port == 0)
 		{
 			port = ses2->listen_port();
-			fprintf(stderr, "%s: ses2->listen_port(): %d\n", time_now_string(), port);
+			std::fprintf(stderr, "%s: ses2->listen_port(): %d\n", time_now_string(), port);
 		}
 
-		fprintf(stderr, "%s: ses1: connecting peer port: %d\n"
+		std::fprintf(stderr, "%s: ses1: connecting peer port: %d\n"
 			, time_now_string(), port);
 		tor1.connect_peer(tcp::endpoint(address::from_string("127.0.0.1", ec)
 			, port));
@@ -873,10 +873,10 @@ setup_transfer(lt::session* ses1, lt::session* ses2, lt::session* ses3
 			if (port == 0) port = ses2->listen_port();
 			if (port2 == 0) port2 = ses1->listen_port();
 
-			fprintf(stderr, "ses3: connecting peer port: %d\n", port);
+			std::fprintf(stderr, "ses3: connecting peer port: %d\n", port);
 			tor3.connect_peer(tcp::endpoint(
 					address::from_string("127.0.0.1", ec), port));
-			fprintf(stderr, "ses3: connecting peer port: %d\n", port2);
+			std::fprintf(stderr, "ses3: connecting peer port: %d\n", port2);
 				tor3.connect_peer(tcp::endpoint(
 					address::from_string("127.0.0.1", ec)
 					, port2));
@@ -904,16 +904,16 @@ int start_web_server(bool ssl, bool chunked_encoding, bool keepalive)
 	} while (ec);
 
 	char buf[200];
-	snprintf(buf, sizeof(buf), "python ../web_server.py %d %d %d %d"
+	std::snprintf(buf, sizeof(buf), "python ../web_server.py %d %d %d %d"
 		, port, chunked_encoding , ssl, keepalive);
 
-	fprintf(stderr, "%s starting web_server on port %d...\n", time_now_string(), port);
+	std::fprintf(stderr, "%s starting web_server on port %d...\n", time_now_string(), port);
 
-	fprintf(stderr, "%s\n", buf);
+	std::fprintf(stderr, "%s\n", buf);
 	pid_type r = async_run(buf);
 	if (r == 0) abort();
 	web_server_pid = r;
-	fprintf(stderr, "%s launched\n", time_now_string());
+	std::fprintf(stderr, "%s launched\n", time_now_string());
 	test_sleep(500);
 	return port;
 }
@@ -921,7 +921,7 @@ int start_web_server(bool ssl, bool chunked_encoding, bool keepalive)
 void stop_web_server()
 {
 	if (web_server_pid == 0) return;
-	fprintf(stderr, "stopping web server\n");
+	std::fprintf(stderr, "stopping web server\n");
 	stop_process(web_server_pid);
 	web_server_pid = 0;
 }

test/swarm_suite.cpp

@@ -47,7 +47,7 @@ void test_swarm(int flags)
 	using namespace libtorrent;
 	namespace lt = libtorrent;
 
-	fprintf(stderr, "\n\n ==== TEST SWARM === %s%s%s%s%s ===\n\n\n"
+	std::fprintf(stderr, "\n\n ==== TEST SWARM === %s%s%s%s%s ===\n\n\n"
 		, (flags & super_seeding) ? "super-seeding ": ""
 		, (flags & strict_super_seeding) ? "strict-super-seeding ": ""
 		, (flags & seed_mode) ? "seed-mode ": ""
@@ -94,7 +94,7 @@ void test_swarm(int flags)
 
 	int port = lt::random() % 100;
 	char iface[50];
-	snprintf(iface, sizeof(iface), "0.0.0.0:480%02d", port);
+	std::snprintf(iface, sizeof(iface), "0.0.0.0:480%02d", port);
 	pack.set_int(settings_pack::upload_rate_limit, int(rate_limit));
 	pack.set_str(settings_pack::listen_interfaces, iface);
 	pack.set_int(settings_pack::max_retry_port_bind, 1000);
@@ -104,13 +104,13 @@ void test_swarm(int flags)
 
 	lt::session ses1(pack);
 
-	snprintf(iface, sizeof(iface), "0.0.0.0:490%02d", port);
+	std::snprintf(iface, sizeof(iface), "0.0.0.0:490%02d", port);
 	pack.set_str(settings_pack::listen_interfaces, iface);
 	pack.set_int(settings_pack::download_rate_limit, int(rate_limit / 2));
 	pack.set_int(settings_pack::upload_rate_limit, int(rate_limit));
 	lt::session ses2(pack);
 
-	snprintf(iface, sizeof(iface), "0.0.0.0:500%02d", port);
+	std::snprintf(iface, sizeof(iface), "0.0.0.0:500%02d", port);
 	pack.set_str(settings_pack::listen_interfaces, iface);
 	lt::session ses3(pack);
 
@@ -200,19 +200,19 @@ void test_swarm(int flags)
 	alert const* ret;
 	while ((ret = ses1.wait_for_alert(seconds(2))))
 	{
-		fprintf(stderr, "wait returned: %d ms\n"
+		std::fprintf(stderr, "wait returned: %d ms\n"
 			, int(total_milliseconds(clock_type::now() - start)));
 		std::vector<alert*> alerts;
 		ses1.pop_alerts(&alerts);
 		for (std::vector<alert*>::iterator i = alerts.begin()
 			, end(alerts.end()); i != end; ++i)
 		{
-			fprintf(stderr, "%s\n", ret->message().c_str());
+			std::fprintf(stderr, "%s\n", ret->message().c_str());
 		}
 		start = clock_type::now();
 	}
 
-	fprintf(stderr, "loop returned: %d ms\n"
+	std::fprintf(stderr, "loop returned: %d ms\n"
 		, int(total_milliseconds(clock_type::now() - start)));
 
 	// this allows shutting down the sessions in parallel
@@ -222,7 +222,7 @@ void test_swarm(int flags)
 
 	time_point end = clock_type::now();
 
-	fprintf(stderr, "time: %d ms\n", int(total_milliseconds(end - start)));
+	std::fprintf(stderr, "time: %d ms\n", int(total_milliseconds(end - start)));
 	TEST_CHECK(end - start < milliseconds(3000));
 	TEST_CHECK(end - start > milliseconds(1900));
 

test/test.cpp

@@ -31,7 +31,7 @@ POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include <vector>
-#include <stdio.h> // for tmpfile()
+
 #include "test.hpp"
 
 unit_test_t _g_unit_tests[1024];
@@ -49,8 +49,8 @@ int test_counter()
 void report_failure(char const* err, char const* file, int line)
 {
 	char buf[500];
-	snprintf(buf, sizeof(buf), "\x1b[41m***** %s:%d \"%s\" *****\x1b[0m\n", file, line, err);
+	std::snprintf(buf, sizeof(buf), "\x1b[41m***** %s:%d \"%s\" *****\x1b[0m\n", file, line, err);
-	fprintf(stderr, "\n%s\n", buf);
+	std::fprintf(stderr, "\n%s\n", buf);
 	failure_strings.push_back(buf);
 	++_g_test_failures;
 }
@@ -64,7 +64,7 @@ int print_failures()
 		if (len > longest_name) longest_name = len;
 	}
 
-	fprintf(stderr, "\n\n");
+	std::fprintf(stderr, "\n\n");
 
 	for (int i = 0; i < _g_num_unit_tests; ++i)
 	{
@@ -72,22 +72,22 @@ int print_failures()
 
 		if (_g_unit_tests[i].num_failures == 0)
 		{
-			fprintf(stderr, "\x1b[32m[%-*s] ***PASS***\n"
+			std::fprintf(stderr, "\x1b[32m[%-*s] ***PASS***\n"
 				, longest_name, _g_unit_tests[i].name);
 		}
 		else
 		{
-			fprintf(stderr, "\x1b[31m[%-*s] %d FAILURES\n"
+			std::fprintf(stderr, "\x1b[31m[%-*s] %d FAILURES\n"
 				, longest_name
 				, _g_unit_tests[i].name
 				, _g_unit_tests[i].num_failures);
 		}
 	}
 
-	fprintf(stderr, "\x1b[0m");
+	std::fprintf(stderr, "\x1b[0m");
 
 	if (_g_test_failures > 0)
-		fprintf(stderr, "\n\n\x1b[41m   == %d TEST(S) FAILED ==\x1b[0m\n\n\n", _g_test_failures);
+		std::fprintf(stderr, "\n\n\x1b[41m   == %d TEST(S) FAILED ==\x1b[0m\n\n\n", _g_test_failures);
 	return _g_test_failures;
 }
 

test/test.hpp

@@ -40,6 +40,9 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <exception>
 #include <sstream>
 #include <vector>
+#include <cstdio> // for snprintf
+#include <cinttypes> // for PRId64 et.al.
+
 #include <boost/preprocessor/cat.hpp>
 
 #include "libtorrent/config.hpp"

test/test_alert_manager.cpp

@@ -207,7 +207,7 @@ TORRENT_TEST(wait_for_alert)
 
 	time_point end = clock_type::now();
 	TEST_EQUAL(a, static_cast<alert*>(0));
-	fprintf(stderr, "delay: %d ms (expected 1 second)\n"
+	std::fprintf(stderr, "delay: %d ms (expected 1 second)\n"
 		, int(total_milliseconds(end - start)));
 	TEST_CHECK(end - start > milliseconds(900));
 	TEST_CHECK(end - start < milliseconds(1100));
@@ -218,7 +218,7 @@ TORRENT_TEST(wait_for_alert)
 	a = mgr.wait_for_alert(seconds(1));
 	end = clock_type::now();
 
-	fprintf(stderr, "delay: %d ms\n", int(total_milliseconds(end - start)));
+	std::fprintf(stderr, "delay: %d ms\n", int(total_milliseconds(end - start)));
 	TEST_CHECK(end - start < milliseconds(1));
 	TEST_CHECK(a->type() == torrent_added_alert::alert_type);
 
@@ -231,7 +231,7 @@ TORRENT_TEST(wait_for_alert)
 	a = mgr.wait_for_alert(seconds(10));
 	end = clock_type::now();
 
-	fprintf(stderr, "delay: %d ms\n", int(total_milliseconds(end - start)));
+	std::fprintf(stderr, "delay: %d ms\n", int(total_milliseconds(end - start)));
 	TEST_CHECK(end - start < milliseconds(500));
 	TEST_CHECK(a->type() == torrent_added_alert::alert_type);
 

test/test_auto_unchoke.cpp

@@ -99,7 +99,7 @@ void test_swarm()
 
 	std::map<std::string, boost::int64_t> cnt = get_counters(ses1);
 
-	fprintf(stderr, "allowed_upload_slots: %d\n", int(cnt["ses.num_unchoke_slots"]));
+	std::fprintf(stderr, "allowed_upload_slots: %d\n", int(cnt["ses.num_unchoke_slots"]));
 	TEST_EQUAL(cnt["ses.num_unchoke_slots"], 1);
 	for (int i = 0; i < 200; ++i)
 	{
@@ -108,7 +108,7 @@ void test_swarm()
 		print_alerts(ses3, "ses3");
 
 		cnt = get_counters(ses1);
-		fprintf(stderr, "allowed unchoked: %d\n", int(cnt["ses.num_unchoke_slots"]));
+		std::fprintf(stderr, "allowed unchoked: %d\n", int(cnt["ses.num_unchoke_slots"]));
 		if (cnt["ses.num_unchoke_slots"] >= 2) break;
 
 		torrent_status st1 = tor1.status();

test/test_bandwidth_limiter.cpp

@@ -179,7 +179,7 @@ void spawn_connections(connections_t& v, bandwidth_manager& bwm
 	for (int i = 0; i < num; ++i)
 	{
 		char name[200];
-		snprintf(name, sizeof(name), "%s%d", prefix, i);
+		std::snprintf(name, sizeof(name), "%s%d", prefix, i);
 		v.push_back(boost::shared_ptr<peer_connection>(new peer_connection(bwm, bwc, 200, false, name)));
 	}
 }

test/test_bdecode.cpp

@@ -43,7 +43,7 @@ TORRENT_TEST(integer)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_CHECK(ret == 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	std::pair<const char*, int> section = e.data_section();
 	TEST_CHECK(std::memcmp(b, section.first, section.second) == 0);
 	TEST_CHECK(section.second == sizeof(b) - 1);
@@ -59,7 +59,7 @@ TORRENT_TEST(string)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_CHECK(ret == 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	std::pair<const char*, int> section = e.data_section();
 	TEST_CHECK(std::memcmp(b, section.first, section.second) == 0);
 	TEST_EQUAL(section.second, sizeof(b) - 1);
@@ -80,7 +80,7 @@ TORRENT_TEST(string_prefix1)
 	error_code ec;
 	int ret = bdecode(test.c_str(), test.c_str() + test.size(), e, ec);
 	TEST_CHECK(ret == 0);
-	printf("%d bytes string\n", e.string_length());
+	std::printf("%d bytes string\n", e.string_length());
 	std::pair<const char*, int> section = e.data_section();
 	TEST_CHECK(std::memcmp(test.c_str(), section.first, section.second) == 0);
 	TEST_EQUAL(section.second, int(test.size()));
@@ -97,7 +97,7 @@ TORRENT_TEST(list)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_CHECK(ret == 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	std::pair<const char*, int> section = e.data_section();
 	TEST_CHECK(std::memcmp(b, section.first, section.second) == 0);
 	TEST_CHECK(section.second == sizeof(b) - 1);
@@ -121,7 +121,7 @@ TORRENT_TEST(dict)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	std::pair<const char*, int> section = e.data_section();
 	TEST_CHECK(std::memcmp(b, section.first, section.second) == 0);
 	TEST_CHECK(section.second == sizeof(b) - 1);
@@ -149,7 +149,7 @@ TORRENT_TEST(dict_key_novalue)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 10);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_value));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test dictionary with a key that's not a string
@@ -163,7 +163,7 @@ TORRENT_TEST(dict_nonstring_key)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 1);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // dictionary key with \0
@@ -189,7 +189,7 @@ TORRENT_TEST(premature_e)
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test strings with negative length-prefix
@@ -203,7 +203,7 @@ TORRENT_TEST(negative_length_prefix)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 0);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_value));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test strings with overflow length-prefix
@@ -217,7 +217,7 @@ TORRENT_TEST(overflow_length_prefix)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 19);
 	TEST_EQUAL(ec,  error_code(bdecode_errors::overflow));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test strings with almost overflow (more than 8 digits)
@@ -231,7 +231,7 @@ TORRENT_TEST(close_overflow_length_prefix)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 8);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test strings with overflow (more than 8 digits)
@@ -246,7 +246,7 @@ TORRENT_TEST(overflow_length_prefix2)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 0);
 	TEST_EQUAL(ec, error_code(bdecode_errors::limit_exceeded));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test integer without any digits
@@ -260,7 +260,7 @@ TORRENT_TEST(nodigit_int)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 1);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test integer with just a minus
@@ -274,7 +274,7 @@ TORRENT_TEST(minus_int)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 2);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test integer with a minus inserted in it
@@ -288,7 +288,7 @@ TORRENT_TEST(interior_minus_int)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 6);
 	TEST_EQUAL(ec,  error_code(bdecode_errors::expected_digit));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test integers that don't fit in 64 bits
@@ -299,7 +299,7 @@ TORRENT_TEST(int_overflow)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	// the lazy aspect makes this overflow when asking for
 	// the value. turning it to zero.
 	TEST_EQUAL(e.int_value(), 0);
@@ -316,7 +316,7 @@ TORRENT_TEST(int_overflow2)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 22);
 	TEST_EQUAL(ec,  error_code(bdecode_errors::overflow));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test truncated negative integer
@@ -330,7 +330,7 @@ TORRENT_TEST(int_truncated)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 2);
 	TEST_EQUAL(ec,  error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // bdecode_error
@@ -351,7 +351,7 @@ TORRENT_TEST(64bit_int)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_CHECK(ret == 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	TEST_CHECK(e.int_value() == 9223372036854775807LL);
 }
 
@@ -363,7 +363,7 @@ TORRENT_TEST(64bit_int_negative)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_CHECK(ret == 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	TEST_CHECK(e.int_value() == -9223372036854775807LL);
 }
 
@@ -378,7 +378,7 @@ TORRENT_TEST(int_invalid_digit)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 9);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test invalid encoding
@@ -399,7 +399,7 @@ TORRENT_TEST(invalid_encoding)
 		, 0xa1, 0x88, 0x7a, 0x8d, 0xc3, 0xd6, 0x31, 0x3a
 		, 0x79, 0x31, 0xae, 0x71, 0x65, 0};
 
-	printf("%s\n", buf);
+	std::printf("%s\n", buf);
 	bdecode_node e;
 	error_code ec;
 	int ret = bdecode((char*)buf, (char*)buf + sizeof(buf), e, ec);
@@ -456,7 +456,7 @@ TORRENT_TEST(unepected_eof)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 5);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test unexpected EOF (really expected terminator)
@@ -471,7 +471,7 @@ TORRENT_TEST(unepected_eof2)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 6);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_colon));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test expected string
@@ -487,7 +487,7 @@ TORRENT_TEST(expected_string)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 1);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test unexpected EOF while parsing dict key
@@ -502,7 +502,7 @@ TORRENT_TEST(unexpected_eof_dict_key)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 5);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test unexpected EOF while parsing dict key
@@ -517,7 +517,7 @@ TORRENT_TEST(unexpected_eof_dict_key2)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 5);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test expected string while parsing dict key
@@ -532,7 +532,7 @@ TORRENT_TEST(expected_string_dict_key2)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 1);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test unexpected EOF while parsing int
@@ -547,7 +547,7 @@ TORRENT_TEST(unexpected_eof_int)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 1);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test unexpected EOF while parsing int
@@ -562,7 +562,7 @@ TORRENT_TEST(unexpected_eof_int2)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 3);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 
@@ -578,7 +578,7 @@ TORRENT_TEST(expected_colon_dict)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 5);
 	TEST_EQUAL(ec, error_code(bdecode_errors::expected_colon));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test empty string
@@ -591,7 +591,7 @@ TORRENT_TEST(empty_string)
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test partial string
@@ -606,7 +606,7 @@ TORRENT_TEST(partial_string)
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(pos, 3);
 	TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 TORRENT_TEST(list_ints)
@@ -616,7 +616,7 @@ TORRENT_TEST(list_ints)
 	for (int i = 0; i < 1000; ++i)
 	{
 		char tmp[20];
-		snprintf(tmp, sizeof(tmp), "i%de", i);
+		std::snprintf(tmp, sizeof(tmp), "i%de", i);
 		buf += tmp;
 	}
 	buf += "e";
@@ -640,12 +640,12 @@ TORRENT_TEST(dict_ints)
 	for (int i = 0; i < 1000; ++i)
 	{
 		char tmp[30];
-		snprintf(tmp, sizeof(tmp), "4:%04di%de", i, i);
+		std::snprintf(tmp, sizeof(tmp), "4:%04di%de", i, i);
 		buf += tmp;
 	}
 	buf += "e";
 
-	printf("%s\n", buf.c_str());
+	std::printf("%s\n", buf.c_str());
 	bdecode_node e;
 	error_code ec;
 	int ret = bdecode((char*)&buf[0], (char*)&buf[0] + buf.size(), e, ec);
@@ -655,7 +655,7 @@ TORRENT_TEST(dict_ints)
 	for (int i = 0; i < 1000; ++i)
 	{
 		char tmp[30];
-		snprintf(tmp, sizeof(tmp), "%04d", i);
+		std::snprintf(tmp, sizeof(tmp), "%04d", i);
 		TEST_EQUAL(e.dict_find_int_value(tmp), i);
 	}
 }
@@ -707,7 +707,7 @@ TORRENT_TEST(exceed_buf_limit)
 	int ret = bdecode(b, b + 0x3fffffff, e, ec);
 	TEST_EQUAL(ret, -1);
 	TEST_EQUAL(ec, error_code(bdecode_errors::limit_exceeded));
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 }
 
 // test parse_int
@@ -786,7 +786,7 @@ TORRENT_TEST(dict_find_funs)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(e.type(), bdecode_node::dict_t);
 
@@ -855,7 +855,7 @@ TORRENT_TEST(list_at_funs)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(e.type(), bdecode_node::list_t);
 
@@ -893,7 +893,7 @@ TORRENT_TEST(list_at_reverse)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(e.type(), bdecode_node::list_t);
 
@@ -919,7 +919,7 @@ TORRENT_TEST(dict_find_funs2)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(e.type(), bdecode_node::dict_t);
 
@@ -937,7 +937,7 @@ TORRENT_TEST(print_entry)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(print_entry(e), "[ 1, 'foo', [ 1, 2 ], { 'x': 1 } ]");
 }
@@ -949,7 +949,7 @@ TORRENT_TEST(print_entry2)
 	error_code ec;
 	int ret = bdecode(b, b + sizeof(b)-1, e, ec);
 	TEST_EQUAL(ret, 0);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(print_entry(e), "{ 'a': 1, 'b': 'foo', 'c': [ 1, 2 ], 'd': { 'x': 1 } }");
 }
@@ -974,7 +974,7 @@ TORRENT_TEST(swap)
 	std::string str2 = print_entry(e2);
 	TEST_EQUAL(e1.type(), bdecode_node::dict_t);
 	TEST_EQUAL(e2.type(), bdecode_node::int_t);
-	printf("%s\n", print_entry(e1).c_str());
+	std::printf("%s\n", print_entry(e1).c_str());
 
 	e1.swap(e2);
 
@@ -982,7 +982,7 @@ TORRENT_TEST(swap)
 	TEST_EQUAL(e2.type(), bdecode_node::dict_t);
 	TEST_EQUAL(print_entry(e1), str2);
 	TEST_EQUAL(print_entry(e2), str1);
-	printf("%s\n", print_entry(e1).c_str());
+	std::printf("%s\n", print_entry(e1).c_str());
 
 	e1.swap(e2);
 
@@ -990,7 +990,7 @@ TORRENT_TEST(swap)
 	TEST_EQUAL(e2.type(), bdecode_node::int_t);
 	TEST_EQUAL(print_entry(e1), str1);
 	TEST_EQUAL(print_entry(e2), str2);
-	printf("%s\n", print_entry(e1).c_str());
+	std::printf("%s\n", print_entry(e1).c_str());
 }
 
 // test swap() (one node is the root of the other node)
@@ -1012,7 +1012,7 @@ TORRENT_TEST(swap_root)
 	std::string str2 = print_entry(e2);
 	TEST_EQUAL(e1.type(), bdecode_node::dict_t);
 	TEST_EQUAL(e2.type(), bdecode_node::int_t);
-	printf("%s\n", print_entry(e1).c_str());
+	std::printf("%s\n", print_entry(e1).c_str());
 
 	e1.swap(e2);
 
@@ -1020,7 +1020,7 @@ TORRENT_TEST(swap_root)
 	TEST_EQUAL(e2.type(), bdecode_node::dict_t);
 	TEST_EQUAL(print_entry(e1), str2);
 	TEST_EQUAL(print_entry(e2), str1);
-	printf("%s\n", print_entry(e1).c_str());
+	std::printf("%s\n", print_entry(e1).c_str());
 
 	// swap back
 	e1.swap(e2);
@@ -1029,7 +1029,7 @@ TORRENT_TEST(swap_root)
 	TEST_EQUAL(e2.type(), bdecode_node::int_t);
 	TEST_EQUAL(print_entry(e1), str1);
 	TEST_EQUAL(print_entry(e2), str2);
-	printf("%s\n", print_entry(e1).c_str());
+	std::printf("%s\n", print_entry(e1).c_str());
 }
 
 // test swap() (neither is a root and they don't share a root)
@@ -1120,14 +1120,14 @@ TORRENT_TEST(clear)
 	bdecode_node e;
 	error_code ec;
 	int ret = bdecode(b1, b1 + sizeof(b1)-1, e, ec);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	TEST_EQUAL(ret, 0);
 	TEST_EQUAL(e.type(), bdecode_node::dict_t);
 	TEST_EQUAL(e.dict_size(), 4);
 	TEST_EQUAL(e.dict_at(1).first, "b");
 
 	ret = bdecode(b2, b2 + sizeof(b2)-1, e, ec);
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 	TEST_EQUAL(ret, 0);
 	TEST_EQUAL(e.type(), bdecode_node::list_t);
 	TEST_EQUAL(e.list_size(), 2);
@@ -1144,7 +1144,7 @@ TORRENT_TEST(copy_root)
 	int ret = bdecode(b1, b1 + sizeof(b1)-1, e1, ec);
 	TEST_EQUAL(ret, 0);
 	TEST_EQUAL(e1.type(), bdecode_node::dict_t);
-	printf("%s\n", print_entry(e1).c_str());
+	std::printf("%s\n", print_entry(e1).c_str());
 
 	bdecode_node e2(e1);
 	bdecode_node e3;
@@ -1172,7 +1172,7 @@ TORRENT_TEST(non_owning_refs)
 
 	TEST_EQUAL(ret, 0);
 	TEST_EQUAL(e1.type(), bdecode_node::dict_t);
-	printf("%s\n", print_entry(e1).c_str());
+	std::printf("%s\n", print_entry(e1).c_str());
 
 	bdecode_node e2 = e1.non_owning();
 
@@ -1197,7 +1197,7 @@ TORRENT_TEST(partial_parse)
 	TEST_EQUAL(pos, 35);
 	TEST_EQUAL(e.type(), bdecode_node::dict_t);
 
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(print_entry(e), "{ 'a': 1, 'b': 'foo', 'c': [ 1, 2 ], 'd': { 'x': {} } }");
 }
@@ -1214,7 +1214,7 @@ TORRENT_TEST(partial_parse2)
 	TEST_EQUAL(pos, 29);
 	TEST_EQUAL(e.type(), bdecode_node::dict_t);
 
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(print_entry(e), "{ 'a': 1, 'b': 'foo', 'c': [ 1, 2 ], 'd': {} }");
 }
@@ -1231,7 +1231,7 @@ TORRENT_TEST(partial_parse3)
 	TEST_EQUAL(pos, 26);
 	TEST_EQUAL(e.type(), bdecode_node::dict_t);
 
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(print_entry(e), "{ 'a': 1, 'b': 'foo', 'c': [ 1, 2 ] }");
 }
@@ -1248,7 +1248,7 @@ TORRENT_TEST(partial_parse4)
 	TEST_EQUAL(pos, 22);
 	TEST_EQUAL(e.type(), bdecode_node::dict_t);
 
-	printf("%s\n", print_entry(e).c_str());
+	std::printf("%s\n", print_entry(e).c_str());
 
 	TEST_EQUAL(print_entry(e), "{ 'a': 1, 'b': 'foo', 'c': [ 1 ] }");
 }
@@ -1268,12 +1268,12 @@ TORRENT_TEST(switch_buffer)
 	TEST_EQUAL(e.type(), bdecode_node::dict_t);
 
 	std::string string1 = print_entry(e);
-	printf("%s\n", string1.c_str());
+	std::printf("%s\n", string1.c_str());
 
 	e.switch_underlying_buffer(b2);
 
 	std::string string2 = print_entry(e);
-	printf("%s\n", string2.c_str());
+	std::printf("%s\n", string2.c_str());
 
 	TEST_EQUAL(string1, string2);
 }

test/test_bencoding.cpp

@@ -130,7 +130,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret == 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		std::pair<const char*, int> section = e.data_section();
 		TEST_CHECK(std::memcmp(b, section.first, section.second) == 0);
 		TEST_CHECK(section.second == sizeof(b) - 1);
@@ -144,7 +144,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret == 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		std::pair<const char*, int> section = e.data_section();
 		TEST_CHECK(std::memcmp(b, section.first, section.second) == 0);
 		TEST_CHECK(section.second == sizeof(b) - 1);
@@ -159,7 +159,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret == 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		std::pair<const char*, int> section = e.data_section();
 		TEST_CHECK(std::memcmp(b, section.first, section.second) == 0);
 		TEST_CHECK(section.second == sizeof(b) - 1);
@@ -181,7 +181,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret == 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		std::pair<const char*, int> section = e.data_section();
 		TEST_CHECK(std::memcmp(b, section.first, section.second) == 0);
 		TEST_CHECK(section.second == sizeof(b) - 1);
@@ -219,7 +219,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_CHECK(ec == error_code(bdecode_errors::expected_value
 			, get_bdecode_category()));
 	}
@@ -231,7 +231,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_CHECK(ec == error_code(bdecode_errors::overflow
 			, get_bdecode_category()));
 	}
@@ -243,7 +243,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret == 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		// the lazy aspect makes this overflow when asking for
 		// the value. turning it to zero.
 		TEST_CHECK(e.int_value() == 0);
@@ -256,7 +256,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret == 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_CHECK(e.int_value() == 9223372036854775807LL);
 	}
 
@@ -267,7 +267,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec);
 		TEST_CHECK(ret == 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_CHECK(e.int_value() == -9223372036854775807LL);
 	}
 
@@ -288,7 +288,7 @@ TORRENT_TEST(lazy_entry)
 			, 0xa1, 0x88, 0x7a, 0x8d, 0xc3, 0xd6, 0x31, 0x3a
 			, 0x79, 0x31, 0xae, 0x71, 0x65, 0};
 
-		printf("%s\n", buf);
+		std::printf("%s\n", buf);
 		lazy_entry e;
 		error_code ec;
 		int ret = lazy_bdecode((char*)buf, (char*)buf + sizeof(buf), e, ec);
@@ -339,7 +339,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof
 			, get_bdecode_category()));
 	}
@@ -352,7 +352,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof
 			, get_bdecode_category()));
 	}
@@ -366,7 +366,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit
 			, get_bdecode_category()));
 	}
@@ -379,7 +379,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof
 			, get_bdecode_category()));
 	}
@@ -392,7 +392,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof
 			, get_bdecode_category()));
 	}
@@ -405,7 +405,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit
 			, get_bdecode_category()));
 	}
@@ -418,7 +418,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof
 			, get_bdecode_category()));
 	}
@@ -431,7 +431,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof
 			, get_bdecode_category()));
 	}
@@ -445,7 +445,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::expected_colon
 			, get_bdecode_category()));
 	}
@@ -460,7 +460,7 @@ TORRENT_TEST(lazy_entry)
 		TEST_EQUAL(ret, -1);
 		TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof
 			, get_bdecode_category()));
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 	}
 
 	// test partial string
@@ -471,7 +471,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_CHECK(ret != 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 		TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof
 			, get_bdecode_category()));
 	}
@@ -484,7 +484,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_EQUAL(ret, 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 
 		pascal_string ps = e.dict_find_pstr("foobar");
 		TEST_EQUAL(memcmp(ps.ptr, "barfoo", ps.len), 0);
@@ -503,7 +503,7 @@ TORRENT_TEST(lazy_entry)
 		error_code ec;
 		int ret = lazy_bdecode(b, b + sizeof(b)-1, e, ec, NULL);
 		TEST_EQUAL(ret, 0);
-		printf("%s\n", print_entry(e).c_str());
+		std::printf("%s\n", print_entry(e).c_str());
 
 		TEST_EQUAL(e.list_size(), 2);
 		pascal_string ps = e.list_pstr_at(0);
@@ -527,7 +527,7 @@ TORRENT_TEST(lazy_entry)
 		for (int i = 0; i < 1000; ++i)
 		{
 			char tmp[20];
-			snprintf(tmp, sizeof(tmp), "i%de", i);
+			std::snprintf(tmp, sizeof(tmp), "i%de", i);
 			buf += tmp;
 		}
 		buf += "e";
@@ -550,12 +550,12 @@ TORRENT_TEST(lazy_entry)
 		for (int i = 0; i < 1000; ++i)
 		{
 			char tmp[30];
-			snprintf(tmp, sizeof(tmp), "4:%04di%de", i, i);
+			std::snprintf(tmp, sizeof(tmp), "4:%04di%de", i, i);
 			buf += tmp;
 		}
 		buf += "e";
 
-		printf("%s\n", buf.c_str());
+		std::printf("%s\n", buf.c_str());
 		lazy_entry e;
 		error_code ec;
 		int ret = lazy_bdecode((char*)&buf[0], (char*)&buf[0] + buf.size(), e, ec);
@@ -565,7 +565,7 @@ TORRENT_TEST(lazy_entry)
 		for (int i = 0; i < 1000; ++i)
 		{
 			char tmp[30];
-			snprintf(tmp, sizeof(tmp), "%04d", i);
+			std::snprintf(tmp, sizeof(tmp), "%04d", i);
 			TEST_EQUAL(e.dict_find_int_value(tmp), i);
 		}
 	}
@@ -624,7 +624,7 @@ TORRENT_TEST(lazy_entry)
 			int ret = lazy_bdecode(b[i], b[i] + strlen(b[i]), e, ec, NULL);
 			TEST_EQUAL(ret, -1);
 			TEST_CHECK(ec == error_code(bdecode_errors::unexpected_eof));
-			printf("%s\n", print_entry(e).c_str());
+			std::printf("%s\n", print_entry(e).c_str());
 		}
 	}
 }

test/test_bitfield.cpp

@@ -43,7 +43,7 @@ void print_bitfield(bitfield const& b)
 	{
 		out += b.get_bit(i) ? "1" : "0";
 	}
-	printf("%s\n", out.c_str());
+	std::printf("%s\n", out.c_str());
 }
 
 void test_iterators(bitfield& test1)
@@ -51,14 +51,14 @@ void test_iterators(bitfield& test1)
 	test1.set_all();
 	int num = 0;
 
-	printf("expecting %d ones\n", test1.size());
+	std::printf("expecting %d ones\n", test1.size());
 	for (bitfield::const_iterator i = test1.begin(); i != test1.end(); ++i)
 	{
-		printf("%d", *i);
+		std::printf("%d", *i);
 		TEST_EQUAL(*i, true);
 		num += *i;
 	}
-	printf("\n");
+	std::printf("\n");
 	TEST_EQUAL(num, test1.size());
 	TEST_EQUAL(num, test1.count());
 }
@@ -82,7 +82,7 @@ TORRENT_TEST(bitfield)
 	test1.clear_bit(2);
 	TEST_EQUAL(test1.count(), 2);
 	int distance = int(std::distance(test1.begin(), test1.end()));
-	printf("distance: %d\n", distance);
+	std::printf("distance: %d\n", distance);
 	TEST_CHECK(distance == 10);
 
 	print_bitfield(test1);

test/test_checking.cpp

@@ -61,7 +61,7 @@ void test_checking(int flags = read_only_files)
 	using namespace libtorrent;
 	namespace lt = libtorrent;
 
-	fprintf(stderr, "\n==== TEST CHECKING %s%s%s=====\n\n"
+	std::fprintf(stderr, "\n==== TEST CHECKING %s%s%s=====\n\n"
 		, (flags & read_only_files) ? "read-only-files ":""
 		, (flags & corrupt_files) ? "corrupt ":""
 		, (flags & incomplete_files) ? "incomplete ":"");
@@ -70,9 +70,9 @@ void test_checking(int flags = read_only_files)
 	for (int i = 0; i < num_files; ++i)
 	{
 		char name[1024];
-		snprintf(name, sizeof(name), "test%d", i);
+		std::snprintf(name, sizeof(name), "test%d", i);
 		char dirname[200];
-		snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
+		std::snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
 		std::string path = combine_path(combine_path("tmp1_checking", "test_torrent_dir"), dirname);
 		path = combine_path(path, name);
 #ifdef TORRENT_WINDOWS
@@ -85,14 +85,14 @@ void test_checking(int flags = read_only_files)
 	// in case the previous run was terminated
 	error_code ec;
 	remove_all("tmp1_checking", ec);
-	if (ec) fprintf(stderr, "ERROR: removing tmp1_checking: (%d) %s\n"
+	if (ec) std::fprintf(stderr, "ERROR: removing tmp1_checking: (%d) %s\n"
 		, ec.value(), ec.message().c_str());
 
 	create_directory("tmp1_checking", ec);
-	if (ec) fprintf(stderr, "ERROR: creating directory tmp1_checking: (%d) %s\n"
+	if (ec) std::fprintf(stderr, "ERROR: creating directory tmp1_checking: (%d) %s\n"
 		, ec.value(), ec.message().c_str());
 	create_directory(combine_path("tmp1_checking", "test_torrent_dir"), ec);
-	if (ec) fprintf(stderr, "ERROR: creating directory test_torrent_dir: (%d) %s\n"
+	if (ec) std::fprintf(stderr, "ERROR: creating directory test_torrent_dir: (%d) %s\n"
 		, ec.value(), ec.message().c_str());
 
 	file_storage fs;
@@ -108,14 +108,14 @@ void test_checking(int flags = read_only_files)
 
 	// calculate the hash for all pieces
 	set_piece_hashes(t, "tmp1_checking", ec);
-	if (ec) fprintf(stderr, "ERROR: set_piece_hashes: (%d) %s\n"
+	if (ec) std::fprintf(stderr, "ERROR: set_piece_hashes: (%d) %s\n"
 		, ec.value(), ec.message().c_str());
 
 	std::vector<char> buf;
 	bencode(std::back_inserter(buf), t.generate());
 	boost::shared_ptr<torrent_info> ti(new torrent_info(&buf[0], int(buf.size()), ec));
 
-	fprintf(stderr, "generated torrent: %s tmp1_checking/test_torrent_dir\n"
+	std::fprintf(stderr, "generated torrent: %s tmp1_checking/test_torrent_dir\n"
 		, to_hex(ti->info_hash().to_string()).c_str());
 
 	// truncate every file in half
@@ -124,18 +124,18 @@ void test_checking(int flags = read_only_files)
 		for (int i = 0; i < num_files; ++i)
 		{
 			char name[1024];
-			snprintf(name, sizeof(name), "test%d", i);
+			std::snprintf(name, sizeof(name), "test%d", i);
 			char dirname[200];
-			snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
+			std::snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
 			std::string path = combine_path(combine_path("tmp1_checking", "test_torrent_dir"), dirname);
 			path = combine_path(path, name);
 
 			error_code ec;
 			file f(path, file::read_write, ec);
-			if (ec) fprintf(stderr, "ERROR: opening file \"%s\": (%d) %s\n"
+			if (ec) std::fprintf(stderr, "ERROR: opening file \"%s\": (%d) %s\n"
 				, path.c_str(), ec.value(), ec.message().c_str());
 			f.set_size(file_sizes[i] / 2, ec);
-			if (ec) fprintf(stderr, "ERROR: truncating file \"%s\": (%d) %s\n"
+			if (ec) std::fprintf(stderr, "ERROR: truncating file \"%s\": (%d) %s\n"
 				, path.c_str(), ec.value(), ec.message().c_str());
 		}
 	}
@@ -143,7 +143,7 @@ void test_checking(int flags = read_only_files)
 	// overwrite the files with new random data
 	if (flags & corrupt_files)
 	{
-		fprintf(stderr, "corrupt file test. overwriting files\n");
+		std::fprintf(stderr, "corrupt file test. overwriting files\n");
 		// increase the size of some files. When they're read only that forces
 		// the checker to open them in write-mode to truncate them
 		static const int file_sizes2[] =
@@ -155,17 +155,17 @@ void test_checking(int flags = read_only_files)
 	// make the files read only
 	if (flags & read_only_files)
 	{
-		fprintf(stderr, "making files read-only\n");
+		std::fprintf(stderr, "making files read-only\n");
 		for (int i = 0; i < num_files; ++i)
 		{
 			char name[1024];
-			snprintf(name, sizeof(name), "test%d", i);
+			std::snprintf(name, sizeof(name), "test%d", i);
 			char dirname[200];
-			snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
+			std::snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
 
 			std::string path = combine_path(combine_path("tmp1_checking", "test_torrent_dir"), dirname);
 			path = combine_path(path, name);
-			fprintf(stderr, "   %s\n", path.c_str());
+			std::fprintf(stderr, "   %s\n", path.c_str());
 
 #ifdef TORRENT_WINDOWS
 			SetFileAttributesA(path.c_str(), FILE_ATTRIBUTE_READONLY);
@@ -203,7 +203,7 @@ void test_checking(int flags = read_only_files)
 
 		st = tor1.status();
 
-		printf("%d %f %s\n", st.state, st.progress_ppm / 10000.f, st.errc.message().c_str());
+		std::printf("%d %f %s\n", st.state, st.progress_ppm / 10000.f, st.errc.message().c_str());
 
 		if (
 #ifndef TORRENT_NO_DEPRECATE
@@ -236,7 +236,7 @@ void test_checking(int flags = read_only_files)
 			// read-only here, we expect the checking to fail.
 			TEST_CHECK(st.errc);
 			if (st.errc)
-				fprintf(stderr, "error: %s\n", st.errc.message().c_str());
+				std::fprintf(stderr, "error: %s\n", st.errc.message().c_str());
 
 			// wait a while to make sure libtorrent survived the error
 			test_sleep(1000);
@@ -245,13 +245,13 @@ void test_checking(int flags = read_only_files)
 			TEST_CHECK(!st.is_seeding);
 			TEST_CHECK(st.errc);
 			if (st.errc)
-				fprintf(stderr, "error: %s\n", st.errc.message().c_str());
+				std::fprintf(stderr, "error: %s\n", st.errc.message().c_str());
 		}
 		else
 		{
 			TEST_CHECK(!st.errc);
 			if (st.errc)
-				fprintf(stderr, "error: %s\n", st.errc.message().c_str());
+				std::fprintf(stderr, "error: %s\n", st.errc.message().c_str());
 		}
 	}
 
@@ -259,7 +259,7 @@ void test_checking(int flags = read_only_files)
 	{
 		TEST_CHECK(st.is_seeding);
 		if (st.errc)
-			fprintf(stderr, "error: %s\n", st.errc.message().c_str());
+			std::fprintf(stderr, "error: %s\n", st.errc.message().c_str());
 	}
 
 	// make the files writable again
@@ -268,9 +268,9 @@ void test_checking(int flags = read_only_files)
 		for (int i = 0; i < num_files; ++i)
 		{
 			char name[1024];
-			snprintf(name, sizeof(name), "test%d", i);
+			std::snprintf(name, sizeof(name), "test%d", i);
 			char dirname[200];
-			snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
+			std::snprintf(dirname, sizeof(dirname), "test_dir%d", i / 5);
 
 			std::string path = combine_path(combine_path("tmp1_checking", "test_torrent_dir"), dirname);
 			path = combine_path(path, name);
@@ -283,7 +283,7 @@ void test_checking(int flags = read_only_files)
 	}
 
 	remove_all("tmp1_checking", ec);
-	if (ec) fprintf(stderr, "ERROR: removing tmp1_checking: (%d) %s\n"
+	if (ec) std::fprintf(stderr, "ERROR: removing tmp1_checking: (%d) %s\n"
 		, ec.value(), ec.message().c_str());
 }