def __new__(cls, addr, s=None):
if s is None:
host, port = addr
for af_type, cls in connector_registry.iteritems():
try :
socket.inet_pton(af_type, host)
break
except socket.error:
pass
else:
raise ValueError("Unknown type of host", host)
self = object.__new__(cls)
self.addr = cls._normAddress(addr)
if s is None:
s = socket.socket(af_type, socket.SOCK_STREAM)
else:
self.is_server = True
self.is_closed = False
self.socket = s
self.socket_fd = s.fileno()
# always use non-blocking sockets
s.setblocking(0)
# disable Nagle algorithm to reduce latency
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.queued = []
return self
def validate_ipv6(ip_text):
try:
socket.inet_pton(socket.AF_INET6, ip_text)
except socket.error:
return False
else:
return True
def join_network(self, seed_peers=None, callback=lambda msg: None):
if seed_peers is None:
seed_peers = []
self.log.info('Joining network')
known_peers = []
# Connect up through seed servers
for idx, seed in enumerate(seed_peers):
try:
socket.inet_pton(socket.AF_INET6, seed)
seed_peers[idx] = "tcp://[%s]:12345" % seed
except (socket.error, ValueError):
seed_peers[idx] = "tcp://%s:12345" % seed
# Connect to persisted peers
db_peers = self.get_past_peers()
known_peers = list(set(seed_peers)) + list(set(db_peers))
self.connect_to_peers(known_peers)
# TODO: This needs rethinking. Normally we can search for ourselves
# but because we are not connected to them quick enough this
# will always fail. Need @gubatron to review
# Populate routing table by searching for self
# if len(known_peers) > 0:
# self.search_for_my_node()
if callback is not None:
callback('Joined')
def convdata(self, dtype, data):
if dtype == "4":
if type(data) != str:
raise error("IPv4 address must be a string")
if len(data) == 4:
d = data
else:
d = socket.inet_pton(socket.AF_INET, data)
if dtype == "6":
if type(data) != str:
raise error("IPv6 address must be a string")
if len(data) == 16 and data.find(":") == -1:
d = data
else:
d = socket.inet_pton(socket.AF_INET6, data)
if dtype == "d":
if type(data) == str:
d = dn.fromstring(data)
elif isinstance(data, dn.domainname):
d = data
else:
raise error("Domain name must be either proper or string")
if dtype == "s":
d = str(data)
if dtype == "i":
d = int(data)
return d
def prepareBaseReply(self, request):
request.setETag("RTSP/1.0")
request.setResponseCode(200)
request.setHeader("cseq", request.received_headers["cseq"])
request.setHeader("audio-jack-status", "connected; type=analog")
if "apple-challenge" in request.received_headers:
challenge = request.received_headers["apple-challenge"]
if challenge[-2:] != "==":
challenge += "=="
data = base64.b64decode(challenge)
host = request.getHost().host
if (host.split(".")) == 4: # ipv4
data += socket.inet_pton(socket.AF_INET, host)
elif host[:7] == "::ffff:":
data += socket.inet_pton(socket.AF_INET, host[7:])
else:
data += socket.inet_pton(socket.AF_INET6, host.split("%")[0])
hwaddr = self.info.deviceid
for i in range (0, 12, 2):
data += chr(int(hwaddr[i:i+2], 16))
data = data.ljust(32, '\0')
#self.dump(data)
key = RSA.load_key_string(AIRPORT_PRIVATE_KEY)
signature = base64.b64encode(key.private_encrypt(data, RSA.pkcs1_padding))
if signature[-2:] == "==":
signature = signature[:-2]
request.setHeader("apple-response", signature)
def _ipv4(s):
try:
socket.inet_pton(socket.AF_INET, s)
except socket.error:
if not re.match(RE_IPV4, s):
return False
return True
def __init__(self, market_id, my_ip, my_port, my_guid, nickname=None):
self.peers = {}
self.callbacks = defaultdict(list)
self.timeouts = []
self.port = my_port
self.ip = my_ip
self.guid = my_guid
self.market_id = market_id
self.nickname = nickname
self.handler = None
# Create one ZeroMQ context to be reused and reduce overhead
self.ctx = zmq.Context()
try:
socket.inet_pton(socket.AF_INET6, my_ip)
my_uri = 'tcp://[%s]:%s' % (self.ip, self.port)
except (socket.error, ValueError):
my_uri = 'tcp://%s:%s' % (self.ip, self.port)
self.uri = my_uri
self.log = logging.getLogger(
'[%s] %s' % (market_id, self.__class__.__name__)
)
def _in6_getifaddr(ifname):
"""
Returns a list of IPv6 addresses configured on the interface ifname.
"""
# Get the output of ifconfig
try:
f = os.popen("%s %s" % (conf.prog.ifconfig, ifname))
except OSError as msg:
log_interactive.warning("Failed to execute ifconfig.")
return []
# Iterate over lines and extract IPv6 addresses
ret = []
for line in f:
if "inet6" in line:
addr = line.rstrip().split(None, 2)[1] # The second element is the IPv6 address
else:
continue
if '%' in line: # Remove the interface identifier if present
addr = addr.split("%", 1)[0]
# Check if it is a valid IPv6 address
try:
socket.inet_pton(socket.AF_INET6, addr)
except:
continue
# Get the scope and keep the address
scope = in6_getscope(addr)
ret.append((addr, scope, ifname))
return ret
def is_ipv6(addr):
"""Checks if a given address is an IPv6 address."""
try:
socket.inet_pton(socket.AF_INET6, addr)
return True
except socket.error:
return False
def _isIPv4Address(address):
try:
socket.inet_pton(socket.AF_INET, address)
except socket.error:
return False
else:
return True
def join_network(self, seed_peers=[], callback=lambda msg: None):
self.log.info('Joining network')
known_peers = []
# Connect up through seed servers
for idx, seed in enumerate(seed_peers):
try:
socket.inet_pton(socket.AF_INET6, seed)
seed_peers[idx] = "tcp://[%s]:12345" % seed
except socket.error:
seed_peers[idx] = "tcp://%s:12345" % seed
# Connect to persisted peers
db_peers = self.get_past_peers()
known_peers = list(set(seed_peers)) + list(set(db_peers))
print 'known_peers', known_peers
self.connect_to_peers(known_peers)
# Populate routing table by searching for self
if len(known_peers) > 0:
self.search_for_my_node()
if callback is not None:
callback('Joined')
def isIPV6(self, string_ip):
ipv6 = True
try:
socket.inet_pton(socket.AF_INET6, string_ip)
except:
ipv6 = False
return ipv6
def is_ip(value):
"""Determine if the given string is an IP address.
Python 2 on Windows doesn't provide ``inet_pton``, so this only
checks IPv4 addresses in that environment.
:param value: value to check
:type value: str
:return: True if string is an IP address
:rtype: bool
"""
if PY2 and os.name == 'nt':
try:
socket.inet_aton(value)
return True
except socket.error:
return False
for family in (socket.AF_INET, socket.AF_INET6):
try:
socket.inet_pton(family, value)
except socket.error:
pass
else:
return True
return False
def get_packed_host(self):
"""Returns a BEP_0005 'packed' representation of the addr."""
try:
result = socket.inet_pton(socket.AF_INET, self.host)
except (ValueError, socket.error):
result = socket.inet_pton(socket.AF_INET6, self.host)
return buffer(result)
def query_nat(self, family, proto, src_ip, src_port, dst_ip, dst_port):
[proto, family, src_port, dst_port] = [
int(v) for v in [proto, family, src_port, dst_port]]
packed_src_ip = socket.inet_pton(family, src_ip)
packed_dst_ip = socket.inet_pton(family, dst_ip)
assert len(packed_src_ip) == len(packed_dst_ip)
length = len(packed_src_ip)
pnl = self.pfioc_natlook()
pnl.proto = proto
pnl.direction = self.PF_OUT
pnl.af = family
memmove(addressof(pnl.saddr), packed_src_ip, length)
memmove(addressof(pnl.daddr), packed_dst_ip, length)
self._add_natlook_ports(pnl, src_port, dst_port)
ioctl(pf_get_dev(), self.DIOCNATLOOK,
(c_char * sizeof(pnl)).from_address(addressof(pnl)))
ip = socket.inet_ntop(
pnl.af, (c_char * length).from_address(addressof(pnl.rdaddr)).raw)
port = socket.ntohs(self._get_natlook_port(pnl.rdxport))
return (ip, port)
def get_host_addrs(self, host, port=0):
# Try IPv6
try:
socket.inet_pton(socket.AF_INET6, host)
return [host]
except socket.error:
pass
# Try IPv4
try:
socket.inet_pton(socket.AF_INET, host)
return [host]
except socket.error:
pass
# So it's a hostname, try to resolve
try:
info = socket.getaddrinfo(host, port, 0, 0, 0, socket.AI_CANONNAME)
ips = []
for family, socktype, proto, canonname, sockaddr in info:
ips.append(sockaddr[0])
return ips
except (socket.error, IndexError):
pass
# All failed
return []
def add_addr(cmd, _type, addr):
if addr is None:
return
host = None
from socket import inet_pton,AF_INET,AF_INET6
try:
inet_pton(AF_INET, addr['uri']['host'])
host = addr['uri']['host']
except:
pass
try:
inet_pton(AF_INET6, addr['uri']['host'])
host = addr['uri']['host']
except:
pass
cursor.execute("""INSERT INTO dionaea.sip_addrs
(sip_command, sip_addr_type, sip_addr_display_name,
sip_addr_uri_scheme, sip_addr_uri_user, sip_addr_uri_password,
sip_addr_uri_hostname, sip_addr_uri_host, sip_addr_uri_port) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)""",
(
cmd, _type, addr['display_name'],
addr['uri']['scheme'], addr['uri']['user'], addr['uri']['password'],
addr['uri']['host'], host, addr['uri']['port']
))
def get_all_names(self):
"""Returns all names found in the Nginx Configuration.
:returns: All ServerNames, ServerAliases, and reverse DNS entries for
virtual host addresses
:rtype: set
"""
all_names = set() # type: Set[str]
for vhost in self.parser.get_vhosts():
all_names.update(vhost.names)
for addr in vhost.addrs:
host = addr.get_addr()
if common.hostname_regex.match(host):
# If it's a hostname, add it to the names.
all_names.add(host)
elif not common.private_ips_regex.match(host):
# If it isn't a private IP, do a reverse DNS lookup
try:
if addr.ipv6:
host = addr.get_ipv6_exploded()
socket.inet_pton(socket.AF_INET6, host)
else:
socket.inet_pton(socket.AF_INET, host)
all_names.add(socket.gethostbyaddr(host)[0])
except (socket.error, socket.herror, socket.timeout):
continue
return util.get_filtered_names(all_names)
def check_ipv6(n):
""" Returns true if n is IPv6 address, false otherwise. """
try:
socket.inet_pton(socket.AF_INET6, n)
return True
except:
return False
def ipv6(value):
'''Validate an IPv6 address'''
try:
socket.inet_pton(socket.AF_INET6, value)
return value
except socket.error:
raise ValueError('{0} is not a valid ipv4 address'.format(value))
def is_local_interface(host):
is_ipv6 = False
if ':' in host:
try:
if host.find('[', 0, 2) != -1:
last_bracket_position = host.rfind(']')
last_colon_position = host.rfind(':')
if last_colon_position > last_bracket_position:
host = host.rsplit(':', 1)[0]
host = host.strip('[]')
socket.inet_pton(socket.AF_INET6, host)
is_ipv6 = True
except socket.error:
host = host.split(':',1)[0]
try:
if is_ipv6:
sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
else:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.connect( (host, 4242) )
local_ip = sock.getsockname()[0]
sock.close()
except:
log.exception("Failed to open socket with %s" % host)
raise
if local_ip == host:
return True
return False
def valid_ipv6(ip):
"""Returns True if the given string is a valid IPv6 address."""
try:
socket.inet_pton(socket.AF_INET6, ip)
except socket.error: # not a valid ip
return False
return True
def validate(self, value):
valid = True
try:
socket.inet_pton(self.family, value)
except:
valid = False
return valid
def setup(hass, config):
"""Set up Zeroconf and make Home Assistant discoverable."""
from zeroconf import Zeroconf, ServiceInfo
zeroconf = Zeroconf()
zeroconf_name = '{}.{}'.format(hass.config.location_name, ZEROCONF_TYPE)
requires_api_password = hass.config.api.api_password is not None
params = {
'version': __version__,
'base_url': hass.config.api.base_url,
'requires_api_password': requires_api_password,
}
host_ip = util.get_local_ip()
try:
host_ip_pton = socket.inet_pton(socket.AF_INET, host_ip)
except socket.error:
host_ip_pton = socket.inet_pton(socket.AF_INET6, host_ip)
info = ServiceInfo(ZEROCONF_TYPE, zeroconf_name, host_ip_pton,
hass.http.server_port, 0, 0, params)
zeroconf.register_service(info)
def stop_zeroconf(event):
"""Stop Zeroconf."""
zeroconf.unregister_service(info)
zeroconf.close()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_zeroconf)
return True
def is_valid_ipv4(string):
''''
>>> is_valid_ipv4('127.0.0.1')
True
>>> is_valid_ipv4('192.168.1.1')
True
>>> is_valid_ipv4('255.255.255')
False
'''
# http://stackoverflow.com/questions/319279/
# how-to-validate-ip-address-in-python
import socket
try:
socket.inet_pton(socket.AF_INET, string)
except AttributeError: # no inet_pton here, sorry
try:
socket.inet_aton(string)
except socket.error:
return False
return string.count('.') == 3
except socket.error: # not a valid address
return False
return True
def cidr_to_list(self, string):
# references:
# http://boubakr92.wordpress.com/2012/12/20/convert-cidr-into-ip-range-with-python/
# http://stackoverflow.com/questions/8338655/how-to-get-list-of-ip-addresses
# parse address and cidr
(addrString, cidrString) = string.split('/')
# split address into octets and convert cidr to int
addr = addrString.split('.')
cidr = int(cidrString)
# initialize the netmask and calculate based on cidr mask
mask = [0, 0, 0, 0]
for i in range(cidr):
mask[i/8] = mask[i/8] + (1 << (7 - i % 8))
# initialize net and binary and netmask with addr to get network
net = []
for i in range(4):
net.append(int(addr[i]) & mask[i])
# duplicate net into broad array, gather host bits, and generate broadcast
broad = list(net)
brange = 32 - cidr
for i in range(brange):
broad[3 - i/8] = broad[3 - i/8] + (1 << (i % 8))
# print information, mapping integer lists to strings for easy printing
#mask = '.'.join(map(str, mask))
net = '.'.join(map(str, net))
broad = '.'.join(map(str, broad))
ips = []
f = struct.unpack('!I',socket.inet_pton(socket.AF_INET,net))[0]
l = struct.unpack('!I',socket.inet_pton(socket.AF_INET,broad))[0]
while f <= l:
ips.append(socket.inet_ntop(socket.AF_INET,struct.pack('!I',f)))
f = f + 1
return ips
def is_ip6(self): from socket import inet_pton, AF_INET6, error try: inet_pton(AF_INET6, self.host) return True except error: return False
def validip6addr(addr): try: socket.inet_pton(socket.AF_INET6, addr) except (socket.error, AttributeError): return False print "Invalid Ipv6 Address" return True
def is_valid_ipv6_address(self, address):
if address == '':
return True
try:
socket.inet_pton(socket.AF_INET6, address)
except socket.error, AttributeError:
return False
def build_dst_address(self, host, port):
family_to_byte = {socket.AF_INET: c.SOCKS5_ATYP_IPv4,
socket.AF_INET6: c.SOCKS5_ATYP_IPv6}
port_bytes = struct.pack('>H', port)
# if the given destination address is an IP address, we will
# use the IP address request even if remote resolving was specified.
for family in (socket.AF_INET, socket.AF_INET6):
try:
host_bytes = socket.inet_pton(family, host)
req = [family_to_byte[family], host_bytes, port_bytes]
return req, (host, port)
except socket.error:
pass
# it's not an IP number, so it's probably a DNS name.
if self._remote_resolve:
host_bytes = host.encode('idna')
req = [c.SOCKS5_ATYP_DOMAIN, chr(len(host_bytes)).encode(),
host_bytes, port_bytes]
else:
family, host_bytes = yield from self._get_dst_addr()
host_bytes = socket.inet_pton(family, host_bytes)
req = [family_to_byte[family], host_bytes, port_bytes]
host = socket.inet_ntop(family, host_bytes)
return req, (host, port)
def addr2bin(string):
""" Convert a string IPv4/IPv6 address into an unsigned integer.
"""
return struct.unpack("!L", socket.inet_pton(DNSUtils.IP_TYPE,
string))[0]
def ip4n(self):
""" IPv4 address of remote host - raw, suitable as API parameter."""
return socket.inet_pton(socket.AF_INET, self._ip4)
def EncodeIP(ip):
return socket.inet_pton(socket.AF_INET, ip)
def ipv4_from_string(ipv4_string):
data = socket.inet_pton(socket.AF_INET, ipv4_string)
ipv4_n = struct.unpack('I', data)
ipv4 = socket.ntohl(ipv4_n[0])
return ipv4
class KZorpTestCaseServices(KZorpComm):
services = [
(kznl.KZorpAddProxyServiceMessage, {
'name': "test-proxy"
}),
(kznl.KZorpAddForwardServiceMessage, {
'name': "test3",
'dst_family': socket.AF_INET,
'dst_ip': socket.inet_pton(socket.AF_INET, '1.2.3.4'),
'dst_port': 1
}),
(kznl.KZorpAddForwardServiceMessage, {
'name': "test6",
'dst_family': socket.AF_INET,
'dst_ip': socket.inet_pton(socket.AF_INET, '1.2.3.4'),
'dst_port': 1
}),
(kznl.KZorpAddProxyServiceMessage, {
'name': 'test5',
'count': 303
}),
(kznl.KZorpAddDenyServiceMessage, {
'name': 'test-deny',
'logging': True,
'count': 33,
'ipv4_settings': kznl.DenyIPv4.DROP,
'ipv6_settings': kznl.DenyIPv6.DROP
}),
]
def check_svc_num(self, num_svc):
_dumped_zones = []
self.send_message(kznl.KZorpGetServiceMessage(None),
message_handler=_dumped_zones.append,
dump=True)
self.assertEqual(num_svc, len(_dumped_zones))
def check_send(self, message, return_value):
self.start_transaction()
r = self.send_message(message, assert_on_error=False)
self.end_transaction()
self.assertEqual(return_value, r)
def newSetUp(self):
self.start_transaction()
for service in self.services:
self.send_message(service[0](**service[1]))
self.end_transaction()
def tearDown(self):
self.flush_all()
def test_get_service(self):
def check_get_reply(self, service, reply):
for (name, value) in service[1].items():
self.assertEqual(getattr(reply, name), value)
self.newSetUp()
self.check_svc_num(len(self.services))
self.assertEqual(
-2,
self.send_message(kznl.KZorpGetServiceMessage("nonexistent"),
assert_on_error=False))
for service in self.services:
self.send_message(
kznl.KZorpGetServiceMessage(service[1].get('name')),
message_handler=partial(check_get_reply, self, service))
def test_add_service_duplicated(self):
self.newSetUp()
service_cnt = len(self.services)
#duplicated entry check: the matching service was in the same transaction
self.start_transaction()
self.send_message(kznl.KZorpAddProxyServiceMessage("dupe1"))
res = self.send_message(kznl.KZorpAddProxyServiceMessage("dupe1"),
assert_on_error=False)
self.end_transaction()
self.assertEqual(-errno.EEXIST, res)
service_cnt += 1
self.check_svc_num(service_cnt)
#duplicated entry check: the matching service was already existing
self.check_send(kznl.KZorpAddProxyServiceMessage("dupe1"),
-errno.EEXIST)
self.check_svc_num(service_cnt)
def test_add_service_invalid(self):
class KZorpAddInvalidServiceMessage(kznl.KZorpAddServiceMessage):
type_string = "Invalid"
def __init__(self, name):
super(KZorpAddInvalidServiceMessage,
self).__init__(name, kznl.KZ_SVC_PROXY + 100, 0, 0)
self._build_payload()
self.newSetUp()
service_cnt = len(self.services)
#invalid service type
self.check_send(KZorpAddInvalidServiceMessage("invalid_service_type"),
-errno.EINVAL)
self.check_svc_num(service_cnt)
def test_add_service(self):
self.newSetUp()
service_cnt = len(self.services)
#outside of transaction
self.assertEqual(
-errno.ENOENT,
self.send_message(self.services[0][0](**self.services[0][1]),
assert_on_error=False))
self.check_svc_num(service_cnt)
def test_add_service_flags(self):
self.newSetUp()
service_cnt = len(self.services)
for i in range(2 * kznl.KZF_SVC_LOGGING):
self.check_send(kznl.KZorpAddProxyServiceMessage("flag-%d" % i, i),
0)
service_cnt += 2 * kznl.KZF_SVC_LOGGING
self.check_svc_num(service_cnt)
# using undefined flags
self.start_transaction()
res = self.send_message(kznl.KZorpAddProxyServiceMessage(
"flag-invalid", flags=0xfffffffc),
assert_on_error=False)
self.end_transaction()
self.assertNotEqual(0, res)
def test_add_service_nontransparent(self):
self.newSetUp()
service_cnt = len(self.services)
self.check_send(
kznl.KZorpAddForwardServiceMessage("test-nontransparent-router",
flags=0,
count=0,
dst_family=socket.AF_INET,
dst_ip=socket.inet_pton(
socket.AF_INET, '1.2.3.4'),
dst_port=10010), 0)
service_cnt += 1
self.check_svc_num(service_cnt)
self.check_send(
kznl.KZorpAddForwardServiceMessage("test-nontransparent-norouter",
flags=0,
count=0), -errno.EINVAL)
self.check_svc_num(service_cnt)
def _test_add_service_nat(self, nat_message_class):
service_cnt = len(self.services)
#adding a nat rule to a service added in the same transaction
self.start_transaction()
self.send_message(
kznl.KZorpAddForwardServiceMessage('test-nat',
flags=kznl.KZF_SVC_TRANSPARENT))
self.send_message(
nat_message_class('test-nat',
nat_src=(kznl.KZ_SVC_NAT_MAP_IPS +
kznl.KZ_SVC_NAT_MAP_PROTO_SPECIFIC,
12345688, 12345689, 1024, 1025),
nat_map=(kznl.KZ_SVC_NAT_MAP_IPS +
kznl.KZ_SVC_NAT_MAP_PROTO_SPECIFIC,
12345688, 12345689, 1024, 1025)))
self.end_transaction()
service_cnt += 2
self.check_svc_num(service_cnt)
def test_add_service_nat_dst(self):
self.newSetUp()
self._test_add_service_nat(
kznl.KZorpAddServiceDestinationNATMappingMessage)
def test_add_service_nat_src(self):
self.newSetUp()
self._test_add_service_nat(kznl.KZorpAddServiceSourceNATMappingMessage)
def test_add_deny_service(self):
response = []
m = kznl.KZorpAddDenyServiceMessage("denyservice", False, 0,
kznl.DenyIPv4.DROP,
kznl.DenyIPv6.DROP)
self.start_transaction()
self.send_message(m)
self.end_transaction()
self.start_transaction()
self.send_message(kznl.KZorpGetServiceMessage("denyservice"),
message_handler=response.append,
dump=True)
self.end_transaction()
self.assertEqual(1, len(response))
def is_valid_ipv6_address(addr):
try:
socket.inet_pton(socket.AF_INET6, addr)
except socket.error:
return False
return True
def _NlAttrIPAddress(self, nla_type, family, address):
return self._NlAttr(nla_type, socket.inet_pton(family, address))
def storeKeyValue(self, nodes, key, value, originalPublisherID, age):
self.log.debug('Store Key Value: (%s, %s %s)' % (nodes, key, type(value)))
try:
value_json = json.loads(value)
# Add Notary GUID to index
if 'notary_index_add' in value_json:
existing_index = self.dataStore[key]
if existing_index is not None:
if not value_json['notary_index_add'] in existing_index['notaries']:
existing_index['notaries'].append(value_json['notary_index_add'])
value = existing_index
else:
value = {'notaries': [value_json['notary_index_add']]}
self.log.info('Notaries: %s' % existing_index)
if 'notary_index_remove' in value_json:
existing_index = self.dataStore[key]
if existing_index is not None:
if value_json['notary_index_remove'] in existing_index['notaries']:
existing_index['notaries'].remove(value_json['notary_index_remove'])
value = existing_index
else:
return
else:
return
# Add listing to keyword index
if 'keyword_index_add' in value_json:
existing_index = self.dataStore[key]
if existing_index is not None:
if not value_json['keyword_index_add'] in existing_index['listings']:
existing_index['listings'].append(value_json['keyword_index_add'])
value = existing_index
else:
value = {'listings': [value_json['keyword_index_add']]}
self.log.info('Keyword Index: %s' % value)
if 'keyword_index_remove' in value_json:
existing_index = self.dataStore[key]
if existing_index is not None:
if value_json['keyword_index_remove'] in existing_index['listings']:
existing_index['listings'].remove(value_json['keyword_index_remove'])
value = existing_index
else:
return
else:
# Not in keyword index anyways
return
except Exception as e:
self.log.debug('Value is not a JSON array: %s' % e)
now = int(time.time())
originallyPublished = now - age
# Store it in your own node
self.dataStore.setItem(key, value, now, originallyPublished, originalPublisherID, market_id=self.market_id)
for node in nodes:
self.log.debug('Sending data to store in DHT: %s' % str(node))
try:
socket.inet_pton(socket.AF_INET6, node[0])
uri = 'tcp://[%s]:%s' % (node[0], node[1])
except (socket.error, ValueError):
uri = 'tcp://%s:%s' % (node[0], node[1])
guid = node[2]
peer = self.routingTable.getContact(guid)
if guid == self.transport.guid:
break
if not peer:
peer = self.transport.get_crypto_peer(guid, uri)
peer.start_handshake()
peer.send(proto_store(key, value, originalPublisherID, age))
def validate_ip_v6_address(address):
try:
socket.inet_pton(socket.AF_INET6, address)
except socket.error:
return False
return True
def to_net_addr(addr):
return socket.inet_pton(socket.AF_INET6, addr)
def inet_pton(afam, text):
return socket.inet_pton(afam, text)
def test_delete_tunnel_ip_flow_dl(self):
dest_ip = IPAddress(
version=IPAddress.IPV4,
address=socket.inet_pton(socket.AF_INET, "192.168.128.12"),
)
src_ip = IPAddress(
version=IPAddress.IPV4,
address=socket.inet_pton(socket.AF_INET, "192.168.129.64"),
)
ip_flow_dl = IPFlowDL(
set_params=71,
tcp_dst_port=0,
tcp_src_port=5002,
udp_dst_port=0,
udp_src_port=0,
ip_proto=6,
dest_ip=dest_ip,
src_ip=src_ip,
precedence=65530,
)
seid1 = 5000
ue_ip_addr = "192.168.128.30"
self.classifier_controller.gtp_handler(
1,
65525,
1,
100000,
IPAddress(version=IPAddress.IPV4,
address=ue_ip_addr.encode('utf-8')),
self.EnodeB_IP,
seid1,
ip_flow_dl=ip_flow_dl,
)
dest_ip = IPAddress(
version=IPAddress.IPV4,
address=socket.inet_pton(socket.AF_INET, "192.168.128.111"),
)
src_ip = IPAddress(
version=IPAddress.IPV4,
address=socket.inet_pton(socket.AF_INET, "192.168.129.4"),
)
ip_flow_dl = IPFlowDL(
set_params=70,
tcp_dst_port=0,
tcp_src_port=0,
udp_dst_port=80,
udp_src_port=5060,
ip_proto=17,
dest_ip=dest_ip,
src_ip=src_ip,
precedence=65525,
)
seid2 = 5001
ue_ip_addr = "192.168.128.31"
self.classifier_controller.gtp_handler(
1,
65525,
2,
100001,
IPAddress(version=IPAddress.IPV4,
address=ue_ip_addr.encode('utf-8')),
self.EnodeB_IP,
seid2,
ip_flow_dl=ip_flow_dl,
)
snapshot_verifier = SnapshotVerifier(
self,
self.BRIDGE,
self.service_manager,
)
with snapshot_verifier:
pass
def __init__(self,
server_address,
xml_file,
multicast=False,
starting_mid=None,
cache=False,
sock=None):
"""
Initialize the Reverse Proxy.
:param server_address: Server address for incoming connections
:param xml_file: the xml file that describe remote servers
:param multicast: if the ip is a multicast address
:param starting_mid: used for testing purposes
:param cache: if a cache must be used
:param sock: if a socket has been created externally, it can be used directly
"""
self.stopped = threading.Event()
self.stopped.clear()
self.to_be_stopped = []
self.purge = threading.Thread(target=self.purge)
self.purge.start()
self._messageLayer = MessageLayer(starting_mid)
self._blockLayer = BlockLayer()
self._observeLayer = ObserveLayer()
self._forwardLayer = ForwardLayer(self)
self.resourceLayer = ResourceLayer(self)
self.cache_enable = cache
if self.cache_enable:
self._cacheLayer = CacheLayer(defines.REVERSE_PROXY)
else:
self._cacheLayer = None
# Resource directory
root = Resource('root',
self,
visible=False,
observable=False,
allow_children=True)
root.path = '/'
self.root = Tree()
self.root["/"] = root
self._serializer = None
self.server_address = server_address
self.multicast = multicast
self.file_xml = xml_file
self._mapping = {}
addrinfo = socket.getaddrinfo(self.server_address[0], None)[0]
if sock is not None:
# Use given socket, could be a DTLS socket
self._socket = sock
self.parse_config()
elif self.multicast: # pragma: no cover
# Create a socket
# self._socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_TTL, 255)
# self._socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_LOOP, 1)
# Join group
if addrinfo[0] == socket.AF_INET: # IPv4
self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
# Allow multiple copies of this program on one machine
# (not strictly needed)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self._socket.bind(('', self.server_address[1]))
mreq = struct.pack("4sl",
socket.inet_aton(defines.ALL_COAP_NODES),
socket.INADDR_ANY)
self._socket.setsockopt(socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP, mreq)
else:
# Bugfix for Python 3.6 for Windows ... missing IPPROTO_IPV6 constant
if not hasattr(socket, 'IPPROTO_IPV6'):
socket.IPPROTO_IPV6 = 41
self._socket = socket.socket(socket.AF_INET6,
socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
# Allow multiple copies of this program on one machine
# (not strictly needed)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self._socket.bind(('', self.server_address[1]))
addrinfo_multicast = socket.getaddrinfo(
defines.ALL_COAP_NODES_IPV6, 5683)[0]
group_bin = socket.inet_pton(socket.AF_INET6,
addrinfo_multicast[4][0])
mreq = group_bin + struct.pack('@I', 0)
self._socket.setsockopt(socket.IPPROTO_IPV6,
socket.IPV6_JOIN_GROUP, mreq)
else:
if addrinfo[0] == socket.AF_INET: # IPv4
self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
else:
self._socket = socket.socket(socket.AF_INET6,
socket.SOCK_DGRAM)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self._socket.bind(self.server_address)
self.parse_config()
def __init__(self,
server_address,
multicast=False,
starting_mid=None,
sock=None,
cb_ignore_listen_exception=None):
"""
Initialize the server.
:param server_address: Server address for incoming connections
:param multicast: if the ip is a multicast address
:param starting_mid: used for testing purposes
:param sock: if a socket has been created externally, it can be used directly
:param cb_ignore_listen_exception: Callback function to handle exception raised during the socket listen operation
"""
self.stopped = threading.Event()
self.stopped.clear()
self.to_be_stopped = []
self.purge = threading.Thread(target=self.purge)
self.purge.start()
self._messageLayer = MessageLayer(starting_mid)
self._blockLayer = BlockLayer()
self._observeLayer = ObserveLayer()
self._requestLayer = RequestLayer(self)
self.resourceLayer = ResourceLayer(self)
# Resource directory
root = Resource('root',
self,
visible=False,
observable=False,
allow_children=False)
root.path = '/'
self.root = Tree()
self.root["/"] = root
self._serializer = None
self.server_address = server_address
self.multicast = multicast
self._cb_ignore_listen_exception = cb_ignore_listen_exception
addrinfo = socket.getaddrinfo(self.server_address[0], None)[0]
if sock is not None:
# Use given socket, could be a DTLS socket
self._socket = sock
elif self.multicast: # pragma: no cover
# Create a socket
# self._socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_TTL, 255)
# self._socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_LOOP, 1)
# Join group
if addrinfo[0] == socket.AF_INET: # IPv4
self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
# Allow multiple copies of this program on one machine
# (not strictly needed)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self._socket.bind(
(defines.ALL_COAP_NODES, self.server_address[1]))
mreq = struct.pack("4sl",
socket.inet_aton(defines.ALL_COAP_NODES),
socket.INADDR_ANY)
self._socket.setsockopt(socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP, mreq)
self._unicast_socket = socket.socket(socket.AF_INET,
socket.SOCK_DGRAM)
self._unicast_socket.setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
self._unicast_socket.bind(self.server_address)
else:
self._socket = socket.socket(socket.AF_INET6,
socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
# Allow multiple copies of this program on one machine
# (not strictly needed)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self._socket.bind(
(defines.ALL_COAP_NODES_IPV6, self.server_address[1]))
addrinfo_multicast = socket.getaddrinfo(
defines.ALL_COAP_NODES_IPV6, 5683)[0]
group_bin = socket.inet_pton(socket.AF_INET6,
addrinfo_multicast[4][0])
mreq = group_bin + struct.pack('@I', 0)
self._socket.setsockopt(socket.IPPROTO_IPV6,
socket.IPV6_JOIN_GROUP, mreq)
self._unicast_socket = socket.socket(socket.AF_INET6,
socket.SOCK_DGRAM)
self._unicast_socket.setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
self._unicast_socket.bind(self.server_address)
else:
if addrinfo[0] == socket.AF_INET: # IPv4
self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
else:
self._socket = socket.socket(socket.AF_INET6,
socket.SOCK_DGRAM)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self._socket.bind(self.server_address)
def setUpClass(cls):
super(TestVxlanGpe, cls).setUpClass()
try:
cls.dport = 4790
cls.flags = 0x0c
# Create 2 pg interfaces.
cls.create_pg_interfaces(range(4))
for pg in cls.pg_interfaces:
pg.admin_up()
# Configure IPv4 addresses on VPP pg0.
cls.pg0.config_ip4()
# Resolve MAC address for VPP's IP address on pg0.
cls.pg0.resolve_arp()
# Our Multicast address
cls.mcast_ip4 = '239.1.1.1'
cls.mcast_ip4n = socket.inet_pton(socket.AF_INET, cls.mcast_ip4)
iplong = atol(cls.mcast_ip4)
cls.mcast_mac = "01:00:5e:%02x:%02x:%02x" % (
(iplong >> 16) & 0x7F, (iplong >> 8) & 0xFF, iplong & 0xFF)
# Create VXLAN-GPE VTEP on VPP pg0, and put vxlan_gpe_tunnel0
# and pg1 into BD.
cls.single_tunnel_bd = 11
r = cls.vapi.vxlan_gpe_add_del_tunnel(src_addr=cls.pg0.local_ip4n,
dst_addr=cls.pg0.remote_ip4n,
vni=cls.single_tunnel_bd)
cls.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=r.sw_if_index,
bd_id=cls.single_tunnel_bd)
cls.vapi.sw_interface_set_l2_bridge(
rx_sw_if_index=cls.pg1.sw_if_index, bd_id=cls.single_tunnel_bd)
# Setup vni 2 to test multicast flooding
cls.n_ucast_tunnels = 10
cls.mcast_flood_bd = 12
cls.create_vxlan_gpe_flood_test_bd(cls.mcast_flood_bd,
cls.n_ucast_tunnels)
r = cls.vapi.vxlan_gpe_add_del_tunnel(src_addr=cls.pg0.local_ip4n,
dst_addr=cls.mcast_ip4n,
mcast_sw_if_index=1,
vni=cls.mcast_flood_bd)
cls.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=r.sw_if_index,
bd_id=cls.mcast_flood_bd)
cls.vapi.sw_interface_set_l2_bridge(
rx_sw_if_index=cls.pg2.sw_if_index, bd_id=cls.mcast_flood_bd)
# Add and delete mcast tunnels to check stability
cls.add_shared_mcast_dst_load()
cls.add_mcast_tunnels_load()
cls.del_shared_mcast_dst_load()
cls.del_mcast_tunnels_load()
# Setup vni 3 to test unicast flooding
cls.ucast_flood_bd = 13
cls.create_vxlan_gpe_flood_test_bd(cls.ucast_flood_bd,
cls.n_ucast_tunnels)
cls.vapi.sw_interface_set_l2_bridge(
rx_sw_if_index=cls.pg3.sw_if_index, bd_id=cls.ucast_flood_bd)
except Exception:
super(TestVxlanGpe, cls).tearDownClass()
raise
def _handle_stage_addr(self, data):
addr, port = self._client_address
if self._is_local:
cmd = common.ord(data[1])
if cmd == CMD_UDP_ASSOCIATE:
logging.debug('U[%d] UDP associate' %
self._config['server_port'])
if self._local_sock.family == socket.AF_INET6:
header = b'\x05\x00\x00\x04'
else:
header = b'\x05\x00\x00\x01'
addr_to_send = socket.inet_pton(self._local_sock.family, addr)
port_to_send = struct.pack('>H', port)
self._write_to_sock(header + addr_to_send + port_to_send,
self._local_sock)
self._stage = STAGE_UDP_ASSOC
# just wait for the client to disconnect
return
elif cmd == CMD_CONNECT:
# just trim VER CMD RSV
data = data[3:]
else:
logging.error('U[%d] Unknown command %d',
self._config['server_port'], cmd)
self.destroy()
return
header_result = parse_header(data)
if header_result is None:
raise Exception('TCP can not parse header')
addrtype, remote_addr, remote_port, header_length = header_result
if self._config['firewall_ports'] and self._config[
'server_port'] not in self._config['firewall_trusted']:
# Firewall enabled
if self._config[
'firewall_mode'] == 'blacklist' and remote_port in self._config[
'firewall_ports']:
firewall_blocked = True
elif self._config[
'firewall_mode'] == 'whitelist' and remote_port not in self._config[
'firewall_ports']:
firewall_blocked = True
else:
firewall_blocked = False
else:
firewall_blocked = False
if firewall_blocked:
logging.warning('U[%d] TCP PORT BANNED: RP[%d] A[%s-->%s]' %
(self._config['server_port'], remote_port, addr,
common.to_str(remote_addr)))
return
else:
logging.info('U[%d] TCP CONN: RP[%d] A[%s-->%s]' %
(self._config['server_port'], remote_port, addr,
common.to_str(remote_addr)))
self._remote_address = (common.to_str(remote_addr), remote_port)
# pause reading
self._update_stream(STREAM_UP, WAIT_STATUS_WRITING)
self._stage = STAGE_DNS
if self._is_local:
# forward address to remote
self._write_to_sock((b'\x05\x00\x00\x01'
b'\x00\x00\x00\x00\x10\x10'),
self._local_sock)
data_to_send = self._cryptor.encrypt(data)
self._data_to_write_to_remote.append(data_to_send)
# notice here may go into _handle_dns_resolved directly
self._dns_resolver.resolve(self._chosen_server[0],
self._handle_dns_resolved)
else:
if self._ota_enable_session:
data = data[header_length:]
self._ota_chunk_data(data,
self._data_to_write_to_remote.append)
elif len(data) > header_length:
self._data_to_write_to_remote.append(data[header_length:])
# notice here may go into _handle_dns_resolved directly
self._dns_resolver.resolve(remote_addr, self._handle_dns_resolved)
class NAT46(AbstractNAT):
"""
<class maturity="stable">
<summary>
Class that performs translation from IPv4 to IPv6 addresses (NAT46)
</summary>
<description>
NAT46 embeds and IPv4 address into a specific portion of the IPv6 address
according to the NAT46 specification as described in RFC6052
(http://tools.ietf.org/html/rfc6052#section-2.2).
</description>
<metainfo>
<attributes/>
</metainfo>
</class>
"""
def __init__(self, prefix="64:ff9b::", prefix_mask=96, suffix="::"):
"""
<method maturity="stable">
<summary>
Constructor to initialize a NAT46 instance.
</summary>
<description>
<para>
This constructor initializes a NAT46 instance.
</para>
</description>
<metainfo>
<arguments>
<argument maturity="stable">
<name>prefix</name>
<type>
<string display_name="Prefix"/>
</type>
<default>"64:ff9b::"</default>
<description>This parameter specifies the common leading part of the IPv6 address that
the IPv4 address should map into. Bits that exceed the mask will be overwritten by the
mapping.</description>
</argument>
<argument maturity="stable">
<name>prefix_mask</name>
<type>
<integer display_name="Prefix netmask"/>
</type>
<default>96</default>
<description>This parameter specifies the position to embed the IPv4 address to and must
be one of 32, 40, 48, 56, 64, or 96.</description>
</argument>
<argument maturity="stable">
<name>suffix</name>
<type>
<string display_name="Suffix"/>
</type>
<default>"::"</default>
<description>This parameter specifies the common trailing part of the IPv6 address that
the IPv4 address should map into. The length of the suffix must not exceed the empty bit
count determined by the configured prefix mask.</description>
</argument>
</arguments>
</metainfo>
</method>
"""
super(NAT46, self).__init__()
try:
self.prefix = socket.inet_pton(socket.AF_INET6, prefix)
except socket.error, e:
raise UserException, "Invalid prefix string specified; error='%s'" % e
try:
self.suffix = socket.inet_pton(socket.AF_INET6, suffix)
except socket.error, e:
raise UserException, "Invalid suffix string specified; error='%s'" % e
def ip_to_bytes(ip):
if ":" in ip: # determine if address is IPv6
return socket.inet_pton(socket.AF_INET6, ip)
else:
return IPV4_PREFIX + socket.inet_pton(socket.AF_INET, ip)
def is_ipv4(addr):
try:
socket.inet_pton(socket.AF_INET, addr)
except socket.error:
return False
return True
def ip6_to_integer(ip6):
ip6 = socket.inet_pton(socket.AF_INET6, ip6)
a, b = unpack(">QQ", ip6)
return (a << 64) | b
def ip(bot, trigger):
"""IP Lookup tool"""
# Check if there is input at all
if not trigger.group(2):
return bot.reply("No search term.")
# Check whether the input is an IP or hostmask or a nickname
decide = ['.', ':']
if any(x in trigger.group(2) for x in decide):
# It's an IP/hostname!
query = trigger.group(2).strip()
else:
# Need to get the host for the username
username = trigger.group(2).strip()
user_in_botdb = bot.users.get(username)
if user_in_botdb is not None:
query = user_in_botdb.host
else:
return bot.say("I\'m not aware of this user.")
db_path = _find_geoip_db(bot)
if db_path is False:
LOGGER.error('Can\'t find (or download) usable GeoIP database.')
bot.say(
'Sorry, I don\'t have a GeoIP database to use for this lookup.')
return False
if ':' in query:
try:
socket.inet_pton(socket.AF_INET6, query)
except (OSError, socket.error): # Python 2/3 compatibility
return bot.say("[IP/Host Lookup] Unable to resolve IP/Hostname")
elif '.' in query:
try:
socket.inet_pton(socket.AF_INET, query)
except (socket.error, socket.herror):
try:
query = socket.getaddrinfo(query, None)[0][4][0]
except socket.gaierror:
return bot.say(
"[IP/Host Lookup] Unable to resolve IP/Hostname")
else:
return bot.say("[IP/Host Lookup] Unable to resolve IP/Hostname")
city = geoip2.database.Reader(os.path.join(db_path, 'GeoLite2-City.mmdb'))
asn = geoip2.database.Reader(os.path.join(db_path, 'GeoLite2-ASN.mmdb'))
host = socket.getfqdn(query)
try:
city_response = city.city(query)
asn_response = asn.asn(query)
except geoip2.errors.AddressNotFoundError:
return bot.say("[IP/Host Lookup] The address is not in the database.")
response = "[IP/Host Lookup] Hostname: %s" % host
try:
response += " | Location: %s" % city_response.country.name
except AttributeError:
response += ' | Location: Unknown'
region = city_response.subdivisions.most_specific.name
response += " | Region: %s" % region if region else ""
city = city_response.city.name
response += " | City: %s" % city if city else ""
isp = "AS" + str(asn_response.autonomous_system_number) + \
" " + asn_response.autonomous_system_organization
response += " | ISP: %s" % isp if isp else ""
bot.say(response)
