nattraverso/ipdiscover.py

   1 """
   2 Generic methods to retreive the IP address of the local machine.
   3
   4 TODO: Example
   5
   6 @author: Raphael Slinckx
   7 @copyright: Copyright 2005
   8 @license: LGPL
   9 @contact: U{raphael@slinckx.net<mailto:raphael@slinckx.net>}
  10 @version: 0.1.0
  11 """
  12
  13 __revision__ = "$id"
  14
  15 import random, socket, logging
  16
  17 from twisted.internet import defer, reactor
  18
  19 from twisted.internet.protocol import DatagramProtocol
  20 from twisted.internet.error import CannotListenError
  21 from twisted.internet.interfaces import IReactorMulticast
  22
  23 from nattraverso.utils import is_rfc1918_ip, is_bogus_ip
  24
  25 def get_local_ip():
  26     """
  27     Returns a deferred which will be called with a
  28     2-uple (lan_flag, ip_address) :
  29         - lan_flag:
  30             - True if it's a local network (RFC1918)
  31             - False if it's a WAN address
  32
  33         - ip_address is the actual ip address
  34
  35     @return: A deferred called with the above defined tuple
  36     @rtype: L{twisted.internet.defer.Deferred}
  37     """
  38     # first we try a connected udp socket, then via multicast
  39     logging.debug("Resolving dns to get udp ip")
  40     result = reactor.resolve('A.ROOT-SERVERS.NET')
  41     result.addCallbacks(_get_via_connected_udp, lambda x:_get_via_multicast())
  42     return result
  43
  44 def get_external_ip():
  45     """
  46     Returns a deferred which will be called with a
  47     2-uple (wan_flag, ip_address):
  48         - wan_flag:
  49             - True if it's a WAN address
  50             - False if it's a LAN address
  51             - None if it's a localhost (127.0.0.1) address
  52         - ip_address: the most accessible ip address of this machine
  53
  54     @return: A deferred called with the above defined tuple
  55     @rtype: L{twisted.internet.defer.Deferred}
  56     """
  57     return get_local_ip().addCallbacks(_on_local_ip, _on_no_local_ip)
  58
  59 #Private----------
  60 def _on_upnp_external_found(ipaddr):
  61     """
  62     Called when an external ip is found through UPNP.
  63
  64     @param ipaddr: The WAN ip address
  65     @type ipaddr: an IP string "x.x.x.x"
  66     """
  67     return (True, ipaddr)
  68
  69 def _on_no_upnp_external_found(error, ipaddr):
  70     """
  71     Called when the UPnP device failed to return external address.
  72
  73     @param ipaddr: The LAN ip address
  74     @type ipaddr: an IP string "x.x.x.x"
  75     """
  76     return (False, ipaddr)
  77
  78 def _on_local_ip(result):
  79     """
  80     Called when we got the local ip of this machine. If we have a WAN address,
  81     we return immediately, else we try to discover ip address through UPnP.
  82
  83     @param result: a tuple (lan_flag, ip_addr)
  84     @type result: a tuple (bool, ip string)
  85     """
  86     local, ipaddr = result
  87     if not local:
  88         return (True, ipaddr)
  89     else:
  90         logging.debug("Got local ip, trying to use upnp to get WAN ip")
  91         import nattraverso.pynupnp
  92         return nattraverso.pynupnp.get_external_ip().addCallbacks(
  93             _on_upnp_external_found,
  94             lambda x: _on_no_upnp_external_found(x, ipaddr))
  95
  96 def _on_no_local_ip(error):
  97     """
  98     Called when we could not retreive by any mean the ip of this machine.
  99     We simply assume there is no connectivity, and return localhost address.
 100     """
 101     return (None, "127.0.0.1")
 102
 103 def _got_multicast_ip(ipaddr):
 104     """
 105     Called when we received the ip address via udp multicast.
 106
 107     @param ipaddr: an ip address
 108     @type ipaddr: a string "x.x.x.x"
 109     """
 110     return (is_rfc1918_ip(ipaddr), ipaddr)
 111
 112 def _get_via_multicast():
 113     """
 114     Init a multicast ip address discovery.
 115
 116     @return: A deferred called with the discovered ip address
 117     @rtype: L{twisted.internet.defer.Deferred}
 118     @raise Exception: When an error occurs during the multicast engine init
 119     """
 120     try:
 121         # Init multicast engine
 122         IReactorMulticast(reactor)
 123     except:
 124         raise
 125
 126     logging.debug("Multicast ping to retrieve local IP")
 127     return _discover_multicast().addCallback(_got_multicast_ip)
 128
 129 def _get_via_connected_udp(ipaddr):
 130     """
 131     Init a UDP socket ip discovery. We do a dns query, and retreive our
 132     ip address from the connected udp socket.
 133
 134     @param ipaddr: The ip address of a dns server
 135     @type ipaddr: a string "x.x.x.x"
 136     @raise RuntimeError: When the ip is a bogus ip (0.0.0.0 or alike)
 137     """
 138     udpprot = DatagramProtocol()
 139     port = reactor.listenUDP(0, udpprot)
 140     udpprot.transport.connect(ipaddr, 7)
 141     localip = udpprot.transport.getHost().host
 142     port.stopListening()
 143
 144     if is_bogus_ip(localip):
 145         raise RuntimeError, "Invalid IP address returned"
 146     else:
 147         return (is_rfc1918_ip(localip), localip)
 148
 149 class _LocalNetworkMulticast(DatagramProtocol):
 150     def __init__(self, nonce):
 151         from p2pool.util import variable
 152
 153         self.nonce = nonce
 154         self.address_received = variable.Event()
 155
 156     def datagramReceived(self, dgram, addr):
 157         """Datagram received, we callback the IP address."""
 158         logging.debug("Received multicast pong: %s; addr:%r", dgram, addr)
 159         if dgram != self.nonce:
 160             return
 161         self.address_received.happened(addr[0])
 162
 163 @defer.inlineCallbacks
 164 def _discover_multicast():
 165     """
 166     Local IP discovery protocol via multicast:
 167         - Broadcast 3 ping multicast packet with "ping" in it
 168         - Wait for an answer
 169         - Retrieve the ip address from the returning packet, which is ours
 170     """
 171
 172     nonce = str(random.randrange(2**64))
 173     p = _LocalNetworkMulticast(nonce)
 174
 175     # 5 different UDP ports
 176     ports = [11000+random.randint(0, 5000) for port in range(5)]
 177     for attempt, port in enumerate(ports):
 178         try:
 179             mcast = reactor.listenMulticast(port, p)
 180             mcast_port = port
 181         except CannotListenError:
 182             if attempt < 5:
 183                 print "Trying another multicast UDP port", port
 184             else:
 185                 raise
 186         else:
 187             break
 188
 189     try:
 190         yield mcast.joinGroup('239.255.255.250', socket.INADDR_ANY)
 191
 192         try:
 193             logging.debug("Sending multicast ping")
 194             for i in xrange(3):
 195                 p.transport.write(nonce, ('239.255.255.250', mcast_port))
 196
 197             address, = yield p.address_received.get_deferred(5)
 198         finally:
 199             mcast.leaveGroup('239.255.255.250', socket.INADDR_ANY)
 200     finally:
 201         mcast.stopListening()
 202
 203     defer.returnValue(address)