src/allmydata/util/iputil.py

   1 # portions extracted from ipaddresslib by Autonomous Zone Industries, LGPL (author: Greg Smith)
   2 # portions adapted from nattraverso.ipdiscover
   3 # portions authored by Brian Warner, working for Allmydata
   4 # most recent version authored by Zooko O'Whielacronx, working for Allmydata
   5
   6 # from the Python Standard Library
   7 import os, re, socket, sys
   8
   9 # from Twisted
  10 from twisted.internet import defer
  11 from twisted.internet import reactor
  12 from twisted.internet.protocol import DatagramProtocol
  13 from twisted.internet.utils import getProcessOutput
  14 from twisted.python.procutils import which
  15 from twisted.python import log
  16
  17 # from allmydata.util
  18 import observer
  19
  20 try:
  21     import resource
  22     def increase_rlimits():
  23         # We'd like to raise our soft resource.RLIMIT_NOFILE, since certain
  24         # systems (OS-X, probably solaris) start with a relatively low limit
  25         # (256), and some unit tests want to open up more sockets than this.
  26         # Most linux systems start with both hard and soft limits at 1024,
  27         # which is plenty.
  28
  29         # unfortunately the values to pass to setrlimit() vary widely from
  30         # one system to another. OS-X reports (256, HUGE), but the real hard
  31         # limit is 10240, and accepts (-1,-1) to mean raise it to the
  32         # maximum. Cygwin reports (256, -1), then ignores a request of
  33         # (-1,-1): instead you have to guess at the hard limit (it appears to
  34         # be 3200), so using (3200,-1) seems to work. Linux reports a
  35         # sensible (1024,1024), then rejects (-1,-1) as trying to raise the
  36         # maximum limit, so you could set it to (1024,1024) but you might as
  37         # well leave it alone.
  38
  39         try:
  40             current = resource.getrlimit(resource.RLIMIT_NOFILE)
  41         except AttributeError:
  42             # we're probably missing RLIMIT_NOFILE
  43             return
  44
  45         if current[0] >= 1024:
  46             # good enough, leave it alone
  47             return
  48
  49         try:
  50             if current[1] > 0 and current[1] < 1000000:
  51                 # solaris reports (256, 65536)
  52                 resource.setrlimit(resource.RLIMIT_NOFILE,
  53                                    (current[1], current[1]))
  54             else:
  55                 # this one works on OS-X (bsd), and gives us 10240, but
  56                 # it doesn't work on linux (on which both the hard and
  57                 # soft limits are set to 1024 by default).
  58                 resource.setrlimit(resource.RLIMIT_NOFILE, (-1,-1))
  59                 new = resource.getrlimit(resource.RLIMIT_NOFILE)
  60                 if new[0] == current[0]:
  61                     # probably cygwin, which ignores -1. Use a real value.
  62                     resource.setrlimit(resource.RLIMIT_NOFILE, (3200,-1))
  63
  64         except ValueError:
  65             log.msg("unable to set RLIMIT_NOFILE: current value %s"
  66                      % (resource.getrlimit(resource.RLIMIT_NOFILE),))
  67         except:
  68             # who knows what. It isn't very important, so log it and continue
  69             log.err()
  70 except ImportError:
  71     def _increase_rlimits():
  72         # TODO: implement this for Windows.  Although I suspect the
  73         # solution might be "be running under the iocp reactor and
  74         # make this function be a no-op".
  75         pass
  76     # pyflakes complains about two 'def FOO' statements in the same time,
  77     # since one might be shadowing the other. This hack appeases pyflakes.
  78     increase_rlimits = _increase_rlimits
  79
  80
  81 def get_local_addresses_async(target='A.ROOT-SERVERS.NET'):
  82     """
  83     Return a Deferred that fires with a list of IPv4 addresses (as dotted-quad
  84     strings) that are currently configured on this host, sorted in descending
  85     order of how likely we think they are to work.
  86
  87     @param target: we want to learn an IP address they could try using to
  88         connect to us; The default value is fine, but it might help if you
  89         pass the address of a host that you are actually trying to be
  90         reachable to.
  91     """
  92     addresses = []
  93     local_ip = get_local_ip_for(target)
  94     if local_ip:
  95         addresses.append(local_ip)
  96
  97     if sys.platform == "cygwin":
  98         d = _cygwin_hack_find_addresses(target)
  99     else:
 100         d = _find_addresses_via_config()
 101
 102     def _collect(res):
 103         for addr in res:
 104             if addr != "0.0.0.0" and not addr in addresses:
 105                 addresses.append(addr)
 106         return addresses
 107     d.addCallback(_collect)
 108
 109     return d
 110
 111 def get_local_ip_for(target):
 112     """Find out what our IP address is for use by a given target.
 113
 114     @return: the IP address as a dotted-quad string which could be used by
 115               to connect to us. It might work for them, it might not. If
 116               there is no suitable address (perhaps we don't currently have an
 117               externally-visible interface), this will return None.
 118     """
 119
 120     try:
 121         target_ipaddr = socket.gethostbyname(target)
 122     except socket.gaierror:
 123         # DNS isn't running
 124         return None
 125     udpprot = DatagramProtocol()
 126     port = reactor.listenUDP(0, udpprot)
 127     try:
 128         udpprot.transport.connect(target_ipaddr, 7)
 129         localip = udpprot.transport.getHost().host
 130     except socket.error:
 131         # no route to that host
 132         localip = None
 133     port.stopListening() # note, this returns a Deferred
 134     return localip
 135
 136 # k: result of sys.platform, v: which kind of IP configuration reader we use
 137 _platform_map = {
 138     "linux-i386": "linux", # redhat
 139     "linux-ppc": "linux",  # redhat
 140     "linux2": "linux",     # debian
 141     "win32": "win32",
 142     "irix6-n32": "irix",
 143     "irix6-n64": "irix",
 144     "irix6": "irix",
 145     "openbsd2": "bsd",
 146     "darwin": "bsd",       # Mac OS X
 147     "freebsd4": "bsd",
 148     "freebsd5": "bsd",
 149     "freebsd6": "bsd",
 150     "netbsd1": "bsd",
 151     "sunos5": "sunos",
 152     "cygwin": "cygwin",
 153     }
 154
 155 class UnsupportedPlatformError(Exception):
 156     pass
 157
 158 # Wow, I'm really amazed at home much mileage we've gotten out of calling
 159 # the external route.exe program on windows...  It appears to work on all
 160 # versions so far.  Still, the real system calls would much be preferred...
 161 # ... thus wrote Greg Smith in time immemorial...
 162 _win32_path = 'route.exe'
 163 _win32_args = ('print',)
 164 _win32_re = re.compile('^\s*\d+\.\d+\.\d+\.\d+\s.+\s(?P<address>\d+\.\d+\.\d+\.\d+)\s+(?P<metric>\d+)\s*$', flags=re.M|re.I|re.S)
 165
 166 # These work in Redhat 6.x and Debian 2.2 potato
 167 _linux_path = '/sbin/ifconfig'
 168 _linux_re = re.compile('^\s*inet addr:(?P<address>\d+\.\d+\.\d+\.\d+)\s.+$', flags=re.M|re.I|re.S)
 169
 170 # NetBSD 1.4 (submitted by Rhialto), Darwin, Mac OS X
 171 _netbsd_path = '/sbin/ifconfig'
 172 _netbsd_args = ('-a',)
 173 _netbsd_re = re.compile('^\s+inet (?P<address>\d+\.\d+\.\d+\.\d+)\s.+$', flags=re.M|re.I|re.S)
 174
 175 # Irix 6.5
 176 _irix_path = '/usr/etc/ifconfig'
 177
 178 # Solaris 2.x
 179 _sunos_path = '/usr/sbin/ifconfig'
 180
 181 class SequentialTrier(object):
 182     """ I hold a list of executables to try and try each one in turn
 183     until one gives me a list of IP addresses."""
 184
 185     def __init__(self, exebasename, args, regex):
 186         assert not os.path.isabs(exebasename)
 187         self.exes_left_to_try = which(exebasename)
 188         self.exes_left_to_try.reverse()
 189         self.args = args
 190         self.regex = regex
 191         self.o = observer.OneShotObserverList()
 192         self._try_next()
 193
 194     def _try_next(self):
 195         if not self.exes_left_to_try:
 196             self.o.fire(None)
 197         else:
 198             exe = self.exes_left_to_try.pop()
 199             d2 = _query(exe, self.args, self.regex)
 200
 201             def cb(res):
 202                 if res:
 203                     self.o.fire(res)
 204                 else:
 205                     self._try_next()
 206
 207             def eb(why):
 208                 self._try_next()
 209
 210             d2.addCallbacks(cb, eb)
 211
 212     def when_tried(self):
 213         return self.o.when_fired()
 214
 215 # k: platform string as provided in the value of _platform_map
 216 # v: tuple of (path_to_tool, args, regex,)
 217 _tool_map = {
 218     "linux": (_linux_path, (), _linux_re,),
 219     "win32": (_win32_path, _win32_args, _win32_re,),
 220     "cygwin": (_win32_path, _win32_args, _win32_re,),
 221     "bsd": (_netbsd_path, _netbsd_args, _netbsd_re,),
 222     "irix": (_irix_path, _netbsd_args, _netbsd_re,),
 223     "sunos": (_sunos_path, _netbsd_args, _netbsd_re,),
 224     }
 225 def _find_addresses_via_config():
 226     # originally by Greg Smith, hacked by Zooko to conform to Brian's API
 227
 228     platform = _platform_map.get(sys.platform)
 229     if not platform:
 230         raise UnsupportedPlatformError(sys.platform)
 231
 232     (pathtotool, args, regex,) = _tool_map[platform]
 233
 234     # If pathtotool is a fully qualified path then we just try that.
 235     # If it is merely an executable name then we use Twisted's
 236     # "which()" utility and try each executable in turn until one
 237     # gives us something that resembles a dotted-quad IPv4 address.
 238
 239     if os.path.isabs(pathtotool):
 240         return _query(pathtotool, args, regex)
 241     else:
 242         return SequentialTrier(pathtotool, args, regex).when_tried()
 243
 244 def _query(path, args, regex):
 245     d = getProcessOutput(path, args)
 246     def _parse(output):
 247         addresses = []
 248         outputsplit = output.split('\n')
 249         for outline in outputsplit:
 250             m = regex.match(outline)
 251             if m:
 252                 addr = m.groupdict()['address']
 253                 if addr not in addresses:
 254                     addresses.append(addr)
 255
 256         return addresses
 257     d.addCallback(_parse)
 258     return d
 259
 260 def _cygwin_hack_find_addresses(target):
 261     addresses = []
 262     for h in [target, "localhost", "127.0.0.1",]:
 263         try:
 264             addr = get_local_ip_for(h)
 265             if addr not in addresses:
 266                 addresses.append(addr)
 267         except socket.gaierror:
 268             pass
 269
 270     return defer.succeed(addresses)