Attachment #246404 for bug #336386

Lines 145-151 Link Here

(-)libtorrent-0.12.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 55-62 Link Here

(-)libtorrent-0.12.6.orig/src/dht/dht_node.cc (-2 / +21 lines)
55	m_recentlyInactive(0),	55	m_recentlyInactive(0),
56	m_bucket(NULL) {	56	m_bucket(NULL) {
57		57
		58	#ifdef RAK_USE_INET6
		59	if (sa->family() != rak::socket_address::af_inet &&
		60	(sa->family() != rak::socket_address::af_inet6 \|\|
		61	!sa->sa_inet6()->is_any()))
		62	throw resource_error("Address not af_inet or in6addr_any");
		63	#else
58	if (sa->family() != rak::socket_address::af_inet)	64	if (sa->family() != rak::socket_address::af_inet)
59	throw resource_error("Address not af_inet");	65	throw resource_error("Address not af_inet");
		66	#endif
60	}	67	}
61		68
62	DhtNode::DhtNode(const std::string& id, const Object& cache) :	69	DhtNode::DhtNode(const std::string& id, const Object& cache) :
Lines 85-92 Link Here
85		92
86	Object*	93	Object*
87	DhtNode::store_cache(Object* container) const {	94	DhtNode::store_cache(Object* container) const {
88	container->insert_key("i", m_socketAddress.sa_inet()->address_h());	95	#ifdef RAK_USE_INET6
89	container->insert_key("p", m_socketAddress.sa_inet()->port());	96	if (m_socketAddress.family() == rak::socket_address::af_inet6) {
		97	// Currently, all we support is in6addr_any (checked in the constructor),
		98	// which is effectively equivalent to this. Note that we need to specify
		99	// int64_t explicitly here because a zero constant is special in C++ and
		100	// thus we need an explicit match.
		101	container->insert_key("i", int64_t(0));
		102	container->insert_key("p", m_socketAddress.sa_inet6()->port());
		103	} else
		104	#endif
		105	{
		106	container->insert_key("i", m_socketAddress.sa_inet()->address_h());
		107	container->insert_key("p", m_socketAddress.sa_inet()->port());
		108	}
90	container->insert_key("t", m_lastSeen);	109	container->insert_key("t", m_lastSeen);
91	return container;	110	return container;
92	}	111	}




      if (read < 0)
        break;

#ifdef RAK_USE_INET6
      // We can currently only process mapped-IPv4 addresses, not real IPv6.
      // Translate them to an af_inet socket_address.
      if (sa.family() == rak::socket_address::af_inet6)
        sa = sa.sa_inet6()->normalize_address();
#endif

      if (sa.family() != rak::socket_address::af_inet)
        continue;

      total += read;
      sstream.str(std::string(buffer, read));





  const char*         c_str() const { return reinterpret_cast<const char*>(this); }
} __attribute__ ((packed));

#ifdef RAK_USE_INET6
struct SocketAddressCompact6 {
  SocketAddressCompact6() {}
  SocketAddressCompact6(in6_addr a, uint16_t p) : addr(a), port(p) {}
  SocketAddressCompact6(const rak::socket_address_inet6* sa) : addr(sa->address()), port(sa->port_n()) {}

  operator rak::socket_address () const {
    rak::socket_address sa;
    sa.sa_inet6()->clear();
    sa.sa_inet6()->set_port_n(port);
    sa.sa_inet6()->set_address(addr);

    return sa;
  }

  in6_addr addr;
  uint16_t port;

  const char*         c_str() const { return reinterpret_cast<const char*>(this); }
} __attribute__ ((packed));
#endif

}

#endif




	    std::back_inserter(*this));
}

#ifdef RAK_USE_INET6
void
AddressList::parse_address_compact_ipv6(const std::string& s) {
  if (sizeof(const SocketAddressCompact6) != 18)
    throw internal_error("ConnectionList::AddressList::parse_address_compact_ipv6(...) bad struct size.");

  std::copy(reinterpret_cast<const SocketAddressCompact6*>(s.c_str()),
            reinterpret_cast<const SocketAddressCompact6*>(s.c_str() + s.size() - s.size() % sizeof(SocketAddressCompact6)),
            std::back_inserter(*this));
}
#endif

}

Lines 50-55 Link Here

(-)libtorrent-0.12.6.orig/src/net/address_list.h (+3 lines)
50	// Parse normal or compact list of addresses and add to AddressList	50	// Parse normal or compact list of addresses and add to AddressList
51	void parse_address_normal(const Object::list_type& b);	51	void parse_address_normal(const Object::list_type& b);
52	void parse_address_compact(const std::string& s);	52	void parse_address_compact(const std::string& s);
		53	#ifdef RAK_USE_INET6
		54	void parse_address_compact_ipv6(const std::string& s);
		55	#endif
53		56
54	private:	57	private:
55	static rak::socket_address parse_address(const Object& b);	58	static rak::socket_address parse_address(const Object& b);




// libTorrent - BitTorrent library
// Copyright (C) 2005-2007, Jari Sundell
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// In addition, as a special exception, the copyright holders give
// permission to link the code of portions of this program with the
// OpenSSL library under certain conditions as described in each
// individual source file, and distribute linked combinations
// including the two.
//
// You must obey the GNU General Public License in all respects for
// all of the code used other than OpenSSL.  If you modify file(s)
// with this exception, you may extend this exception to your version
// of the file(s), but you are not obligated to do so.  If you do not
// wish to do so, delete this exception statement from your version.
// If you delete this exception statement from all source files in the
// program, then also delete it here.
//
// Contact:  Jari Sundell <jaris@ifi.uio.no>
//
//           Skomakerveien 33
//           3185 Skoppum, NORWAY

#include "config.h"

#include <stdio.h>
#include <ifaddrs.h>
#include <rak/socket_address.h>
#include <sys/types.h>
#include <errno.h>

#ifdef __linux__
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#endif

#include "torrent/exceptions.h"
#include "socket_fd.h"
#include "local_addr.h"

namespace torrent {
namespace {

// IPv4 priority, from highest to lowest:
//
//   1. Everything else (global address)
//   2. Private address space (10.0.0.0/8, 172.16.0.0/16, 192.168.0.0/24)
//   3. Empty/INADDR_ANY (0.0.0.0)
//   4. Link-local address (169.254.0.0/16)
//   5. Localhost (127.0.0.0/8)
int get_priority_ipv4(const in_addr& addr) {
  if ((addr.s_addr & htonl(0xff000000U)) == htonl(0x7f000000U)) {
    return 5;
  }
  if (addr.s_addr == htonl(0)) {
    return 4;
  }
  if ((addr.s_addr & htonl(0xffff0000U)) == htonl(0xa9fe0000U)) {
    return 3;
  }
  if ((addr.s_addr & htonl(0xff000000U)) == htonl(0x0a000000U) ||
      (addr.s_addr & htonl(0xffff0000U)) == htonl(0xac100000U) ||
      (addr.s_addr & htonl(0xffff0000U)) == htonl(0xc0a80000U)) {
    return 2;
  }
  return 1;
}

#ifdef RAK_USE_INET6
// IPv6 priority, from highest to lowest:
//
//  1. Global address (2000::/16 not in 6to4 or Teredo)
//  2. 6to4 (2002::/16)
//  3. Teredo (2001::/32)
//  4. Empty/INADDR_ANY (::)
//  5. Everything else (link-local, ULA, etc.)
int get_priority_ipv6(const in6_addr& addr) {
  const uint32_t *addr32 = reinterpret_cast<const uint32_t *>(addr.s6_addr);
  if (addr32[0] == htonl(0) &&
      addr32[1] == htonl(0) &&
      addr32[2] == htonl(0) &&
      addr32[3] == htonl(0)) {
    return 4;
  }
  if (addr32[0] == htonl(0x20010000)) {
    return 3;
  }
  if ((addr32[0] & htonl(0xffff0000)) == htonl(0x20020000)) {
    return 2;
  }
  if ((addr32[0] & htonl(0xe0000000)) == htonl(0x20000000)) {
    return 1;
  }
  return 5;
}
#endif

int get_priority(const rak::socket_address& addr) {
  switch (addr.family()) {
  case AF_INET:
    return get_priority_ipv4(addr.c_sockaddr_inet()->sin_addr);
#ifdef RAK_USE_INET6
  case AF_INET6:
    return get_priority_ipv6(addr.c_sockaddr_inet6()->sin6_addr);
#endif
  default:
    throw torrent::internal_error("Unknown address family given to compare");
  }
}

}

#ifdef __linux__

// Linux-specific implementation that understands how to filter away
// understands how to filter away secondary addresses.
bool get_local_address(sa_family_t family, rak::socket_address *address) {
  ifaddrs *ifaddrs;
  if (getifaddrs(&ifaddrs)) {
    return false;
  }

  rak::socket_address best_addr;
  switch (family) {
  case AF_INET:
    best_addr.sa_inet()->clear();
    break;
#ifdef RAK_USE_INET6
  case AF_INET6:
    best_addr.sa_inet6()->clear();
    break;
#endif
  default:
    throw torrent::internal_error("Unknown address family given to get_local_address");
  }

  // The bottom bit of the priority is used to hold if the address is 
  // a secondary address (e.g. with IPv6 privacy extensions) or not;
  // secondary addresses have lower priority (higher number).
  int best_addr_pri = get_priority(best_addr) * 2;

  // Get all the addresses via Linux' netlink interface.
  int fd = ::socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  if (fd == -1) {
    return false;
  }

  struct sockaddr_nl nladdr;
  memset(&nladdr, 0, sizeof(nladdr));
  nladdr.nl_family = AF_NETLINK;
  if (::bind(fd, (sockaddr *)&nladdr, sizeof(nladdr))) {
    ::close(fd);
    return false;
  }

  const int seq_no = 1;
  struct {
    nlmsghdr nh;
    rtgenmsg g;
  } req;
  memset(&req, 0, sizeof(req));

  req.nh.nlmsg_len = sizeof(req);
  req.nh.nlmsg_type = RTM_GETADDR;
  req.nh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
  req.nh.nlmsg_pid = getpid();
  req.nh.nlmsg_seq = seq_no;
  req.g.rtgen_family = AF_UNSPEC;

  int ret;
  do {
    ret = ::sendto(fd, &req, sizeof(req), 0, (sockaddr *)&nladdr, sizeof(nladdr));
  } while (ret == -1 && errno == EINTR);

  if (ret == -1) {
    ::close(fd);
    return false;
  }

  bool done = false;
  do {
    char buf[4096];
    socklen_t len = sizeof(nladdr);
    do {
      ret = ::recvfrom(fd, buf, sizeof(buf), 0, (sockaddr *)&nladdr, &len);
    } while (ret == -1 && errno == EINTR);

    if (ret < 0) {
      ::close(fd);
      return false;
    }

    for (const nlmsghdr *nlmsg = (const nlmsghdr *)buf;
         NLMSG_OK(nlmsg, ret);
         nlmsg = NLMSG_NEXT(nlmsg, ret)) {
      if (nlmsg->nlmsg_seq != seq_no)
        continue;
      if (nlmsg->nlmsg_type == NLMSG_DONE) {
        done = true;
        break;
      }
      if (nlmsg->nlmsg_type == NLMSG_ERROR) {
        ::close(fd);
        return false;
      }
      if (nlmsg->nlmsg_type != RTM_NEWADDR)
        continue;

      const ifaddrmsg *ifa = (const ifaddrmsg *)NLMSG_DATA(nlmsg);

      if (ifa->ifa_family != family)
        continue; 

#ifdef IFA_F_OPTIMISTIC
      if ((ifa->ifa_flags & IFA_F_OPTIMISTIC) != 0)
        continue;
#endif
#ifdef IFA_F_DADFAILED
      if ((ifa->ifa_flags & IFA_F_DADFAILED) != 0)
        continue;
#endif
#ifdef IFA_F_DEPRECATED
      if ((ifa->ifa_flags & IFA_F_DEPRECATED) != 0)
        continue;
#endif
#ifdef IFA_F_TENTATIVE
      if ((ifa->ifa_flags & IFA_F_TENTATIVE) != 0)
        continue;
#endif
  
      // Since there can be point-to-point links on the machine, we need to keep
      // track of the addresses we've seen for this interface; if we see both
      // IFA_LOCAL and IFA_ADDRESS for an interface, keep only the IFA_LOCAL.
      rak::socket_address this_addr;
      bool seen_addr = false;
      int plen = IFA_PAYLOAD(nlmsg);
      for (const rtattr *rta = IFA_RTA(ifa);
           RTA_OK(rta, plen);
	   rta = RTA_NEXT(rta, plen)) {
        if (rta->rta_type != IFA_LOCAL &&
            rta->rta_type != IFA_ADDRESS) {
          continue;
        }
        if (rta->rta_type == IFA_ADDRESS && seen_addr) {
          continue;
        }
        seen_addr = true;
        switch (ifa->ifa_family) {
        case AF_INET:
          this_addr.sa_inet()->clear();
          this_addr.sa_inet()->set_address(*(const in_addr *)RTA_DATA(rta));
          break;
#ifdef RAK_USE_INET6
        case AF_INET6:
          this_addr.sa_inet6()->clear();
          this_addr.sa_inet6()->set_address(*(const in6_addr *)RTA_DATA(rta));
          break;
#endif
        }
      }
      if (!seen_addr)
        continue;
       
      int this_addr_pri = get_priority(this_addr) * 2;
      if ((ifa->ifa_flags & IFA_F_SECONDARY) == IFA_F_SECONDARY) {
        ++this_addr_pri;
      }

      if (this_addr_pri < best_addr_pri) {
        best_addr = this_addr;
        best_addr_pri = this_addr_pri;
      }
    }
  } while (!done);

  ::close(fd);
  if (!best_addr.is_address_any()) {
    *address = best_addr;
    return true;
  } else {
    return false;
  } 
}

#else

// Generic POSIX variant.
bool get_local_address(sa_family_t family, rak::socket_address *address) {
  SocketFd sock;
  if (!sock.open_datagram()) {
    return false;
  }

  rak::socket_address dummy_dest;
  dummy_dest.clear();

  switch (family) {
  case rak::socket_address::af_inet:
    dummy_dest.set_address_c_str("4.0.0.0"); 
    break;
#ifdef RAK_USE_INET6
  case rak::socket_address::af_inet6:
    dummy_dest.set_address_c_str("2001:700::"); 
    break;
#endif
  default:
    throw internal_error("Unknown address family");
  }
  dummy_dest.set_port(80);

  if (!sock.connect(dummy_dest)) {
    sock.close();
    return false;
  }

  bool ret = sock.getsockname(address);
  sock.close();
  return ret;
}

#endif

}




// libTorrent - BitTorrent library
// Copyright (C) 2005-2007, Jari Sundell
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// In addition, as a special exception, the copyright holders give
// permission to link the code of portions of this program with the
// OpenSSL library under certain conditions as described in each
// individual source file, and distribute linked combinations
// including the two.
//
// You must obey the GNU General Public License in all respects for
// all of the code used other than OpenSSL.  If you modify file(s)
// with this exception, you may extend this exception to your version
// of the file(s), but you are not obligated to do so.  If you do not
// wish to do so, delete this exception statement from your version.
// If you delete this exception statement from all source files in the
// program, then also delete it here.
//
// Contact:  Jari Sundell <jaris@ifi.uio.no>
//
//           Skomakerveien 33
//           3185 Skoppum, NORWAY

// A routine to get a local IP address that can be presented to a tracker.
// (Does not use UPnP etc., so will not understand NAT.)
// On a machine with multiple network cards, address selection can be a
// complex process, and in general what's selected is a source/destination
// address pair. However, this routine will give an approximation that will
// be good enough for most purposes and users.

#ifndef LIBTORRENT_NET_LOCAL_ADDR_H
#define LIBTORRENT_NET_LOCAL_ADDR_H

#include <unistd.h>

namespace rak {
  class socket_address;
}

namespace torrent {

// Note: family must currently be rak::af_inet or rak::af_inet6
// (rak::af_unspec won't do); anything else will throw an exception.
// Returns false if no address of the given family could be found,
// either because there are none, or because something went wrong in
// the process (e.g., no free file descriptors).
bool get_local_address(sa_family_t family, rak::socket_address *address);

}

#endif /* LIBTORRENT_NET_LOCAL_ADDR_H */

Lines 4-9 Link Here

(-)libtorrent-0.12.6.orig/src/net/Makefile.am (+2 lines)
4	address_list.cc \	4	address_list.cc \
5	address_list.h \	5	address_list.h \
6	data_buffer.h \	6	data_buffer.h \
		7	local_addr.cc \
		8	local_addr.h \
7	listen.cc \	9	listen.cc \
8	listen.h \	10	listen.h \
9	protocol_buffer.h \	11	protocol_buffer.h \

Lines 54-62 Link Here

(-)libtorrent-0.12.6.orig/src/net/Makefile.in (-3 / +6 lines)
54	CONFIG_CLEAN_VPATH_FILES =	54	CONFIG_CLEAN_VPATH_FILES =
55	LTLIBRARIES = $(noinst_LTLIBRARIES)	55	LTLIBRARIES = $(noinst_LTLIBRARIES)
56	libsub_net_la_LIBADD =	56	libsub_net_la_LIBADD =
57	am_libsub_net_la_OBJECTS = address_list.lo listen.lo socket_base.lo \	57	am_libsub_net_la_OBJECTS = address_list.lo local_addr.lo listen.lo \
58	socket_datagram.lo socket_fd.lo socket_set.lo socket_stream.lo \	58	socket_base.lo socket_datagram.lo socket_fd.lo socket_set.lo \
59	throttle_internal.lo throttle_list.lo	59	socket_stream.lo throttle_internal.lo throttle_list.lo
60	libsub_net_la_OBJECTS = $(am_libsub_net_la_OBJECTS)	60	libsub_net_la_OBJECTS = $(am_libsub_net_la_OBJECTS)
61	DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)	61	DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
62	depcomp = $(SHELL) $(top_srcdir)/depcomp	62	depcomp = $(SHELL) $(top_srcdir)/depcomp
Lines 216-221 Link Here
216	address_list.cc \	216	address_list.cc \
217	address_list.h \	217	address_list.h \
218	data_buffer.h \	218	data_buffer.h \
		219	local_addr.cc \
		220	local_addr.h \
219	listen.cc \	221	listen.cc \
220	listen.h \	222	listen.h \
221	protocol_buffer.h \	223	protocol_buffer.h \
Lines 290-295 Link Here
290		292
291	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/address_list.Plo@am__quote@	293	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/address_list.Plo@am__quote@
292	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/listen.Plo@am__quote@	294	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/listen.Plo@am__quote@
		295	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/local_addr.Plo@am__quote@
293	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/socket_base.Plo@am__quote@	296	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/socket_base.Plo@am__quote@
294	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/socket_datagram.Plo@am__quote@	297	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/socket_datagram.Plo@am__quote@
295	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/socket_fd.Plo@am__quote@	298	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/socket_fd.Plo@am__quote@

Lines 73-79 Link Here

(-)libtorrent-0.12.6.orig/src/net/socket_datagram.cc (-1 / +7 lines)
73	int r;	73	int r;
74		74
75	if (sa != NULL) {	75	if (sa != NULL) {
76	r = ::sendto(m_fileDesc, buffer, length, 0, sa->sa_inet()->c_sockaddr(), sizeof(rak::socket_address_inet));	76	#ifdef RAK_USE_INET6
		77	if (m_ipv6_socket && sa->family() == rak::socket_address::pf_inet) {
		78	rak::socket_address_inet6 sa_mapped = sa->sa_inet()->to_mapped_address();
		79	r = ::sendto(m_fileDesc, buffer, length, 0, sa_mapped.c_sockaddr(), sizeof(rak::socket_address_inet6));
		80	} else
		81	#endif
		82	r = ::sendto(m_fileDesc, buffer, length, 0, sa->c_sockaddr(), sa->length());
77	} else {	83	} else {
78	r = ::send(m_fileDesc, buffer, length, 0);	84	r = ::send(m_fileDesc, buffer, length, 0);
79	}	85	}

Lines 70-75 Link Here

(-)libtorrent-0.12.6.orig/src/net/socket_fd.cc (+76 lines)
70	check_valid();	70	check_valid();
71	int opt = p;	71	int opt = p;
72		72
		73	#ifdef RAK_USE_INET6
		74	if (m_ipv6_socket)
		75	return setsockopt(m_fd, IPPROTO_IPV6, IPV6_TCLASS, &opt, sizeof(opt)) == 0;
		76	else
		77	#endif
73	return setsockopt(m_fd, IPPROTO_IP, IP_TOS, &opt, sizeof(opt)) == 0;	78	return setsockopt(m_fd, IPPROTO_IP, IP_TOS, &opt, sizeof(opt)) == 0;
74	}	79	}
75		80
Lines 112-123 Link Here
112		117
113	bool	118	bool
114	SocketFd::open_stream() {	119	SocketFd::open_stream() {
		120	#ifdef RAK_USE_INET6
		121	m_fd = socket(rak::socket_address::pf_inet6, SOCK_STREAM, IPPROTO_TCP);
		122	if (m_fd == -1) {
		123	m_ipv6_socket = false;
		124	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_STREAM, IPPROTO_TCP)) != -1;
		125	}
		126	m_ipv6_socket = true;
		127
		128	int zero = 0;
		129	return setsockopt(m_fd, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero)) != -1;
		130	#else
115	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_STREAM, IPPROTO_TCP)) != -1;	131	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_STREAM, IPPROTO_TCP)) != -1;
		132	#endif
116	}	133	}
117		134
118	bool	135	bool
119	SocketFd::open_datagram() {	136	SocketFd::open_datagram() {
		137	#ifdef RAK_USE_INET6
		138	m_fd = socket(rak::socket_address::pf_inet6, SOCK_DGRAM, 0);
		139	if (m_fd == -1) {
		140	m_ipv6_socket = false;
		141	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_DGRAM, 0)) != -1;
		142	}
		143	m_ipv6_socket = true;
		144
		145	int zero = 0;
		146	return setsockopt(m_fd, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero)) != -1;
		147	#else
120	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_DGRAM, 0)) != -1;	148	return (m_fd = socket(rak::socket_address::pf_inet, SOCK_DGRAM, 0)) != -1;
		149	#endif
121	}	150	}
122		151
123	bool	152	bool
Lines 135-140 Link Here
135	SocketFd::bind(const rak::socket_address& sa) {	164	SocketFd::bind(const rak::socket_address& sa) {
136	check_valid();	165	check_valid();
137		166
		167	#ifdef RAK_USE_INET6
		168	if (m_ipv6_socket && sa.family() == rak::socket_address::pf_inet) {
		169	rak::socket_address_inet6 sa_mapped = sa.sa_inet()->to_mapped_address();
		170	return !::bind(m_fd, sa_mapped.c_sockaddr(), sizeof(sa_mapped));
		171	}
		172	#endif
138	return !::bind(m_fd, sa.c_sockaddr(), sa.length());	173	return !::bind(m_fd, sa.c_sockaddr(), sa.length());
139	}	174	}
140		175
Lines 142-147 Link Here
142	SocketFd::bind(const rak::socket_address& sa, unsigned int length) {	177	SocketFd::bind(const rak::socket_address& sa, unsigned int length) {
143	check_valid();	178	check_valid();
144		179
		180	#ifdef RAK_USE_INET6
		181	if (m_ipv6_socket && sa.family() == rak::socket_address::pf_inet) {
		182	rak::socket_address_inet6 sa_mapped = sa.sa_inet()->to_mapped_address();
		183	return !::bind(m_fd, sa_mapped.c_sockaddr(), sizeof(sa_mapped));
		184	}
		185	#endif
145	return !::bind(m_fd, sa.c_sockaddr(), length);	186	return !::bind(m_fd, sa.c_sockaddr(), length);
146	}	187	}
147		188
Lines 149-158 Link Here
149	SocketFd::connect(const rak::socket_address& sa) {	190	SocketFd::connect(const rak::socket_address& sa) {
150	check_valid();	191	check_valid();
151		192
		193	#ifdef RAK_USE_INET6
		194	if (m_ipv6_socket && sa.family() == rak::socket_address::pf_inet) {
		195	rak::socket_address_inet6 sa_mapped = sa.sa_inet()->to_mapped_address();
		196	return !::connect(m_fd, sa_mapped.c_sockaddr(), sizeof(sa_mapped)) \|\| errno == EINPROGRESS;
		197	}
		198	#endif
152	return !::connect(m_fd, sa.c_sockaddr(), sa.length()) \|\| errno == EINPROGRESS;	199	return !::connect(m_fd, sa.c_sockaddr(), sa.length()) \|\| errno == EINPROGRESS;
153	}	200	}
154		201
155	bool	202	bool
		203	SocketFd::getsockname(rak::socket_address *sa) {
		204	check_valid();
		205
		206	socklen_t len = sizeof(rak::socket_address);
		207	if (::getsockname(m_fd, sa->c_sockaddr(), &len)) {
		208	return false;
		209	}
		210
		211	#ifdef RAK_USE_INET6
		212	if (m_ipv6_socket && sa->family() == rak::socket_address::af_inet6) {
		213	*sa = sa->sa_inet6()->normalize_address();
		214	}
		215	#endif
		216
		217	return true;
		218	}
		219
		220	bool
156	SocketFd::listen(int size) {	221	SocketFd::listen(int size) {
157	check_valid();	222	check_valid();
158		223
Lines 164-170 Link Here
164	check_valid();	229	check_valid();
165	socklen_t len = sizeof(rak::socket_address);	230	socklen_t len = sizeof(rak::socket_address);
166		231
		232	#ifdef RAK_USE_INET6
		233	if (sa == NULL) {
		234	return SocketFd(::accept(m_fd, NULL, &len));
		235	}
		236	int fd = ::accept(m_fd, sa->c_sockaddr(), &len);
		237	if (fd != -1 && m_ipv6_socket && sa->family() == rak::socket_address::af_inet6) {
		238	*sa = sa->sa_inet6()->normalize_address();
		239	}
		240	return SocketFd(fd);
		241	#else
167	return SocketFd(::accept(m_fd, sa != NULL ? sa->c_sockaddr() : NULL, &len));	242	return SocketFd(::accept(m_fd, sa != NULL ? sa->c_sockaddr() : NULL, &len));
		243	#endif
168	}	244	}
169		245
170	// unsigned int	246	// unsigned int

Lines 77-82 Link Here

(-)libtorrent-0.12.6.orig/src/net/socket_fd.h (+4 lines)
77	bool bind(const rak::socket_address& sa);	77	bool bind(const rak::socket_address& sa);
78	bool bind(const rak::socket_address& sa, unsigned int length);	78	bool bind(const rak::socket_address& sa, unsigned int length);
79	bool connect(const rak::socket_address& sa);	79	bool connect(const rak::socket_address& sa);
		80	bool getsockname(rak::socket_address* sa);
80		81
81	bool listen(int size);	82	bool listen(int size);
82	SocketFd accept(rak::socket_address* sa);	83	SocketFd accept(rak::socket_address* sa);
Lines 88-93 Link Here
88	inline void check_valid() const;	89	inline void check_valid() const;
89		90
90	int m_fd;	91	int m_fd;
		92	#ifdef RAK_USE_INET6
		93	bool m_ipv6_socket;
		94	#endif
91	};	95	};
92		96
93	}	97	}




  m_slotResolver(&resolve_host) {

  m_bindAddress = (new rak::socket_address())->c_sockaddr();
  rak::socket_address::cast_from(m_bindAddress)->sa_inet()->clear();

  m_localAddress = (new rak::socket_address())->c_sockaddr();
  rak::socket_address::cast_from(m_localAddress)->sa_inet()->clear();

  m_proxyAddress = (new rak::socket_address())->c_sockaddr();

#ifdef RAK_USE_INET6
  rak::socket_address::cast_from(m_bindAddress)->sa_inet6()->clear();
  rak::socket_address::cast_from(m_localAddress)->sa_inet6()->clear();
  rak::socket_address::cast_from(m_proxyAddress)->sa_inet6()->clear();
#else
  rak::socket_address::cast_from(m_bindAddress)->sa_inet()->clear();
  rak::socket_address::cast_from(m_localAddress)->sa_inet()->clear();
  rak::socket_address::cast_from(m_proxyAddress)->sa_inet()->clear();
#endif
}

ConnectionManager::~ConnectionManager() {

ConnectionManager::set_bind_address(const sockaddr* sa) {
  const rak::socket_address* rsa = rak::socket_address::cast_from(sa);

#ifndef RAK_USE_INET6
  if (rsa->family() != rak::socket_address::af_inet)
    throw input_error("Tried to set a bind address that is not an af_inet address.");
#endif

  rak::socket_address::cast_from(m_bindAddress)->copy(*rsa, rsa->length());
}

ConnectionManager::set_local_address(const sockaddr* sa) {
  const rak::socket_address* rsa = rak::socket_address::cast_from(sa);

#ifndef RAK_USE_INET6
  if (rsa->family() != rak::socket_address::af_inet)
    throw input_error("Tried to set a local address that is not an af_inet address.");
#endif

  rak::socket_address::cast_from(m_localAddress)->copy(*rsa, rsa->length());
}

ConnectionManager::set_proxy_address(const sockaddr* sa) {
  const rak::socket_address* rsa = rak::socket_address::cast_from(sa);

#ifndef RAK_USE_INET6
  if (rsa->family() != rak::socket_address::af_inet)
    throw input_error("Tried to set a proxy address that is not an af_inet address.");
#endif

  rak::socket_address::cast_from(m_proxyAddress)->copy(*rsa, rsa->length());
}

Lines 57-62 Link Here

(-)libtorrent-0.12.6.orig/src/torrent/event.h (+4 lines)
57		57
58	protected:	58	protected:
59	int m_fileDesc;	59	int m_fileDesc;
		60
		61	#ifdef RAK_USE_INET6
		62	bool m_ipv6_socket;
		63	#endif
60	};	64	};
61		65
62	}	66	}

Lines 65-79 Link Here

(-)libtorrent-0.12.6.orig/src/torrent/peer/peer_list.cc (-3 / +11 lines)
65	// humans.	65	// humans.
66	return sa1->sa_inet()->address_h() < sa2->sa_inet()->address_h();	66	return sa1->sa_inet()->address_h() < sa2->sa_inet()->address_h();
67		67
		68	#ifdef RAK_USE_INET6
		69	else {
		70	const in6_addr addr1 = sa1->sa_inet6()->address();
		71	const in6_addr addr2 = sa2->sa_inet6()->address();
		72	return memcmp(&addr1, &addr2, sizeof(in6_addr)) < 0;
		73	}
		74	#else
68	else	75	else
69	// When we implement INET6 handling, embed the ipv4 address in
70	// the ipv6 address.
71	throw internal_error("socket_address_key(...) tried to compare an invalid family type.");	76	throw internal_error("socket_address_key(...) tried to compare an invalid family type.");
		77	#endif
		78
72	}	79	}
73		80
74	inline bool	81	inline bool
75	socket_address_key::is_comparable(const sockaddr* sa) {	82	socket_address_key::is_comparable(const sockaddr* sa) {
76	return rak::socket_address::cast_from(sa)->family() == rak::socket_address::af_inet;	83	return rak::socket_address::cast_from(sa)->family() == rak::socket_address::af_inet \|\|
		84	rak::socket_address::cast_from(sa)->family() == rak::socket_address::af_inet6;
77	}	85	}
78		86
79	struct peer_list_equal_port : public std::binary_function<PeerList::reference, uint16_t, bool> {	87	struct peer_list_equal_port : public std::binary_function<PeerList::reference, uint16_t, bool> {

Lines 43-48 Link Here

(-)libtorrent-0.12.6.orig/src/tracker/tracker_http.cc (-11 / +35 lines)
43		43
44	#include "download/download_info.h"	44	#include "download/download_info.h"
45	#include "net/address_list.h"	45	#include "net/address_list.h"
		46	#include "net/local_addr.h"
46	#include "torrent/connection_manager.h"	47	#include "torrent/connection_manager.h"
47	#include "torrent/exceptions.h"	48	#include "torrent/exceptions.h"
48	#include "torrent/http.h"	49	#include "torrent/http.h"
Lines 114-122 Link Here
114		115
115	const rak::socket_address* localAddress = rak::socket_address::cast_from(manager->connection_manager()->local_address());	116	const rak::socket_address* localAddress = rak::socket_address::cast_from(manager->connection_manager()->local_address());
116		117
117	if (localAddress->family() == rak::socket_address::af_inet &&	118	if (!localAddress->is_address_any())
118	!localAddress->sa_inet()->is_address_any())
119	s << "&ip=" << localAddress->address_str();	119	s << "&ip=" << localAddress->address_str();
		120
		121	#ifdef RAK_USE_INET6
		122	if (localAddress->is_address_any() \|\| localAddress->family() != rak::socket_address::pf_inet6) {
		123	rak::socket_address local_v6;
		124	if (get_local_address(rak::socket_address::af_inet6, &local_v6))
		125	s << "&ipv6=" << rak::copy_escape_html(local_v6.address_str());
		126	}
		127	#endif
120		128
121	if (info->is_compact())	129	if (info->is_compact())
122	s << "&compact=1";	130	s << "&compact=1";
Lines 220-237 Link Here
220		228
221	AddressList l;	229	AddressList l;
222		230
223	try {	231	if (!b.has_key("peers")
224	// Due to some trackers sending the wrong type when no peers are	232	#ifdef RAK_USE_INET6
225	// available, don't bork on it.	233	&& !b.has_key("peers6")
226	if (b.get_key("peers").is_string())	234	#endif
227	l.parse_address_compact(b.get_key_string("peers"));	235	) {
		236	return receive_failed("No peers returned");
		237	}
228		238
229	else if (b.get_key("peers").is_list())	239	if (b.has_key("peers")) {
230	l.parse_address_normal(b.get_key_list("peers"));	240	try {
		241	// Due to some trackers sending the wrong type when no peers are
		242	// available, don't bork on it.
		243	if (b.get_key("peers").is_string())
		244	l.parse_address_compact(b.get_key_string("peers"));
		245
		246	else if (b.get_key("peers").is_list())
		247	l.parse_address_normal(b.get_key_list("peers"));
		248
		249	} catch (bencode_error& e) {
		250	return receive_failed(e.what());
		251	}
		252	}
231		253
232	} catch (bencode_error& e) {	254	#ifdef RAK_USE_INET6
233	return receive_failed(e.what());	255	if (b.has_key("peers6")) {
		256	l.parse_address_compact_ipv6(b.get_key_string("peers6"));
234	}	257	}
		258	#endif
235		259
236	close();	260	close();
237	m_parent->receive_success(this, &l);	261	m_parent->receive_success(this, &l);

Lines 271-281 Link Here

(-)libtorrent-0.12.6.orig/src/tracker/tracker_udp.cc (-2 / +9 lines)
271		271
272	const rak::socket_address* localAddress = rak::socket_address::cast_from(manager->connection_manager()->local_address());	272	const rak::socket_address* localAddress = rak::socket_address::cast_from(manager->connection_manager()->local_address());
273		273
274	// This code assumes we're have a inet address.	274	#ifdef RAK_USE_INET6
		275	uint32_t local_addr = 0;
		276	if (localAddress->family() == rak::socket_address::af_inet)
		277	local_addr = localAddress->sa_inet()->address_n();
		278	#else
275	if (localAddress->family() != rak::socket_address::af_inet)	279	if (localAddress->family() != rak::socket_address::af_inet)
276	throw internal_error("TrackerUdp::prepare_announce_input() info->local_address() not of family AF_INET.");	280	throw internal_error("TrackerUdp::prepare_announce_input() info->local_address() not of family AF_INET.");
		281
		282	uint32_t local_addr = localAddress->sa_inet()->address_n();
		283	#endif
277		284
278	m_writeBuffer->write_32_n(localAddress->sa_inet()->address_n());	285	m_writeBuffer->write_32_n(local_addr);
279	m_writeBuffer->write_32(m_parent->key());	286	m_writeBuffer->write_32(m_parent->key());
280	m_writeBuffer->write_32(m_parent->numwant());	287	m_writeBuffer->write_32(m_parent->numwant());
281	m_writeBuffer->write_16(manager->connection_manager()->listen_port());	288	m_writeBuffer->write_16(manager->connection_manager()->listen_port());

Return to bug 336386

Lines 674-679 Link Here

(-)libtorrent-0.12.6.orig/src/dht/dht_server.cc (+10 lines)
674	if (read < 0)	674	if (read < 0)
675	break;	675	break;
676		676
		677	#ifdef RAK_USE_INET6
		678	// We can currently only process mapped-IPv4 addresses, not real IPv6.
		679	// Translate them to an af_inet socket_address.
		680	if (sa.family() == rak::socket_address::af_inet6)
		681	sa = sa.sa_inet6()->normalize_address();
		682	#endif
		683
		684	if (sa.family() != rak::socket_address::af_inet)
		685	continue;
		686
677	total += read;	687	total += read;
678	sstream.str(std::string(buffer, read));	688	sstream.str(std::string(buffer, read));
679		689

Lines 206-211 Link Here

(-)libtorrent-0.12.6.orig/src/download/download_info.h (+22 lines)
206	const char* c_str() const { return reinterpret_cast<const char*>(this); }	206	const char* c_str() const { return reinterpret_cast<const char*>(this); }
207	} __attribute__ ((packed));	207	} __attribute__ ((packed));
208		208
		209	#ifdef RAK_USE_INET6
		210	struct SocketAddressCompact6 {
		211	SocketAddressCompact6() {}
		212	SocketAddressCompact6(in6_addr a, uint16_t p) : addr(a), port(p) {}
		213	SocketAddressCompact6(const rak::socket_address_inet6* sa) : addr(sa->address()), port(sa->port_n()) {}
		214
		215	operator rak::socket_address () const {
		216	rak::socket_address sa;
		217	sa.sa_inet6()->clear();
		218	sa.sa_inet6()->set_port_n(port);
		219	sa.sa_inet6()->set_address(addr);
		220
		221	return sa;
		222	}
		223
		224	in6_addr addr;
		225	uint16_t port;
		226
		227	const char* c_str() const { return reinterpret_cast<const char*>(this); }
		228	} __attribute__ ((packed));
		229	#endif
		230
209	}	231	}
210		232
211	#endif	233	#endif

Lines 79-82 Link Here

(-)libtorrent-0.12.6.orig/src/net/address_list.cc (+12 lines)
79	std::back_inserter(*this));	79	std::back_inserter(*this));
80	}	80	}
81		81
		82	#ifdef RAK_USE_INET6
		83	void
		84	AddressList::parse_address_compact_ipv6(const std::string& s) {
		85	if (sizeof(const SocketAddressCompact6) != 18)
		86	throw internal_error("ConnectionList::AddressList::parse_address_compact_ipv6(...) bad struct size.");
		87
		88	std::copy(reinterpret_cast<const SocketAddressCompact6*>(s.c_str()),
		89	reinterpret_cast<const SocketAddressCompact6*>(s.c_str() + s.size() - s.size() % sizeof(SocketAddressCompact6)),
		90	std::back_inserter(*this));
		91	}
		92	#endif
		93
82	}	94	}

Line 0 Link Here

(-)libtorrent-0.12.6.orig/src/net/local_addr.cc (+336 lines)
		1	// libTorrent - BitTorrent library
		2	// Copyright (C) 2005-2007, Jari Sundell
		3	//
		4	// This program is free software; you can redistribute it and/or modify
		5	// it under the terms of the GNU General Public License as published by
		6	// the Free Software Foundation; either version 2 of the License, or
		7	// (at your option) any later version.
		8	//
		9	// This program is distributed in the hope that it will be useful,
		10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		12	// GNU General Public License for more details.
		13	//
		14	// You should have received a copy of the GNU General Public License
		15	// along with this program; if not, write to the Free Software
		16	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		17	//
		18	// In addition, as a special exception, the copyright holders give
		19	// permission to link the code of portions of this program with the
		20	// OpenSSL library under certain conditions as described in each
		21	// individual source file, and distribute linked combinations
		22	// including the two.
		23	//
		24	// You must obey the GNU General Public License in all respects for
		25	// all of the code used other than OpenSSL. If you modify file(s)
		26	// with this exception, you may extend this exception to your version
		27	// of the file(s), but you are not obligated to do so. If you do not
		28	// wish to do so, delete this exception statement from your version.
		29	// If you delete this exception statement from all source files in the
		30	// program, then also delete it here.
		31	//
		32	// Contact: Jari Sundell <jaris@ifi.uio.no>
		33	//
		34	// Skomakerveien 33
		35	// 3185 Skoppum, NORWAY
		36
		37	#include "config.h"
		38
		39	#include <stdio.h>
		40	#include <ifaddrs.h>
		41	#include <rak/socket_address.h>
		42	#include <sys/types.h>
		43	#include <errno.h>
		44
		45	#ifdef __linux__
		46	#include <linux/netlink.h>
		47	#include <linux/rtnetlink.h>
		48	#endif
		49
		50	#include "torrent/exceptions.h"
		51	#include "socket_fd.h"
		52	#include "local_addr.h"
		53
		54	namespace torrent {
		55	namespace {
		56
		57	// IPv4 priority, from highest to lowest:
		58	//
		59	// 1. Everything else (global address)
		60	// 2. Private address space (10.0.0.0/8, 172.16.0.0/16, 192.168.0.0/24)
		61	// 3. Empty/INADDR_ANY (0.0.0.0)
		62	// 4. Link-local address (169.254.0.0/16)
		63	// 5. Localhost (127.0.0.0/8)
		64	int get_priority_ipv4(const in_addr& addr) {
65	if ((addr.s_addr & htonl(0xff000000U)) == htonl(0x7f000000U)) {
66	return 5;
67	}
68	if (addr.s_addr == htonl(0)) {
69	return 4;
70	}
71	if ((addr.s_addr & htonl(0xffff0000U)) == htonl(0xa9fe0000U)) {
72	return 3;
73	}
74	if ((addr.s_addr & htonl(0xff000000U)) == htonl(0x0a000000U) \|\|
75	(addr.s_addr & htonl(0xffff0000U)) == htonl(0xac100000U) \|\|
76	(addr.s_addr & htonl(0xffff0000U)) == htonl(0xc0a80000U)) {
77	return 2;
78	}
79	return 1;
80	}
81
82	#ifdef RAK_USE_INET6
83	// IPv6 priority, from highest to lowest:
84	//
85	// 1. Global address (2000::/16 not in 6to4 or Teredo)
86	// 2. 6to4 (2002::/16)
87	// 3. Teredo (2001::/32)
88	// 4. Empty/INADDR_ANY (::)
89	// 5. Everything else (link-local, ULA, etc.)
90	int get_priority_ipv6(const in6_addr& addr) {
91	const uint32_t addr32 = reinterpret_cast<const uint32_t >(addr.s6_addr);
92	if (addr32[0] == htonl(0) &&
93	addr32[1] == htonl(0) &&
94	addr32[2] == htonl(0) &&
95	addr32[3] == htonl(0)) {
96	return 4;
97	}
98	if (addr32[0] == htonl(0x20010000)) {
99	return 3;
100	}
101	if ((addr32[0] & htonl(0xffff0000)) == htonl(0x20020000)) {
102	return 2;
103	}
104	if ((addr32[0] & htonl(0xe0000000)) == htonl(0x20000000)) {
105	return 1;
106	}
107	return 5;
108	}
109	#endif
110
111	int get_priority(const rak::socket_address& addr) {
112	switch (addr.family()) {
113	case AF_INET:
114	return get_priority_ipv4(addr.c_sockaddr_inet()->sin_addr);
115	#ifdef RAK_USE_INET6
116	case AF_INET6:
117	return get_priority_ipv6(addr.c_sockaddr_inet6()->sin6_addr);
118	#endif
119	default:
120	throw torrent::internal_error("Unknown address family given to compare");
121	}
122	}
123
124	}
125
126	#ifdef __linux__
127
128	// Linux-specific implementation that understands how to filter away
129	// understands how to filter away secondary addresses.
130	bool get_local_address(sa_family_t family, rak::socket_address *address) {
131	ifaddrs *ifaddrs;
132	if (getifaddrs(&ifaddrs)) {
133	return false;
134	}
135
136	rak::socket_address best_addr;
137	switch (family) {
138	case AF_INET:
139	best_addr.sa_inet()->clear();
140	break;
141	#ifdef RAK_USE_INET6
142	case AF_INET6:
143	best_addr.sa_inet6()->clear();
144	break;
145	#endif
146	default:
147	throw torrent::internal_error("Unknown address family given to get_local_address");
148	}
149
150	// The bottom bit of the priority is used to hold if the address is
151	// a secondary address (e.g. with IPv6 privacy extensions) or not;
152	// secondary addresses have lower priority (higher number).
153	int best_addr_pri = get_priority(best_addr) * 2;
154
155	// Get all the addresses via Linux' netlink interface.
156	int fd = ::socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
157	if (fd == -1) {
158	return false;
159	}
160
161	struct sockaddr_nl nladdr;
162	memset(&nladdr, 0, sizeof(nladdr));
163	nladdr.nl_family = AF_NETLINK;
164	if (::bind(fd, (sockaddr *)&nladdr, sizeof(nladdr))) {
165	::close(fd);
166	return false;
167	}
168
169	const int seq_no = 1;
170	struct {
171	nlmsghdr nh;
172	rtgenmsg g;
173	} req;
174	memset(&req, 0, sizeof(req));
175
176	req.nh.nlmsg_len = sizeof(req);
177	req.nh.nlmsg_type = RTM_GETADDR;
178	req.nh.nlmsg_flags = NLM_F_ROOT \| NLM_F_MATCH \| NLM_F_REQUEST;
179	req.nh.nlmsg_pid = getpid();
180	req.nh.nlmsg_seq = seq_no;
181	req.g.rtgen_family = AF_UNSPEC;
182
183	int ret;
184	do {
185	ret = ::sendto(fd, &req, sizeof(req), 0, (sockaddr *)&nladdr, sizeof(nladdr));
186	} while (ret == -1 && errno == EINTR);
187
188	if (ret == -1) {
189	::close(fd);
190	return false;
191	}
192
193	bool done = false;
194	do {
195	char buf[4096];
196	socklen_t len = sizeof(nladdr);
197	do {
198	ret = ::recvfrom(fd, buf, sizeof(buf), 0, (sockaddr *)&nladdr, &len);
199	} while (ret == -1 && errno == EINTR);
200
201	if (ret < 0) {
202	::close(fd);
203	return false;
204	}
205
206	for (const nlmsghdr nlmsg = (const nlmsghdr )buf;
207	NLMSG_OK(nlmsg, ret);
208	nlmsg = NLMSG_NEXT(nlmsg, ret)) {
209	if (nlmsg->nlmsg_seq != seq_no)
210	continue;
211	if (nlmsg->nlmsg_type == NLMSG_DONE) {
212	done = true;
213	break;
214	}
215	if (nlmsg->nlmsg_type == NLMSG_ERROR) {
216	::close(fd);
217	return false;
218	}
219	if (nlmsg->nlmsg_type != RTM_NEWADDR)
220	continue;
221
222	const ifaddrmsg ifa = (const ifaddrmsg )NLMSG_DATA(nlmsg);
223
224	if (ifa->ifa_family != family)
225	continue;
226
227	#ifdef IFA_F_OPTIMISTIC
228	if ((ifa->ifa_flags & IFA_F_OPTIMISTIC) != 0)
229	continue;
230	#endif
231	#ifdef IFA_F_DADFAILED
232	if ((ifa->ifa_flags & IFA_F_DADFAILED) != 0)
233	continue;
234	#endif
235	#ifdef IFA_F_DEPRECATED
236	if ((ifa->ifa_flags & IFA_F_DEPRECATED) != 0)
237	continue;
238	#endif
239	#ifdef IFA_F_TENTATIVE
240	if ((ifa->ifa_flags & IFA_F_TENTATIVE) != 0)
241	continue;
242	#endif
243
244	// Since there can be point-to-point links on the machine, we need to keep
245	// track of the addresses we've seen for this interface; if we see both
246	// IFA_LOCAL and IFA_ADDRESS for an interface, keep only the IFA_LOCAL.
247	rak::socket_address this_addr;
248	bool seen_addr = false;
249	int plen = IFA_PAYLOAD(nlmsg);
250	for (const rtattr *rta = IFA_RTA(ifa);
251	RTA_OK(rta, plen);
252	rta = RTA_NEXT(rta, plen)) {
253	if (rta->rta_type != IFA_LOCAL &&
254	rta->rta_type != IFA_ADDRESS) {
255	continue;
256	}
257	if (rta->rta_type == IFA_ADDRESS && seen_addr) {
258	continue;
259	}
260	seen_addr = true;
261	switch (ifa->ifa_family) {
262	case AF_INET:
263	this_addr.sa_inet()->clear();
264	this_addr.sa_inet()->set_address((const in_addr )RTA_DATA(rta));
265	break;
266	#ifdef RAK_USE_INET6
267	case AF_INET6:
268	this_addr.sa_inet6()->clear();
269	this_addr.sa_inet6()->set_address((const in6_addr )RTA_DATA(rta));
270	break;
271	#endif
272	}
273	}
274	if (!seen_addr)
275	continue;
276
277	int this_addr_pri = get_priority(this_addr) * 2;
278	if ((ifa->ifa_flags & IFA_F_SECONDARY) == IFA_F_SECONDARY) {
279	++this_addr_pri;
280	}
281
282	if (this_addr_pri < best_addr_pri) {
283	best_addr = this_addr;
284	best_addr_pri = this_addr_pri;
285	}
286	}
287	} while (!done);
288
289	::close(fd);
290	if (!best_addr.is_address_any()) {
291	*address = best_addr;
292	return true;
293	} else {
294	return false;
295	}
296	}
297
298	#else
299
300	// Generic POSIX variant.
301	bool get_local_address(sa_family_t family, rak::socket_address *address) {
302	SocketFd sock;
303	if (!sock.open_datagram()) {
304	return false;
305	}
306
307	rak::socket_address dummy_dest;
308	dummy_dest.clear();
309
310	switch (family) {
311	case rak::socket_address::af_inet:
312	dummy_dest.set_address_c_str("4.0.0.0");
313	break;
314	#ifdef RAK_USE_INET6
315	case rak::socket_address::af_inet6:
316	dummy_dest.set_address_c_str("2001:700::");
317	break;
318	#endif
319	default:
320	throw internal_error("Unknown address family");
321	}
322	dummy_dest.set_port(80);
323
324	if (!sock.connect(dummy_dest)) {
325	sock.close();
326	return false;
327	}
328
329	bool ret = sock.getsockname(address);
330	sock.close();
331	return ret;
332	}
333
334	#endif
335
336	}

Lines 78-90 Link Here

(-)libtorrent-0.12.6.orig/src/torrent/connection_manager.cc (-4 / +15 lines)
78	m_slotResolver(&resolve_host) {	78	m_slotResolver(&resolve_host) {
79		79
80	m_bindAddress = (new rak::socket_address())->c_sockaddr();	80	m_bindAddress = (new rak::socket_address())->c_sockaddr();
81	rak::socket_address::cast_from(m_bindAddress)->sa_inet()->clear();
82
83	m_localAddress = (new rak::socket_address())->c_sockaddr();	81	m_localAddress = (new rak::socket_address())->c_sockaddr();
84	rak::socket_address::cast_from(m_localAddress)->sa_inet()->clear();
85
86	m_proxyAddress = (new rak::socket_address())->c_sockaddr();	82	m_proxyAddress = (new rak::socket_address())->c_sockaddr();
		83
		84	#ifdef RAK_USE_INET6
		85	rak::socket_address::cast_from(m_bindAddress)->sa_inet6()->clear();
		86	rak::socket_address::cast_from(m_localAddress)->sa_inet6()->clear();
		87	rak::socket_address::cast_from(m_proxyAddress)->sa_inet6()->clear();
		88	#else
		89	rak::socket_address::cast_from(m_bindAddress)->sa_inet()->clear();
		90	rak::socket_address::cast_from(m_localAddress)->sa_inet()->clear();
87	rak::socket_address::cast_from(m_proxyAddress)->sa_inet()->clear();	91	rak::socket_address::cast_from(m_proxyAddress)->sa_inet()->clear();
		92	#endif
88	}	93	}
89		94
90	ConnectionManager::~ConnectionManager() {	95	ConnectionManager::~ConnectionManager() {
Lines 123-130 Link Here
123	ConnectionManager::set_bind_address(const sockaddr* sa) {	128	ConnectionManager::set_bind_address(const sockaddr* sa) {
124	const rak::socket_address* rsa = rak::socket_address::cast_from(sa);	129	const rak::socket_address* rsa = rak::socket_address::cast_from(sa);
125		130
		131	#ifndef RAK_USE_INET6
126	if (rsa->family() != rak::socket_address::af_inet)	132	if (rsa->family() != rak::socket_address::af_inet)
127	throw input_error("Tried to set a bind address that is not an af_inet address.");	133	throw input_error("Tried to set a bind address that is not an af_inet address.");
		134	#endif
128		135
129	rak::socket_address::cast_from(m_bindAddress)->copy(*rsa, rsa->length());	136	rak::socket_address::cast_from(m_bindAddress)->copy(*rsa, rsa->length());
130	}	137	}
Lines 133-140 Link Here
133	ConnectionManager::set_local_address(const sockaddr* sa) {	140	ConnectionManager::set_local_address(const sockaddr* sa) {
134	const rak::socket_address* rsa = rak::socket_address::cast_from(sa);	141	const rak::socket_address* rsa = rak::socket_address::cast_from(sa);
135		142
		143	#ifndef RAK_USE_INET6
136	if (rsa->family() != rak::socket_address::af_inet)	144	if (rsa->family() != rak::socket_address::af_inet)
137	throw input_error("Tried to set a local address that is not an af_inet address.");	145	throw input_error("Tried to set a local address that is not an af_inet address.");
		146	#endif
138		147
139	rak::socket_address::cast_from(m_localAddress)->copy(*rsa, rsa->length());	148	rak::socket_address::cast_from(m_localAddress)->copy(*rsa, rsa->length());
140	}	149	}
Lines 143-150 Link Here
143	ConnectionManager::set_proxy_address(const sockaddr* sa) {	152	ConnectionManager::set_proxy_address(const sockaddr* sa) {
144	const rak::socket_address* rsa = rak::socket_address::cast_from(sa);	153	const rak::socket_address* rsa = rak::socket_address::cast_from(sa);
145		154
		155	#ifndef RAK_USE_INET6
146	if (rsa->family() != rak::socket_address::af_inet)	156	if (rsa->family() != rak::socket_address::af_inet)
147	throw input_error("Tried to set a proxy address that is not an af_inet address.");	157	throw input_error("Tried to set a proxy address that is not an af_inet address.");
		158	#endif
148		159
149	rak::socket_address::cast_from(m_proxyAddress)->copy(*rsa, rsa->length());	160	rak::socket_address::cast_from(m_proxyAddress)->copy(*rsa, rsa->length());
150	}	161	}