FilesExpand file tree

 master

/

localinterfaces.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

108 lines (86 loc) · 3.15 KB

 master

/

localinterfaces.py

Copy path

Top

File metadata and controls

• Code
• Blame

108 lines (86 loc) · 3.15 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

"""Simple utility for building a list of local IPs using the socket module.

This module defines two constants:

LOCALHOST : The loopback interface, or the first interface that points to this

machine. It will *almost* always be '127.0.0.1'

LOCAL_IPS : A list of IP addresses, loopback first, that point to this machine.

PUBLIC_IPS : A list of public IP addresses that point to this machine.

Use these to tell remote clients where to find you.

"""

#-----------------------------------------------------------------------------

# Copyright (C) 2010-2011 The IPython Development Team

#

# Distributed under the terms of the BSD License. The full license is in

# the file COPYING, distributed as part of this software.

#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------

# Imports

#-----------------------------------------------------------------------------

import socket

from .data import uniq_stable

#-----------------------------------------------------------------------------

# Code

#-----------------------------------------------------------------------------

LOCAL_IPS = []

PUBLIC_IPS = []

LOCALHOST = '127.0.0.1'

def _only_once(f):

"""decorator to only run a function once"""

f.called = False

def wrapped():

if f.called:

return

ret = f()

f.called = True

return ret

return wrapped

def _requires_ips(f):

"""decorator to ensure load_ips has been run before f"""

def ips_loaded(*args, **kwargs):

_load_ips()

return f(*args, **kwargs)

return ips_loaded

@_only_once

def _load_ips():

"""load the IPs that point to this machine

This function will only ever be called once.

"""

global LOCALHOST

try:

LOCAL_IPS[:] = socket.gethostbyname_ex('localhost')[2]

except socket.error:

pass

try:

hostname = socket.gethostname()

PUBLIC_IPS[:] = socket.gethostbyname_ex(hostname)[2]

# try hostname.local, in case hostname has been short-circuited to loopback

if not hostname.endswith('.local') and all(ip.startswith('127') for ip in PUBLIC_IPS):

PUBLIC_IPS[:] = socket.gethostbyname_ex(socket.gethostname() + '.local')[2]

except socket.error:

pass

finally:

PUBLIC_IPS[:] = uniq_stable(PUBLIC_IPS)

LOCAL_IPS.extend(PUBLIC_IPS)

# include all-interface aliases: 0.0.0.0 and ''

LOCAL_IPS.extend(['0.0.0.0', ''])

LOCAL_IPS[:] = uniq_stable(LOCAL_IPS)

LOCALHOST = LOCAL_IPS[0]

@_requires_ips

def local_ips():

"""return the IP addresses that point to this machine"""

return LOCAL_IPS

@_requires_ips

def public_ips():

"""return the IP addresses for this machine that are visible to other machines"""

return PUBLIC_IPS

@_requires_ips

def localhost():

"""return ip for localhost (almost always 127.0.0.1)"""

return LOCALHOST

@_requires_ips

def is_local_ip(ip):

"""does `ip` point to this machine?"""

return ip in LOCAL_IPS

@_requires_ips

def is_public_ip(ip):

"""is `ip` a publicly visible address?"""

return ip in PUBLIC_IPS