def testInterpreterCrash(self):
# Making sure getnameinfo doesn't crash the interpreter
try:
# On some versions, this crashes the interpreter.
socket.getnameinfo(('x', 0, 0, 0), 0)
except socket.error:
pass
def testInterpreterCrash(self):
# Making sure getnameinfo doesn't crash the interpreter
try:
# On some versions, this crashes the interpreter.
socket.getnameinfo(('x', 0, 0, 0), 0)
except socket.error:
pass
def test_get_name_info():
import socket
try:
socket.getnameinfo((1, 0, 0, 0), 0)
except TypeError:
raised = True
assert raised
def _guess_alternatives(self, address):
if address not in ("::", "", "0.0.0.0"):
return None
hosts = self._find_addresses(AF_INET)
for a in hosts[:]:
self.logger.debug("Finding hostname for %s", a)
try:
host = getnameinfo((a, 0), 0)[0]
except Exception as e:
self.logger.warn("Failed to lookup name for address %s: %s",
address, e)
else:
if host != a:
hosts.append(host)
if address == "::":
hosts.append("[::]")
ipv6addresses = self._find_addresses(AF_INET6)
for address in ipv6addresses:
hosts.append("[" + address.split("%")[0] + "]")
self.logger.debug("Finding hostname for %s", address)
try:
host = getnameinfo((address, 0), 0)[0]
except Exception as e:
self.logger.warn("Failed to lookup address %s: %s",
address, e)
else:
if host != address:
hosts.append(host)
else:
hosts.append("0.0.0.0")
return hosts
def testInterpreterCrash(self):
if sys.platform[:4] == 'java': return
# Making sure getnameinfo doesn't crash the interpreter
try:
# On some versions, this crashes the interpreter.
socket.getnameinfo(('x', 0, 0, 0), 0)
except socket.error:
pass
def testInterpreterCrash(self):
if sys.platform[:4] == 'java': return
# Making sure getnameinfo doesn't crash the interpreter
try:
# On some versions, this crashes the interpreter.
socket.getnameinfo(('x', 0, 0, 0), 0)
except socket.error:
pass
def testRefCountGetNameInfo(self):
# Testing reference count for getnameinfo
if hasattr(sys, "getrefcount"):
try:
# On some versions, this loses a reference
orig = sys.getrefcount(__name__)
socket.getnameinfo(__name__, 0)
except TypeError:
self.assertEqual(sys.getrefcount(__name__), orig, "socket.getnameinfo loses a reference")
def testRefCountGetNameInfo(self):
# Testing reference count for getnameinfo
if hasattr(sys, "getrefcount"):
try:
# On some versions, this loses a reference
orig = sys.getrefcount(__name__)
socket.getnameinfo(__name__,0)
except SystemError:
if sys.getrefcount(__name__) != orig:
self.fail("socket.getnameinfo loses a reference")
def testRefCountGetNameInfo(self):
# Testing reference count for getnameinfo
if hasattr(sys, "getrefcount"):
try:
# On some versions, this loses a reference
orig = sys.getrefcount(__name__)
socket.getnameinfo(__name__, 0)
except TypeError:
self.assertEqual(sys.getrefcount(__name__), orig,
"socket.getnameinfo loses a reference")
def testRefCountGetNameInfo(self):
# Testing reference count for getnameinfo
if hasattr(sys, "getrefcount"):
try:
# On some versions, this loses a reference
orig = sys.getrefcount(__name__)
socket.getnameinfo(__name__,0)
except SystemError:
if sys.getrefcount(__name__) <> orig:
self.fail("socket.getnameinfo loses a reference")
def listener():
global service,addr
while True:
client, addr = server.accept()
print(f"{addr} connected to the server")
client.send("service".encode('utf-8'))
service = client.recv(1024).decode('utf-8')
service = service.lower()
client.send("connected to the server".encode('utf-8'))
if service == 'chatroom':
client.send("username".encode('utf-8'))
chatroom_clients.append(client)
username = client.recv(1024).decode('utf-8')
print(f'Username of the client is {username}')
usernames.append(username)
broadcast_message(f'{username} joined the chat room!')
elif service == 'file transfer':
print(f'{socket.getnameinfo(addr,1)[0]} connected to the server for file transfer')
fileTransfer_clients.append(client)
fileTransfer_clients_name.append(socket.getnameinfo(addr,1)[0])
clients.append(client)
print(f'[Active connections] {len(clients)}')
t2 = threading.Thread(target=client_handler , args=[client])
t2.start()
def validate(self, key, client_addr, cert_principals=None, ca=False):
for entry in self._ca_entries if ca else self._user_entries:
if entry.key != key:
continue
from_patterns = entry.options.get('from')
if from_patterns is not None:
client_host, _ = socket.getnameinfo((client_addr, 0),
socket.NI_NUMERICSERV)
client_ip = ip_address(client_addr)
if not all(pattern.matches(client_host, client_addr, client_ip)
for pattern in from_patterns):
continue
principal_patterns = entry.options.get('principals')
if cert_principals is not None and principal_patterns is not None:
if not all(any(pattern.matches(principal)
for principal in cert_principals)
for pattern in principal_patterns):
continue
return entry.options
return None
def listen(self):
if __debug__:
self.err_log.debug('Entering main loop.')
while True:
try:
sock, addr = self.listener.accept()
if self.secure:
sock = self.wrap_socket(sock)
self.active_queue.put((
(sock, socket.getnameinfo(addr, socket.NI_NUMERICHOST | socket.NI_NUMERICSERV)),
self.interface[1],
self.secure
))
except socket.timeout:
# socket.timeout will be raised every THREAD_STOP_CHECK_INTERVAL
# seconds. When that happens, we check if it's time to die.
if not self.ready:
if __debug__:
self.err_log.debug('Listener exiting.')
try:
self.listener.shutdown(socket.SHUT_RDWR)
except socket.error:
self.err_log.warning('Socket shutdown() failed')
self.listener.close()
return
else:
continue
except:
self.err_log.error(str(traceback.format_exc()))
def getpeernameinfo(self):
"""Returns (remote, port, family) tuple
"""
(addr, port) = socket.getnameinfo(self.socket.getpeername(),
socket.NI_NUMERICHOST | socket.NI_NUMERICSERV)
return (addr, port, self.socket.family)
def _validate_ip_address(family, address):
"""Check if `address` is valid IP address and return it, in a normalized
form.
:Parameters:
- `family`: ``socket.AF_INET`` or ``socket.AF_INET6``
- `address`: the IP address to validate
"""
try:
info = socket.getaddrinfo(address, 0, family, socket.SOCK_STREAM, 0,
socket.AI_NUMERICHOST)
except socket.gaierror as err:
logger.debug("gaierror: {0} for {1!r}".format(err, address))
raise ValueError("Bad IP address")
if not info:
logger.debug("getaddrinfo result empty")
raise ValueError("Bad IP address")
addr = info[0][4]
logger.debug(" got address: {0!r}".format(addr))
try:
return socket.getnameinfo(addr, socket.NI_NUMERICHOST)[0]
except socket.gaierror as err:
logger.debug("gaierror: {0} for {1!r}".format(err, addr))
raise ValueError("Bad IP address")
def canonicalize_dns(inhost, family=socket.AF_UNSPEC):
"Canonicalize a hostname or numeric IP address."
if inhost in canonicalization_cache:
return canonicalization_cache[inhost]
# Catch garbaged hostnames in corrupted Mode 6 responses
m = re.match("([:.[\]]|\w)*", inhost)
if not m:
raise TypeError
(hostname, portsuffix) = portsplit(inhost)
try:
ai = socket.getaddrinfo(hostname, None, family, 0, 0, socket.AI_CANONNAME)
except socket.gaierror as e:
print('getaddrinfo failed: %s' % e, file=sys.stderr)
raise SystemExit(1)
(family, socktype, proto, canonname, sockaddr) = ai[0]
try:
name = socket.getnameinfo(sockaddr, socket.NI_NAMEREQD)
result = name[0].lower() + portsuffix
except socket.gaierror:
# On OS X, canonname is empty for hosts without rDNS.
# Fall back to the hostname.
canonicalized = canonname or hostname
result = canonicalized.lower() + portsuffix
canonicalization_cache[inhost] = result
return result
def match_options(self, client_addr, cert_principals, cert_subject=None):
"""Match "from", "principals" and "subject" options in entry"""
from_patterns = self.options.get('from')
if from_patterns:
client_host, _ = socket.getnameinfo((client_addr, 0),
socket.NI_NUMERICSERV)
client_ip = ip_address(client_addr)
if not all(pattern.matches(client_host, client_addr, client_ip)
for pattern in from_patterns):
return False
principal_patterns = self.options.get('principals')
if cert_principals is not None and principal_patterns is not None:
if not all(any(pattern.matches(principal)
for principal in cert_principals)
for pattern in principal_patterns):
return False
subject_patterns = self.options.get('subject')
if cert_subject is not None and subject_patterns is not None:
if not all(pattern.matches(cert_subject)
for pattern in subject_patterns):
return False
return True
async def test_getnameinfo():
# Trivial test:
ni_numeric = stdlib_socket.NI_NUMERICHOST | stdlib_socket.NI_NUMERICSERV
with assert_checkpoints():
got = await tsocket.getnameinfo(("127.0.0.1", 1234), ni_numeric)
assert got == ("127.0.0.1", "1234")
# getnameinfo requires a numeric address as input:
with assert_checkpoints():
with pytest.raises(tsocket.gaierror):
await tsocket.getnameinfo(("google.com", 80), 0)
with assert_checkpoints():
with pytest.raises(tsocket.gaierror):
await tsocket.getnameinfo(("localhost", 80), 0)
# Blocking call to get expected values:
host, service = stdlib_socket.getnameinfo(("127.0.0.1", 80), 0)
# Some working calls:
got = await tsocket.getnameinfo(("127.0.0.1", 80), 0)
assert got == (host, service)
got = await tsocket.getnameinfo(("127.0.0.1", 80), tsocket.NI_NUMERICHOST)
assert got == ("127.0.0.1", service)
got = await tsocket.getnameinfo(("127.0.0.1", 80), tsocket.NI_NUMERICSERV)
assert got == (host, "80")
def update(self, s):
self.win.erase()
self.addstr(1, 0, "CLIENT PORT S I QUEUED RECVD SENT", curses.A_REVERSE)
self.sessions[s.server_id] = s.sessions
items = []
for l in self.sessions:
items.extend(l)
items.sort(key=lambda x: int(x.queued), reverse=True)
for i, session in enumerate(items):
try:
# ugh, need to handle if slow - thread for async resolver?
if options.names:
session.host = socket.getnameinfo((session.host, int(session.port)), 0)[0]
self.addstr(
i + 2,
0,
"%-15s %5s %1s %1s %8s %8s %8s"
% (
session.host[:15],
session.port,
session.server_id,
session.interest_ops,
session.queued,
session.recved,
session.sent,
),
)
except:
break
def __init__(self, parent, server):
"""
Initialize a HeyU client application.
:param parent: The parent of the ``HubApplication``. This
will be an instance of ``tendril.Tendril``.
:param server: The underlying HeyU server instance. The
server keeps track of subscriptions and
forwards notifications to the subscribers.
"""
# Initialize the application
super(HubApplication, self).__init__(parent)
# Save the server link
self.server = server
# Are we a persistent connection?
self.persist = False
# Set up the desired framer
parent.framers = tendril.COBSFramer(True)
# Determine the hostname of the client
try:
if parent.remote_addr[0] in ('127.0.0.1', '::1'):
self.hostname = socket.getfqdn()
else:
self.hostname, _port = socket.getnameinfo(parent.remote_addr,
0)
except Exception:
# Just use the bare address
self.hostname = parent.remote_addr[0]
def task3(ip, port):
# Creating tuple
sock_addr = (ip, int(port))
# Getting host/port by iP address
host, port = socket.getnameinfo(sock_addr, 0)
print("Domain: ", host)
print("Service: ", port)
def resolve_name_and_port(flow, addr, port, rank, flags=0):
if addr in cfg.aux:
r_addr = cfg.aux[addr]
# TODO find a way to disable hostname resolution in getnameinfo (akin to passing NULL to host)
# until then, disable name resolution effectively
flags &= ~socket.NI_NAMEREQD
flags | socket.NI_NUMERICHOST
_, r_port = socket.getnameinfo(('127.0.0.1', port), flags)
else:
addr = str(addr)
# local names must be resolvable
if rank > 0:
flags |= socket.NI_NAMEREQD
flags &= ~socket.NI_NUMERICHOST
# HACK to combat strange transient problems
r_addr, r_port = getnameinfo_repeated((addr, port), flags)
if (flags & socket.NI_NAMEREQD) and r_addr == str(addr):
flow.set_loglevel(logging.WARNING)
l.warning(f"non-resolution detected: {r_addr}")
if r_addr.find('.') == -1:
flow.set_loglevel(logging.WARNING)
l.warning(f"rejecting non-FQDN resolution {addr} -> {r_addr}")
r_addr = str(addr)
return r_addr, r_port
def setup(self):
# some hack for mapped IPv4-to-IPv6 addresses
ip = IPy.IP(self.client_address[0])
if ip.iptype() == "IPV4MAP":
self.client_address = (ip._getIPv4Map().strNormal(), self.client_address[1])
client_name = socket.getnameinfo(self.client_address, socket.NI_NUMERICSERV)
self.logger = logging.getLogger("ffcontroller.control-connection")
threading.current_thread().setName(client_name[0])
self.start_time = datetime.datetime.now()
self.last_command_time = self.start_time
self.commands_sent = 0
self.queue = MixedQueue(global_queue)
# start dedicated server for us
self.proxy_server = start_server(
ThreadedHTTPServer,
HTTPProxyRequestHandler,
options.proxy_address,
proxy_port_range.popleft(),
ServerConnectionPool(self.queue),
)
# register self for statistics
control_connections.append(self)
self.logger.debug("started")
socketserver.StreamRequestHandler.setup(self)
self.connection.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
def main():
if len(sys.argv) != 2:
print("usage:", sys.argv[0], "PORT")
sys.exit(0)
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_ip = '127.0.0.1'
sock_port = int(sys.argv[1])
sock.bind((sock_ip, sock_port))
sock.listen(1)
print("Ready to receive messages on: ", (sock_ip, sock_port))
while 1:
connectionSocket, addr = sock.accept()
data = connectionSocket.recv(1024)
print("Getting data from socket...", data)
print("Peername: ", connectionSocket.getpeername())
print("Nameinfo: ", socket.getnameinfo(addr, 0))
connectionSocket.sendall(data)
sock.close()
except OSError as e:
print("OSError:", e)
except socket.gaierror as e:
print(e)
def __init__(self, host, port):
host = socket.gethostbyname(host)
host, port = socket.getnameinfo((host, port), socket.NI_NUMERICHOST)
self.addr = (host, int(port))
self._path = "%s:%s" % (host, port)
self.socket = None
self._create_socket()
def connect(self):
# create listening socket for back connection
backserv = socket.socket()
backserv.settimeout(options.backconn_timeout)
# bind to some unused port
backserv.bind((options.backconn_address, 0))
selfaddr = backserv.getsockname()
selfnetloc = "{0}:{1}".format(*selfaddr)
self.logger.debug("awaiting back connection on {0}".format(selfnetloc))
# start listening
backserv.listen(1)
for i in range(options.retry_count):
# put both locations to queue
self.queue.put((selfnetloc, self.netloc))
# wait for connection
try:
self.sock, peeraddr = backserv.accept()
self.sock.settimeout(options.transport_timeout)
break
except socket.timeout:
self.logger.info("timeout while accepting back connection. resending request.")
else:
raise socket.timeout("timeout while trying to establish back connection")
self.logger.debug(
"accepted back connection from {0}:{1}".format(*socket.getnameinfo(peeraddr, socket.NI_NUMERICSERV))
)
# close server socket
backserv.close()
def canonicalize_dns(inhost, family=socket.AF_UNSPEC):
"Canonicalize a hostname or numeric IP address."
if inhost in canonicalization_cache:
return canonicalization_cache[inhost]
# Catch garbaged hostnames in corrupted Mode 6 responses
m = re.match("([:.[\]]|\w)*", inhost)
if not m:
raise TypeError
(hostname, portsuffix) = portsplit(inhost)
try:
ai = socket.getaddrinfo(hostname, None, family, 0, 0,
socket.AI_CANONNAME)
except socket.gaierror as e:
print('getaddrinfo failed: %s' % e, file=sys.stderr)
raise SystemExit(1)
(family, socktype, proto, canonname, sockaddr) = ai[0]
try:
name = socket.getnameinfo(sockaddr, socket.NI_NAMEREQD)
result = name[0].lower() + portsuffix
except socket.gaierror:
# On OS X, canonname is empty for hosts without rDNS.
# Fall back to the hostname.
canonicalized = canonname or hostname
result = canonicalized.lower() + portsuffix
canonicalization_cache[inhost] = result
return result
def test_getnameinfo():
from pypy.module._socket.interp_socket import get_error
host = "127.0.0.1"
port = 25
info = socket.getnameinfo((host, port), 0)
w_l = space.appexec(
[w_socket, space.wrap(host),
space.wrap(port)],
"(_socket, host, port): return _socket.getnameinfo((host, port), 0)")
assert space.unwrap(w_l) == info
sockaddr = space.newtuple([space.wrap('mail.python.org'), space.wrap(0)])
space.raises_w(
get_error(space, 'error'), space.appexec,
[w_socket, sockaddr, space.wrap(0)],
"(_socket, sockaddr, flags): return _socket.getnameinfo(sockaddr, flags)"
)
if socket.has_ipv6:
sockaddr = space.newtuple(
[space.wrap('::1'),
space.wrap(0),
space.wrap(0xffffffff)])
space.raises_w(
space.w_OverflowError, space.appexec,
[w_socket, sockaddr, space.wrap(0)],
"(_socket, sockaddr, flags): return _socket.getnameinfo(sockaddr, flags)"
)
def dns_ptr(self, urinput, addrfield):
"""Return the first resolved domain name for the address.
The address is specified in _addrfield_ of _urinput_. The
domain name is returned as a string. If no domain name can be
resolved n/a is returned."""
try:
addr = getattr(urinput, addrfield)
family = {
True: socket.AF_INET,
False: socket.AF_INET6
}[addr.isIPv4()]
return socket.getnameinfo(
(
str(addr),
# fudge port
0),
socket.NI_NAMEREQD
# select the domain name and
# ensure we don't return a
# longer string than promised
| family)[0][:self.maximumnamelength]
except Exception as err: # pylint:disable=broad-except
print("Error: Received exception {}"
" doing ptr lookup for {}".format(
err, getattr(urinput, addrfield, "unavailable address")))
return "n/a"
def test_getnameinfo():
host = "127.0.0.1"
port = 25
info = socket.getnameinfo((host, port), 0)
w_l = space.appexec([w_socket, space.wrap(host), space.wrap(port)],
"(_socket, host, port): return _socket.getnameinfo((host, port), 0)")
assert space.unwrap(w_l) == info
def canonicalize_dns(inhost, family=socket.AF_UNSPEC):
"Canonicalize a hostname or numeric IP address."
resname = canonicalization_cache.get(inhost)
if resname is not None:
return resname
# Catch garbaged hostnames in corrupted Mode 6 responses
m = re.match("([:.[\]]|\w)*", inhost)
if not m:
raise TypeError
(hostname, portsuffix) = portsplit(inhost)
try:
ai = socket.getaddrinfo(hostname, None, family, 0, 0,
socket.AI_CANONNAME)
except socket.gaierror:
return "DNSFAIL:%s" % hostname
(family, socktype, proto, canonname, sockaddr) = ai[0]
try:
name = socket.getnameinfo(sockaddr, socket.NI_NAMEREQD)
result = name[0].lower() + portsuffix
except socket.gaierror:
# On OS X, canonname is empty for hosts without rDNS.
# Fall back to the hostname.
canonicalized = canonname or hostname
result = canonicalized.lower() + portsuffix
canonicalization_cache.set(inhost, result)
return result
async def test_getnameinfo():
# Trivial test:
ni_numeric = stdlib_socket.NI_NUMERICHOST | stdlib_socket.NI_NUMERICSERV
with assert_checkpoints():
got = await tsocket.getnameinfo(("127.0.0.1", 1234), ni_numeric)
assert got == ("127.0.0.1", "1234")
# getnameinfo requires a numeric address as input:
with assert_checkpoints():
with pytest.raises(tsocket.gaierror):
await tsocket.getnameinfo(("google.com", 80), 0)
with assert_checkpoints():
with pytest.raises(tsocket.gaierror):
await tsocket.getnameinfo(("localhost", 80), 0)
# Blocking call to get expected values:
host, service = stdlib_socket.getnameinfo(("127.0.0.1", 80), 0)
# Some working calls:
got = await tsocket.getnameinfo(("127.0.0.1", 80), 0)
assert got == (host, service)
got = await tsocket.getnameinfo(("127.0.0.1", 80), tsocket.NI_NUMERICHOST)
assert got == ("127.0.0.1", service)
got = await tsocket.getnameinfo(("127.0.0.1", 80), tsocket.NI_NUMERICSERV)
assert got == (host, "80")
def match_options(self, client_addr, cert_principals, cert_subject=None):
"""Match "from", "principals" and "subject" options in entry"""
from_patterns = self.options.get('from')
if from_patterns:
client_host, _ = socket.getnameinfo((client_addr, 0),
socket.NI_NUMERICSERV)
client_ip = ip_address(client_addr)
if not all(
pattern.matches(client_host, client_addr, client_ip)
for pattern in from_patterns):
return False
principal_patterns = self.options.get('principals')
if cert_principals is not None and principal_patterns is not None:
if not all(
any(
pattern.matches(principal)
for principal in cert_principals)
for pattern in principal_patterns):
return False
subject_patterns = self.options.get('subject')
if cert_subject is not None and subject_patterns is not None:
if not all(
pattern.matches(cert_subject)
for pattern in subject_patterns):
return False
return True
def validate(self, key, client_addr, cert_principals=None, ca=False):
"""Return whether a public key or CA is valid for authentication"""
for entry in self._ca_entries if ca else self._user_entries:
if entry.key != key:
continue
from_patterns = entry.options.get('from')
if from_patterns is not None:
client_host, _ = socket.getnameinfo((client_addr, 0),
socket.NI_NUMERICSERV)
client_ip = ip_address(client_addr)
if not all(
pattern.matches(client_host, client_addr, client_ip)
for pattern in from_patterns):
continue
principal_patterns = entry.options.get('principals')
if cert_principals is not None and principal_patterns is not None:
if not all(
any(
pattern.matches(principal)
for principal in cert_principals)
for pattern in principal_patterns):
continue
return entry.options
return None
def findFreePort(interface="127.0.0.1",
family=socket.AF_INET,
type=socket.SOCK_STREAM):
"""
Ask the platform to allocate a free port on the specified interface, then
release the socket and return the address which was allocated.
@param interface: The local address to try to bind the port on.
@type interface: C{str}
@param type: The socket type which will use the resulting port.
@return: A two-tuple of address and port, like that returned by
L{socket.getsockname}.
"""
addr = socket.getaddrinfo(interface, 0)[0][4]
probe = socket.socket(family, type)
try:
probe.bind(addr)
if family == socket.AF_INET6:
sockname = probe.getsockname()
hostname = socket.getnameinfo(
sockname, socket.NI_NUMERICHOST | socket.NI_NUMERICSERV)[0]
return (hostname, sockname[1])
else:
return probe.getsockname()
finally:
probe.close()
async def resolve(
self, hostname: str, port: int = 0, family: int = socket.AF_INET
) -> List[Dict[str, Any]]:
infos = await self._loop.getaddrinfo(
hostname,
port,
type=socket.SOCK_STREAM,
family=family,
flags=socket.AI_ADDRCONFIG,
)
hosts = []
for family, _, proto, _, address in infos:
if family == socket.AF_INET6 and address[3]: # type: ignore
# This is essential for link-local IPv6 addresses.
# LL IPv6 is a VERY rare case. Strictly speaking, we should use
# getnameinfo() unconditionally, but performance makes sense.
host, _port = socket.getnameinfo(
address, socket.NI_NUMERICHOST | socket.NI_NUMERICSERV
)
port = int(_port)
else:
host, port = address[:2]
hosts.append(
{
"hostname": hostname,
"host": host,
"port": port,
"family": family,
"proto": proto,
"flags": socket.AI_NUMERICHOST | socket.AI_NUMERICSERV,
}
)
return hosts
def getFrame(self, num_pixels):
num_bytes = num_pixels * self.FRAME_PIXEL_SIZE + self.FRAME_HEADER_SIZE
logging.debug("Emptying socking before RX")
self.__empty_socket()
try:
logging.debug("Waiting for new packet")
data, addr = self.sock.recvfrom(num_bytes)
try:
addr = socket.getnameinfo(addr, 0)
except socket.gaierror:
logging.warn("Error during hostname lookup for %s" % addr[0])
(ident, height, width, length) = struct.unpack("HHHH", data[0:8])
if(ident != self.FRAME_IDENT):
raise FrameException("Wrong frame ident received (got 0x%x)" % ident)
pixels = bytearray(data[8:])
if(length != len(pixels)):
raise FrameException("Header says %i pixel bytes, but got %i" % (length, len(pixels)))
if(length != num_pixels * self.FRAME_PIXEL_SIZE):
raise FrameException("Not enough data in the packet to make a frame")
packet = {
"addr": addr,
"frame": (height, width, pixels)
}
return packet
except socket.timeout:
raise NoDataException(socket.timeout)
def test_getnameinfo():
host = "127.0.0.1"
port = 25
info = socket.getnameinfo((host, port), 0)
w_l = space.appexec([w_socket, space.wrap(host), space.wrap(port)],
"(_socket, host, port): return _socket.getnameinfo((host, port), 0)")
assert space.unwrap(w_l) == info
async def habla(self, ctx, called=False):
try:
channel = ctx.message.author.voice.channel
voice = get(self.bot.voice_clients, guild=ctx.guild)
if voice and voice.is_connected():
await voice.move_to(channel)
else:
voice = await channel.connect()
await voice.disconnect()
voice = await channel.connect()
if called:
return voice, channel
else:
voice.play(discord.FFmpegPCMAudio('voice/kyaa.mp3'),
after=lambda e: print('ahh~'))
voice.source = discord.PCMVolumeTransformer(voice.source)
voice.source.volume = 0.2
except socket.gaierror():
print(socket.getaddrinfo())
print(socket.getnameinfo(socket.getaddrinfo()))
socket.close()
def getHostnameFqdn():
"""
Wrapper around getfqdn.
Returns the fully qualified hostname, None if not found.
"""
try:
sHostname = socket.getfqdn();
except:
return None;
if '.' in sHostname or sHostname.startswith('localhost'):
return sHostname;
#
# Somewhat misconfigured system, needs expensive approach to guessing FQDN.
# Get address information on the hostname and do a reverse lookup from that.
#
try:
aAddressInfo = socket.getaddrinfo(sHostname, None);
except:
return sHostname;
for aAI in aAddressInfo:
try: sName, _ = socket.getnameinfo(aAI[4], 0);
except: continue;
if '.' in sName and not set(sName).issubset(set('0123456789.')) and not sName.startswith('localhost'):
return sName;
return sHostname;
def getHostnameFqdn():
"""
Wrapper around getfqdn.
Returns the fully qualified hostname, None if not found.
"""
try:
sHostname = socket.getfqdn()
except:
return None
if '.' in sHostname or sHostname.startswith('localhost'):
return sHostname
#
# Somewhat misconfigured system, needs expensive approach to guessing FQDN.
# Get address information on the hostname and do a reverse lookup from that.
#
try:
aAddressInfo = socket.getaddrinfo(sHostname, None)
except:
return sHostname
for aAI in aAddressInfo:
try:
sName, _ = socket.getnameinfo(aAI[4], 0)
except:
continue
if '.' in sName and not set(sName).issubset(
set('0123456789.')) and not sName.startswith('localhost'):
return sName
return sHostname
def mac_to_ipv6(prefix, mac):
mp = mac.split(":")
inv_a = int(mp[0], 16) ^ 2
addr = "{0}{1:02x}{2:02x}:{3:02x}ff:fe{4:02x}:{5:02x}{6:02x}" \
.format(prefix, inv_a, int(mp[1], 16), int(mp[2], 16),
int(mp[3], 16), int(mp[4], 16), int(mp[5], 16))
name = socket.getnameinfo((addr, 22), socket.NI_NUMERICSERV | socket.NI_NUMERICHOST)
return name[0]
def _resolve_ip(self, ip):
try:
result = socket.getnameinfo((ip, 0), 0)[0]
if result == ip:
return NO_DATA
return result
except socket.gaierror:
return NO_DATA
def getpeernameinfo(self):
"""Returns (remote, port, family) tuple
"""
(addr, port) = socket.getnameinfo(
self.socket.getpeername(),
socket.NI_NUMERICHOST | socket.NI_NUMERICSERV)
return (addr, port, self.socket.family)
def mac_to_ipv6(prefix, mac):
mp = mac.split(":")
inv_a = int(mp[0], 16) ^ 2
addr = "%s%02x%02x:%02xff:fe%02x:%02x%02x" % \
(prefix, inv_a, int(mp[1], 16), int(mp[2], 16),
int(mp[3], 16), int(mp[4], 16), int(mp[5], 16))
name = socket.getnameinfo((addr, 22), socket.NI_NUMERICSERV|socket.NI_NUMERICHOST)
return name[0]
def mac_to_ipv6(prefix, mac):
mp = mac.split(":")
inv_a = int(mp[0], 16) ^ 2
addr = "{0}{1:02x}{2:02x}:{3:02x}ff:fe{4:02x}:{5:02x}{6:02x}" \
.format(prefix, inv_a, int(mp[1], 16), int(mp[2], 16),
int(mp[3], 16), int(mp[4], 16), int(mp[5], 16))
name = socket.getnameinfo((addr, 22),
socket.NI_NUMERICSERV | socket.NI_NUMERICHOST)
return name[0]
def find_jobs(self, constraint = 'True', attributes = []):
"""
Return ClassAds for jobs matching the constraints.
"""
if len(self._schedds) == 0:
LOG.info('Finding schedds reporting to collector %s', self._collector_name)
attempt = 0
while True:
try:
schedd_ads = self._collector.query(htcondor.AdTypes.Schedd, self._schedd_constraint, ['MyAddress', 'ScheddIpAddr'])
break
except IOError:
attempt += 1
LOG.warning('Collector query failed: %s', str(sys.exc_info()[0]))
if attempt == 10:
LOG.error('Communication with the collector failed. We have no information of the condor pool.')
return
LOG.debug('%d schedd ads', len(schedd_ads))
for ad in schedd_ads:
LOG.debug(ad)
schedd = htcondor.Schedd(ad)
matches = re.match('<([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+):([0-9]+)', ad['MyAddress'])
# schedd does not have an ipaddr attribute natively, but we can assign it
schedd.ipaddr = matches.group(1)
schedd.host = socket.getnameinfo((matches.group(1), int(matches.group(2))), socket.AF_INET)[0] # socket.getnameinfo(*, AF_INET) returns a (host, port) 2-tuple
self._schedds.append(schedd)
LOG.debug('Found schedds: %s', ', '.join(['%s (%s)' % (schedd.host, schedd.ipaddr) for schedd in self._schedds]))
LOG.debug('Querying HTCondor with constraint "%s" for attributes %s', constraint, str(attributes))
classads = []
for schedd in self._schedds:
attempt = 0
while True:
try:
ads = schedd.query(constraint, attributes)
break
except IOError:
attempt += 1
LOG.warning('IOError in communicating with schedd %s. Trying again.', schedd.ipaddr)
if attempt == 10:
LOG.error('Schedd %s did not respond.', schedd.ipaddr)
ads = []
break
classads.extend(ads)
LOG.info('HTCondor returned %d classads', len(classads))
return classads
def event_v6(cpu, data, size):
event = ct.cast(data, ct.POINTER(Info_ipv6)).contents
addr = str(inet_ntop(AF_INET6, event.daddr))
hostname, info = socket.getnameinfo((addr, 0), 0)
host = socket.getfqdn(hostname)
print('{:<5d} {:<15s} {:<37s} {:<24s} {:<5d} {:<5d} {:<12f}'.format(
event.pid, event.comm.decode(), inet_ntop(AF_INET6, event.saddr), host,
event.dport, event.sport,
float(event.delta_us) / 1000))
def hostname2(self, ipAddress):
try:
# slow!
ret = socket.getnameinfo((ipAddress, 1), socket.NI_NAMEREQD)[0]
if ret == 'unknown':
return ipAddress
return ret
except socket.gaierror:
return ipAddress
def RetrieveIP4Info(self, ip):
"""Retrieves information for an IP4 address."""
if ip.is_private:
return (IPInfo.INTERNAL, "Internal IP address.")
try:
# It's an external IP, let's try to do a reverse lookup.
res = socket.getnameinfo((str(ip), 0), socket.NI_NAMEREQD)
return (IPInfo.EXTERNAL, res[0])
except (socket.error, socket.herror, socket.gaierror):
return (IPInfo.EXTERNAL, "Unknown IP address.")
def test_getnameinfo():
'''
Tests socket.getnameinfo()
'''
#sanity
socket.getnameinfo(("127.0.0.1", 80), 8)
socket.getnameinfo(("127.0.0.1", 80), 9)
host, service = socket.getnameinfo( ("127.0.0.1", 80), 8)
AreEqual(service, '80')
if is_cli:
AssertError(NotImplementedError, socket.getnameinfo, ("127.0.0.1", 80), 0)
#IP gives a TypeError
#AssertError(SystemError, socket.getnameinfo, ("127.0.0.1"), 8)
#AssertError(SystemError, socket.getnameinfo, (321), 8)
AssertError(TypeError, socket.getnameinfo, ("127.0.0.1"), '0')
AssertError(TypeError, socket.getnameinfo, ("127.0.0.1", 80, 0, 0, 0), 8)
AssertError(socket.gaierror, socket.getnameinfo, ('no such host will ever exist', 80), 8)
def scan_range(self, start_ip, end_ip):
if self.solr_instance is None:
self.solr_instance = searchengine.solr_tools.get_solr_instance('working', url_offset = 0)
for i in range(start_ip, end_ip):
try:
ipv4_address = IPv4Address(i).exploded
hostname_info = socket.getnameinfo((ipv4_address, 0), socket.NI_NAMEREQD)
log("[SCNR #{:02}] PTR record: {}".format(self.scanner_id, hostname_info[0]))
self.__probe_http(hostname_info[0])
except socket.error as e:
log_exception(e.args)
log_exception("not found ({})".format(ipv4_address))
def main():
serverport = 12000
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
serverSocket.bind(('', serverport))
print "The server is ready to receive"
while 1:
message, clientAddress = serverSocket.recvfrom(2048)
print("Got the message %s from %s" %(message, clientAddress))
host, port = socket.getnameinfo(clientAddress, socket.AF_INET)
print ("Host, port pair: %s, %s" % (host, port))
serverSocket.close()
pass
def ip6tos(in_):
addr=in_.contents.sin6_addr._S6_un._S6_u16
vals=[]
for x in range(0,8):
vals.append(sk.ntohs(addr[x]))
host= ("%x:%x:%x:%x:%x:%x:%x:%x" % tuple(vals))
port=0
flowinfo=in_.contents.sin6_flowinfo
scopeid=in_.contents.sin6_scope_id
flags=sk.NI_NUMERICHOST | sk.NI_NUMERICSERV
retAddr,retPort=sk.getnameinfo((host, port, flowinfo, scopeid), flags)
return retAddr
def socket(self, s):
"""Adds the following fields:
:ip_addr: numeric IP address
:port: port number
:host: peer hostname, as returned by :func:`getnameinfo`
:service: the human readable name of the service on ``port``
:arg socket s: the socket to extract information from
"""
ip_addr, port = s.getpeername()
host, service = _socket.getnameinfo((ip_addr, port), 0)
return self.fields(ip_addr=ip_addr, port=port, host=host, service=service)
def do_CONNECT(self):
self.last_request = "{0} {1} {2}".format(self.command, self.path, self.request_version)
try:
backconn = self.server.pool.create(self.path)
backconn.connect()
self.send_response(200)
except:
self.send_response(503)
return
finally:
self.end_headers()
self.last_send_time = datetime.datetime.now()
def pump(source, dest):
logger = logging.getLogger("{0}.{1}".format(self.logger.name, threading.current_thread().name))
try:
while True:
data = source.read(8192)
logger.debug("pumping {0} bytes".format(len(data)))
if len(data) == 0:
raise socket.error("connection closed")
dest.write(data)
self.last_send_time = datetime.datetime.now()
except Exception as e:
logger.debug("{0}. closing both sides.".format(e))
dest._sock.close()
source._sock.close()
client_addr = "{0}:{1}".format(*socket.getnameinfo(self.request.getpeername(), socket.NI_NUMERICSERV))
server_addr = "{0}:{1}".format(*socket.getnameinfo(backconn.sock.getpeername(), socket.NI_NUMERICSERV))
self.logger.debug("pumping between {0} and {1}".format(client_addr, server_addr))
pump_threads = [
threading.Thread(target=pump, args=(backconn.sock.makefile("rb", 0), self.wfile), name="s2c"),
threading.Thread(target=pump, args=(self.rfile, backconn.sock.makefile("wb", 0)), name="c2s"),
]
# pump data until the end
list(map(threading.Thread.start, pump_threads))
list(map(threading.Thread.join, pump_threads))
def test_network(times=10):
from socket import socket, gaierror, NI_NUMERICSERV, getnameinfo
from time import sleep
for i in range(times):
try:
print(getnameinfo(socket().getsockname(), NI_NUMERICSERV))
print("Network Online, continuing")
break
except gaierror:
print("Network not available... Trying again (%s of %s)" % (i, times))
sleep(1)
def reverse(addr):
"""
Resolve an IPv4 or IPv6 address to a hostname.
:param addr:
The address to lookup!
"""
port = 0 # Hard-code for now
flags = 0 # Just use the default
try:
info = socket.getnameinfo((addr, port), flags)
except socket.gaierror:
return addr
else:
host, port = info
return host
