Attachment #246400 for bug #336386

Lines 145-151 Link Here

(-)rtorrent-0.8.6.orig/rak/socket_address.h (-7 / +167 lines)
145	};	145	};
146	};	146	};
147		147
148	// Remeber to set the AF_INET.	148	// Remember to set the AF_INET.
149		149
150	class socket_address_inet {	150	class socket_address_inet {
151	public:	151	public:
Lines 184-189 Link Here
184		184
185	const sockaddr* c_sockaddr() const { return reinterpret_cast<const sockaddr*>(&m_sockaddr); }	185	const sockaddr* c_sockaddr() const { return reinterpret_cast<const sockaddr*>(&m_sockaddr); }
186	const sockaddr_in* c_sockaddr_inet() const { return &m_sockaddr; }	186	const sockaddr_in* c_sockaddr_inet() const { return &m_sockaddr; }
		187
		188	#ifdef RAK_USE_INET6
		189	socket_address_inet6 to_mapped_address() const;
		190	#endif
187		191
188	bool operator == (const socket_address_inet& rhs) const;	192	bool operator == (const socket_address_inet& rhs) const;
189	bool operator < (const socket_address_inet& rhs) const;	193	bool operator < (const socket_address_inet& rhs) const;
Lines 192-197 Link Here
192	struct sockaddr_in m_sockaddr;	196	struct sockaddr_in m_sockaddr;
193	};	197	};
194		198
		199	#ifdef RAK_USE_INET6
		200	// Remember to set the AF_INET6.
		201
		202	class socket_address_inet6 {
		203	public:
		204	bool is_any() const { return is_port_any() && is_address_any(); }
		205	bool is_valid() const { return !is_port_any() && !is_address_any(); }
		206	bool is_port_any() const { return port() == 0; }
		207	bool is_address_any() const { return std::memcmp(&m_sockaddr.sin6_addr, &in6addr_any, sizeof(in6_addr)) == 0; }
		208
		209	void clear() { std::memset(this, 0, sizeof(socket_address_inet6)); set_family(); }
		210
		211	uint16_t port() const { return ntohs(m_sockaddr.sin6_port); }
		212	uint16_t port_n() const { return m_sockaddr.sin6_port; }
		213	void set_port(uint16_t p) { m_sockaddr.sin6_port = htons(p); }
		214	void set_port_n(uint16_t p) { m_sockaddr.sin6_port = p; }
		215
		216	in6_addr address() const { return m_sockaddr.sin6_addr; }
		217	std::string address_str() const;
		218	bool address_c_str(char* buf, socklen_t size) const;
		219
		220	void set_address(in6_addr a) { m_sockaddr.sin6_addr = a; }
		221	bool set_address_str(const std::string& a) { return set_address_c_str(a.c_str()); }
		222	bool set_address_c_str(const char* a);
		223
		224	void set_address_any() { set_port(0); set_address(in6addr_any); }
		225
		226	sa_family_t family() const { return m_sockaddr.sin6_family; }
		227	void set_family() { m_sockaddr.sin6_family = AF_INET6; }
		228
		229	sockaddr* c_sockaddr() { return reinterpret_cast<sockaddr*>(&m_sockaddr); }
		230	sockaddr_in6* c_sockaddr_inet6() { return &m_sockaddr; }
		231
		232	const sockaddr* c_sockaddr() const { return reinterpret_cast<const sockaddr*>(&m_sockaddr); }
		233	const sockaddr_in6* c_sockaddr_inet6() const { return &m_sockaddr; }
		234
		235	socket_address normalize_address() const;
		236
		237	bool operator == (const socket_address_inet6& rhs) const;
		238	bool operator < (const socket_address_inet6& rhs) const;
		239
		240	private:
		241	struct sockaddr_in6 m_sockaddr;
		242	};
		243	#endif
		244
195	// Unique key for the address, excluding port numbers etc.	245	// Unique key for the address, excluding port numbers etc.
196	class socket_address_key {	246	class socket_address_key {
197	public:	247	public:
Lines 241-248 Link Here
241	switch (family()) {	291	switch (family()) {
242	case af_inet:	292	case af_inet:
243	return sa_inet()->is_valid();	293	return sa_inet()->is_valid();
244	// case af_inet6:	294	#ifdef RAK_USE_INET6
245	// return sa_inet6().is_valid();	295	case af_inet6:
		296	return sa_inet6()->is_valid();
		297	#endif
246	default:	298	default:
247	return false;	299	return false;
248	}	300	}
Lines 253-258 Link Here
253	switch (family()) {	305	switch (family()) {
254	case af_inet:	306	case af_inet:
255	return !sa_inet()->is_address_any();	307	return !sa_inet()->is_address_any();
		308	#ifdef RAK_USE_INET6
		309	case af_inet6:
		310	return !sa_inet6()->is_address_any();
		311	#endif
256	default:	312	default:
257	return false;	313	return false;
258	}	314	}
Lines 263-268 Link Here
263	switch (family()) {	319	switch (family()) {
264	case af_inet:	320	case af_inet:
265	return sa_inet()->is_address_any();	321	return sa_inet()->is_address_any();
		322	#ifdef RAK_USE_INET6
		323	case af_inet6:
		324	return sa_inet6()->is_address_any();
		325	#endif
266	default:	326	default:
267	return true;	327	return true;
268	}	328	}
Lines 273-278 Link Here
273	switch (family()) {	333	switch (family()) {
274	case af_inet:	334	case af_inet:
275	return sa_inet()->port();	335	return sa_inet()->port();
		336	#ifdef RAK_USE_INET6
		337	case af_inet6:
		338	return sa_inet6()->port();
		339	#endif
276	default:	340	default:
277	return 0;	341	return 0;
278	}	342	}
Lines 283-288 Link Here
283	switch (family()) {	347	switch (family()) {
284	case af_inet:	348	case af_inet:
285	return sa_inet()->set_port(p);	349	return sa_inet()->set_port(p);
		350	#ifdef RAK_USE_INET6
		351	case af_inet6:
		352	return sa_inet6()->set_port(p);
		353	#endif
286	default:	354	default:
287	break;	355	break;
288	}	356	}
Lines 293-298 Link Here
293	switch (family()) {	361	switch (family()) {
294	case af_inet:	362	case af_inet:
295	return sa_inet()->address_str();	363	return sa_inet()->address_str();
		364	#ifdef RAK_USE_INET6
		365	case af_inet6:
		366	return sa_inet6()->address_str();
		367	#endif
296	default:	368	default:
297	return std::string();	369	return std::string();
298	}	370	}
Lines 303-308 Link Here
303	switch (family()) {	375	switch (family()) {
304	case af_inet:	376	case af_inet:
305	return sa_inet()->address_c_str(buf, size);	377	return sa_inet()->address_c_str(buf, size);
		378	#ifdef RAK_USE_INET6
		379	case af_inet6:
		380	return sa_inet6()->address_c_str(buf, size);
		381	#endif
306	default:	382	default:
307	return false;	383	return false;
308	}	384	}
Lines 314-319 Link Here
314	sa_inet()->set_family();	390	sa_inet()->set_family();
315	return true;	391	return true;
316		392
		393	#ifdef RAK_USE_INET6
		394	} else if (sa_inet6()->set_address_c_str(a)) {
		395	sa_inet6()->set_family();
		396	return true;
		397	#endif
		398
317	} else {	399	} else {
318	return false;	400	return false;
319	}	401	}
Lines 325-330 Link Here
325	switch(family()) {	407	switch(family()) {
326	case af_inet:	408	case af_inet:
327	return sizeof(sockaddr_in);	409	return sizeof(sockaddr_in);
		410	#ifdef RAK_USE_INET6
		411	case af_inet6:
		412	return sizeof(sockaddr_in6);
		413	#endif
328	default:	414	default:
329	return 0;	415	return 0;
330	}	416	}
Lines 349-356 Link Here
349	switch (family()) {	435	switch (family()) {
350	case af_inet:	436	case af_inet:
351	return sa_inet() == rhs.sa_inet();	437	return sa_inet() == rhs.sa_inet();
352	// case af_inet6:	438	#ifdef RAK_USE_INET6
353	// return sa_inet6() == rhs.sa_inet6();	439	case af_inet6:
		440	return sa_inet6() == rhs.sa_inet6();
		441	#endif
354	default:	442	default:
355	throw std::logic_error("socket_address::operator == (rhs) invalid type comparison.");	443	throw std::logic_error("socket_address::operator == (rhs) invalid type comparison.");
356	}	444	}
Lines 364-371 Link Here
364	switch (family()) {	452	switch (family()) {
365	case af_inet:	453	case af_inet:
366	return sa_inet() < rhs.sa_inet();	454	return sa_inet() < rhs.sa_inet();
367	// case af_inet6:	455	#ifdef RAK_USE_INET6
368	// return sa_inet6() < rhs.sa_inet6();	456	case af_inet6:
		457	return sa_inet6() < rhs.sa_inet6();
		458	#endif
369	default:	459	default:
370	throw std::logic_error("socket_address::operator < (rhs) invalid type comparison.");	460	throw std::logic_error("socket_address::operator < (rhs) invalid type comparison.");
371	}	461	}
Lines 391-396 Link Here
391	return inet_pton(AF_INET, a, &m_sockaddr.sin_addr);	481	return inet_pton(AF_INET, a, &m_sockaddr.sin_addr);
392	}	482	}
393		483
		484	#ifdef RAK_USE_INET6
		485	inline socket_address_inet6
		486	socket_address_inet::to_mapped_address() const {
		487	uint32_t addr32[4];
		488	addr32[0] = 0;
		489	addr32[1] = 0;
		490	addr32[2] = htonl(0xffff);
		491	addr32[3] = m_sockaddr.sin_addr.s_addr;
		492
		493	socket_address_inet6 sa;
		494	sa.clear();
		495	sa.set_address(reinterpret_cast<in6_addr >(addr32));
		496	sa.set_port_n(m_sockaddr.sin_port);
		497	return sa;
		498	}
		499	#endif
		500
394	inline bool	501	inline bool
395	socket_address_inet::operator == (const socket_address_inet& rhs) const {	502	socket_address_inet::operator == (const socket_address_inet& rhs) const {
396	return	503	return
Lines 406-411 Link Here
406	m_sockaddr.sin_port < rhs.m_sockaddr.sin_port);	513	m_sockaddr.sin_port < rhs.m_sockaddr.sin_port);
407	}	514	}
408		515
		516	#ifdef RAK_USE_INET6
		517
		518	inline std::string
		519	socket_address_inet6::address_str() const {
		520	char buf[INET6_ADDRSTRLEN];
		521
		522	if (!address_c_str(buf, INET6_ADDRSTRLEN))
		523	return std::string();
		524
		525	return std::string(buf);
		526	}
		527
		528	inline bool
		529	socket_address_inet6::address_c_str(char* buf, socklen_t size) const {
		530	return inet_ntop(family(), &m_sockaddr.sin6_addr, buf, size);
		531	}
		532
		533	inline bool
		534	socket_address_inet6::set_address_c_str(const char* a) {
		535	return inet_pton(AF_INET6, a, &m_sockaddr.sin6_addr);
		536	}
		537
		538	inline socket_address
		539	socket_address_inet6::normalize_address() const {
		540	const uint32_t addr32 = reinterpret_cast<const uint32_t >(m_sockaddr.sin6_addr.s6_addr);
		541	if (addr32[0] == 0 && addr32[1] == 0 && addr32[2] == htonl(0xffff)) {
		542	socket_address addr4;
		543	addr4.sa_inet()->set_family();
		544	addr4.sa_inet()->set_address_n(addr32[3]);
		545	addr4.sa_inet()->set_port_n(m_sockaddr.sin6_port);
		546	return addr4;
		547	}
		548	return reinterpret_cast<const socket_address>(this);
		549	}
		550
		551	inline bool
		552	socket_address_inet6::operator == (const socket_address_inet6& rhs) const {
		553	return
		554	memcmp(&m_sockaddr.sin6_addr, &rhs.m_sockaddr.sin6_addr, sizeof(in6_addr)) == 0 &&
		555	m_sockaddr.sin6_port == rhs.m_sockaddr.sin6_port;
		556	}
		557
		558	inline bool
		559	socket_address_inet6::operator < (const socket_address_inet6& rhs) const {
		560	int addr_comp = memcmp(&m_sockaddr.sin6_addr, &rhs.m_sockaddr.sin6_addr, sizeof(in6_addr));
		561	return
		562	addr_comp < 0 \|\|
		563	(addr_comp == 0 \|\|
		564	m_sockaddr.sin6_port < rhs.m_sockaddr.sin6_port);
		565	}
		566
		567	#endif
		568
409	}	569	}
410		570
411	#endif	571	#endif

Lines 68-74 Link Here

(-)rtorrent-0.8.6.orig/src/command_peer.cc (-1 / +7 lines)
68		68
69	torrent::Object	69	torrent::Object
70	retrieve_p_address(torrent::Peer* peer) {	70	retrieve_p_address(torrent::Peer* peer) {
71	return rak::socket_address::cast_from(peer->peer_info()->socket_address())->address_str();	71	const rak::socket_address *addr = rak::socket_address::cast_from(peer->peer_info()->socket_address());
		72	#ifdef RAK_USE_INET6
		73	if (addr->family() == rak::socket_address::af_inet6)
		74	return "[" + addr->address_str() + "]";
		75	else
		76	#endif
		77	return addr->address_str();
72	}	78	}
73		79
74	torrent::Object	80	torrent::Object

Lines 88-95 Link Here

(-)rtorrent-0.8.6.orig/src/core/curl_get.cc (+23 lines)
88	curl_easy_setopt(m_handle, CURLOPT_NOSIGNAL, (long)1);	88	curl_easy_setopt(m_handle, CURLOPT_NOSIGNAL, (long)1);
89	curl_easy_setopt(m_handle, CURLOPT_FOLLOWLOCATION, (long)1);	89	curl_easy_setopt(m_handle, CURLOPT_FOLLOWLOCATION, (long)1);
90	curl_easy_setopt(m_handle, CURLOPT_MAXREDIRS, (long)5);	90	curl_easy_setopt(m_handle, CURLOPT_MAXREDIRS, (long)5);
		91
		92	// Even when IPv6-enabled, we don't want to use CURL_IPRESOLVE_WHATEVER,
		93	// since that will usually prefer connecting over IPv6 to the tracker.
		94	// Since it's usually a lot easier to find our global IPv6 address
		95	// (if we have one) than our global IPv4 address, we prefer connecting
		96	// over IPv4 if we can, so that the tracker will get our IPv4 address
		97	// that way. If the resolve fails, CurlStack will call retry_ipv6()
		98	// on us and we'll make a second attempt with CURL_IPRESOLVE_V6.
91	curl_easy_setopt(m_handle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);	99	curl_easy_setopt(m_handle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
		100
92	curl_easy_setopt(m_handle, CURLOPT_ENCODING, "");	101	curl_easy_setopt(m_handle, CURLOPT_ENCODING, "");
		102	#ifdef RAK_USE_INET6
		103	m_ipv6 = false;
		104	#endif
93		105
94	m_stack->add_get(this);	106	m_stack->add_get(this);
95	}	107	}
Lines 107-112 Link Here
107	m_handle = NULL;	119	m_handle = NULL;
108	}	120	}
109		121
		122	#ifdef RAK_USE_INET6
		123	void
		124	CurlGet::retry_ipv6() {
		125	CURL* nhandle = curl_easy_duphandle(m_handle);
		126	curl_easy_setopt(nhandle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
		127	curl_easy_cleanup(m_handle);
		128	m_handle = nhandle;
		129	m_ipv6 = true;
		130	}
		131	#endif
		132
110	void	133	void
111	CurlGet::receive_timeout() {	134	CurlGet::receive_timeout() {
112	return m_stack->transfer_done(m_handle, "Timed out");	135	return m_stack->transfer_done(m_handle, "Timed out");

Lines 56-61 Link Here

(-)rtorrent-0.8.6.orig/src/core/curl_get.h (+7 lines)
56		56
57	void start();	57	void start();
58	void close();	58	void close();
		59	#ifdef RAK_USE_INET6
		60	bool is_using_ipv6() { return m_ipv6; }
		61	void retry_ipv6();
		62	#endif
59		63
60	bool is_busy() const { return m_handle; }	64	bool is_busy() const { return m_handle; }
61	bool is_active() const { return m_active; }	65	bool is_active() const { return m_active; }
Lines 74-79 Link Here
74	void receive_timeout();	78	void receive_timeout();
75		79
76	bool m_active;	80	bool m_active;
		81	#ifdef RAK_USE_INET6
		82	bool m_ipv6;
		83	#endif
77		84
78	rak::priority_item m_taskTimeout;	85	rak::priority_item m_taskTimeout;
79		86




        if (msg->msg != CURLMSG_DONE)
          throw torrent::internal_error("CurlStack::receive_action() msg->msg != CURLMSG_DONE.");

#ifdef RAK_USE_INET6
        if (msg->data.result == CURLE_COULDNT_RESOLVE_HOST) {
          iterator itr = std::find_if(begin(), end(), rak::equal(msg->easy_handle, std::mem_fun(&CurlGet::handle)));

          if (itr == end())
            throw torrent::internal_error("Could not find CurlGet when calling CurlStack::receive_action.");

          if (!(*itr)->is_using_ipv6()) {
            (*itr)->retry_ipv6();
            if (curl_multi_add_handle((CURLM*)m_handle, (*itr)->handle()) > 0)
              throw torrent::internal_error("Error calling curl_multi_add_handle.");
            continue;
          }
        } else
#endif
	transfer_done(msg->easy_handle, msg->data.result == CURLE_OK ? NULL : curl_easy_strerror(msg->data.result));
      }


Lines 68-74 Link Here

(-)rtorrent-0.8.6.orig/src/display/window_peer_list.cc (-2 / +17 lines)
68	int x = 2;	68	int x = 2;
69	int y = 0;	69	int y = 0;
70		70
71	m_canvas->print(x, y, "IP"); x += 16;	71	#ifdef RAK_USE_INET6
		72	m_canvas->print(x, y, "IP"); x += 25;
		73	#else
		74	m_canvas->print(x, y, "IP"); x += 16;
		75	#endif
72	m_canvas->print(x, y, "UP"); x += 7;	76	m_canvas->print(x, y, "UP"); x += 7;
73	m_canvas->print(x, y, "DOWN"); x += 7;	77	m_canvas->print(x, y, "DOWN"); x += 7;
74	m_canvas->print(x, y, "PEER"); x += 7;	78	m_canvas->print(x, y, "PEER"); x += 7;
Lines 99-108 Link Here
99		103
100	x = 0;	104	x = 0;
101		105
		106	std::string ip_address = rak::socket_address::cast_from(p->address())->address_str();
		107	#ifdef RAK_USE_INET6
		108	if (ip_address.size() >= 24) {
		109	ip_address.replace(ip_address.begin() + 21, ip_address.end(), "...");
		110	}
		111	#endif
		112
102	m_canvas->print(x, y, "%c %s",	113	m_canvas->print(x, y, "%c %s",
103	range.first == m_focus ? '' : ' ',	114	range.first == m_focus ? '' : ' ',
104	rak::socket_address::cast_from(p->address())->address_str().c_str());	115	ip_address.c_str());
		116	#ifdef RAK_USE_INET6
		117	x += 27;
		118	#else
105	x += 18;	119	x += 18;
		120	#endif
106		121
107	m_canvas->print(x, y, "%.1f", (double)p->up_rate()->rate() / 1024); x += 7;	122	m_canvas->print(x, y, "%.1f", (double)p->up_rate()->rate() / 1024); x += 7;
108	m_canvas->print(x, y, "%.1f", (double)p->down_rate()->rate() / 1024); x += 7;	123	m_canvas->print(x, y, "%.1f", (double)p->down_rate()->rate() / 1024); x += 7;

Lines 71-76 Link Here

(-)rtorrent-0.8.6.orig/src/utils/socket_fd.cc (+76 lines)
71	check_valid();	71	check_valid();
72	int opt = p;	72	int opt = p;
73		73
		74	#ifdef RAK_USE_INET6
		75	if (m_ipv6_socket)
		76	return setsockopt(m_fd, IPPROTO_IPV6, IPV6_TCLASS, &opt, sizeof(opt)) == 0;
		77	else
		78	#endif
74	return setsockopt(m_fd, IPPROTO_IP, IP_TOS, &opt, sizeof(opt)) == 0;	79	return setsockopt(m_fd, IPPROTO_IP, IP_TOS, &opt, sizeof(opt)) == 0;
75	}	80	}
76		81
Lines 130-141 Link Here
130		135
131	bool	136	bool
132	SocketFd::open_stream() {	137	SocketFd::open_stream() {
		138	#ifdef RAK_USE_INET6
		139	m_fd = socket(rak::socket_address::pf_inet6, SOCK_STREAM, IPPROTO_TCP);
		140	if (m_fd == -1) {
		141	m_ipv6_socket = false;
		142	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_STREAM, IPPROTO_TCP)) != -1;
		143	}
		144	m_ipv6_socket = true;
		145
		146	int zero = 0;
		147	return setsockopt(m_fd, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero)) != -1;
		148	#else
133	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_STREAM, IPPROTO_TCP)) != -1;	149	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_STREAM, IPPROTO_TCP)) != -1;
		150	#endif
134	}	151	}
135		152
136	bool	153	bool
137	SocketFd::open_datagram() {	154	SocketFd::open_datagram() {
		155	#ifdef RAK_USE_INET6
		156	m_fd = socket(rak::socket_address::pf_inet6, SOCK_DGRAM, 0);
		157	if (m_fd == -1) {
		158	m_ipv6_socket = false;
		159	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_DGRAM, 0)) != -1;
		160	}
		161	m_ipv6_socket = true;
		162
		163	int zero = 0;
		164	return setsockopt(m_fd, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero)) != -1;
		165	#else
138	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_DGRAM, 0)) != -1;	166	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_DGRAM, 0)) != -1;
		167	#endif
139	}	168	}
140		169
141	bool	170	bool
Lines 153-158 Link Here
153	SocketFd::bind(const rak::socket_address& sa) {	182	SocketFd::bind(const rak::socket_address& sa) {
154	check_valid();	183	check_valid();
155		184
		185	#ifdef RAK_USE_INET6
		186	if (m_ipv6_socket && sa.family() == rak::socket_address::pf_inet) {
		187	rak::socket_address_inet6 sa_mapped = sa.sa_inet()->to_mapped_address();
		188	return !::bind(m_fd, sa_mapped.c_sockaddr(), sizeof(sa_mapped));
		189	}
		190	#endif
156	return !::bind(m_fd, sa.c_sockaddr(), sa.length());	191	return !::bind(m_fd, sa.c_sockaddr(), sa.length());
157	}	192	}
158		193
Lines 160-165 Link Here
160	SocketFd::bind(const rak::socket_address& sa, unsigned int length) {	195	SocketFd::bind(const rak::socket_address& sa, unsigned int length) {
161	check_valid();	196	check_valid();
162		197
		198	#ifdef RAK_USE_INET6
		199	if (m_ipv6_socket && sa.family() == rak::socket_address::pf_inet) {
		200	rak::socket_address_inet6 sa_mapped = sa.sa_inet()->to_mapped_address();
		201	return !::bind(m_fd, sa_mapped.c_sockaddr(), sizeof(sa_mapped));
		202	}
		203	#endif
163	return !::bind(m_fd, sa.c_sockaddr(), length);	204	return !::bind(m_fd, sa.c_sockaddr(), length);
164	}	205	}
165		206
Lines 167-176 Link Here
167	SocketFd::connect(const rak::socket_address& sa) {	208	SocketFd::connect(const rak::socket_address& sa) {
168	check_valid();	209	check_valid();
169		210
		211	#ifdef RAK_USE_INET6
		212	if (m_ipv6_socket && sa.family() == rak::socket_address::pf_inet) {
		213	rak::socket_address_inet6 sa_mapped = sa.sa_inet()->to_mapped_address();
		214	return !::connect(m_fd, sa_mapped.c_sockaddr(), sizeof(sa_mapped)) \|\| errno == EINPROGRESS;
		215	}
		216	#endif
170	return !::connect(m_fd, sa.c_sockaddr(), sa.length()) \|\| errno == EINPROGRESS;	217	return !::connect(m_fd, sa.c_sockaddr(), sa.length()) \|\| errno == EINPROGRESS;
171	}	218	}
172		219
173	bool	220	bool
		221	SocketFd::getsockname(rak::socket_address *sa) {
		222	check_valid();
		223
		224	socklen_t len = sizeof(rak::socket_address);
		225	if (::getsockname(m_fd, sa->c_sockaddr(), &len)) {
		226	return false;
		227	}
		228
		229	#ifdef RAK_USE_INET6
		230	if (m_ipv6_socket && sa->family() == rak::socket_address::af_inet6) {
		231	*sa = sa->sa_inet6()->normalize_address();
		232	}
		233	#endif
		234
		235	return true;
		236	}
		237
		238	bool
174	SocketFd::listen(int size) {	239	SocketFd::listen(int size) {
175	check_valid();	240	check_valid();
176		241
Lines 182-188 Link Here
182	check_valid();	247	check_valid();
183	socklen_t len = sizeof(rak::socket_address);	248	socklen_t len = sizeof(rak::socket_address);
184		249
		250	#ifdef RAK_USE_INET6
		251	if (sa == NULL) {
		252	return SocketFd(::accept(m_fd, NULL, &len));
		253	}
		254	int fd = ::accept(m_fd, sa->c_sockaddr(), &len);
		255	if (fd != -1 && m_ipv6_socket && sa->family() == rak::socket_address::af_inet6) {
		256	*sa = sa->sa_inet6()->normalize_address();
		257	}
		258	return SocketFd(fd);
		259	#else
185	return SocketFd(::accept(m_fd, sa != NULL ? sa->c_sockaddr() : NULL, &len));	260	return SocketFd(::accept(m_fd, sa != NULL ? sa->c_sockaddr() : NULL, &len));
		261	#endif
186	}	262	}
187		263
188	// unsigned int	264	// unsigned int

Lines 80-85 Link Here

(-)rtorrent-0.8.6.orig/src/utils/socket_fd.h (+4 lines)
80	bool bind(const rak::socket_address& sa);	80	bool bind(const rak::socket_address& sa);
81	bool bind(const rak::socket_address& sa, unsigned int length);	81	bool bind(const rak::socket_address& sa, unsigned int length);
82	bool connect(const rak::socket_address& sa);	82	bool connect(const rak::socket_address& sa);
		83	bool getsockname(rak::socket_address* sa);
83		84
84	bool listen(int size);	85	bool listen(int size);
85	SocketFd accept(rak::socket_address* sa);	86	SocketFd accept(rak::socket_address* sa);
Lines 91-96 Link Here
91	inline void check_valid() const;	92	inline void check_valid() const;
92		93
93	int m_fd;	94	int m_fd;
		95	#ifdef RAK_USE_INET6
		96	bool m_ipv6_socket;
		97	#endif
94	};	98	};
95		99
96	}	100	}

Return to bug 336386

Lines 111-116 Link Here

(-)rtorrent-0.8.6.orig/src/core/curl_stack.cc (+15 lines)
111	if (msg->msg != CURLMSG_DONE)	111	if (msg->msg != CURLMSG_DONE)
112	throw torrent::internal_error("CurlStack::receive_action() msg->msg != CURLMSG_DONE.");	112	throw torrent::internal_error("CurlStack::receive_action() msg->msg != CURLMSG_DONE.");
113		113
		114	#ifdef RAK_USE_INET6
		115	if (msg->data.result == CURLE_COULDNT_RESOLVE_HOST) {
		116	iterator itr = std::find_if(begin(), end(), rak::equal(msg->easy_handle, std::mem_fun(&CurlGet::handle)));
		117
		118	if (itr == end())
		119	throw torrent::internal_error("Could not find CurlGet when calling CurlStack::receive_action.");
		120
		121	if (!(*itr)->is_using_ipv6()) {
		122	(*itr)->retry_ipv6();
		123	if (curl_multi_add_handle((CURLM)m_handle, (itr)->handle()) > 0)
		124	throw torrent::internal_error("Error calling curl_multi_add_handle.");
		125	continue;
		126	}
		127	} else
		128	#endif
114	transfer_done(msg->easy_handle, msg->data.result == CURLE_OK ? NULL : curl_easy_strerror(msg->data.result));	129	transfer_done(msg->easy_handle, msg->data.result == CURLE_OK ? NULL : curl_easy_strerror(msg->data.result));
115	}	130	}
116		131