def setup_sockets(self):
self.sockets = {}
ip_addresses = get_interface_addresses(self.logger)
self.ip_addresses = ip_addresses
multi_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
multi_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
multi_sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, self.ttl)
for ip in ip_addresses:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
mreq=socket.inet_aton(self.address)+socket.inet_aton(ip)
multi_sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
self.logger.info("Regestering multicast for: %s: %s"%(self.address, ip))
sock.bind((ip, self.port))
self.sockets[ip] = sock
multi_sock.bind(("", self.port))
self.socks = [self.sockets[x] for x in self.sockets.keys()]
self.multi_sock = multi_sock
python类IPPROTO_IP的实例源码
def __init__(self, group_addr, port):
bind_addr = '0.0.0.0'
# Create a IPv4/UDP socket
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Avoid error 'Address already in use'.
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Construct a membership_request
membership_request = socket.inet_aton(group_addr) + socket.inet_aton(bind_addr)
# Send add membership request to socket
self.sock.setsockopt(socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP, membership_request)
# Bind the socket to an interfaces
self.sock.bind((bind_addr, port))
# Set non-blocking receiving mode
self.sock.setblocking(False)
self.publisher = rospy.Publisher('/raw_referee', std_msgs.msg.String, queue_size=10)
def __init__(self, playerCount):
"""
Initialisierung eines GameLogic
Parameter: int die maximale Spieleranzahl
Rückgabewerte: -
"""
threading.Thread.__init__(self)
self.deamon = True
self.queue = Queue.Queue(0)
self.playerCount = playerCount
self.playerConnectedCount = 0
self.players = []
self.weaponPositions = []
self.possibleWeaponPositions = ["140_110", "490_110", "420_300", "220_300", "060_300", "600_300", "420_550", "220_550", "090_490", "550_480", "600_170", "600_040", "350_050", "290_040", "050_180"]
self.playerPositions = []
self.game = game.Game(self)
self.MCAST_GRP = '224.1.1.1'
self.MCAST_PORT = 5000
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
def _socketpair_compat():
"""TCP/IP socketpair including Windows support"""
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listensock.bind(("127.0.0.1", 0))
listensock.listen(1)
iface, port = listensock.getsockname()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock1.setblocking(0)
try:
sock1.connect(("localhost", port))
except socket.error as err:
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
raise
sock2, address = listensock.accept()
sock2.setblocking(0)
listensock.close()
return (sock1, sock2)
def bind(self, addr, port, tos, ttl, df):
log.debug(
"bind(addr=%s, port=%d, tos=%d, ttl=%d)", addr, port, tos, ttl)
self.socket = socket.socket(
socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_TOS, tos)
self.socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind((addr, port))
if df:
if (sys.platform == "linux2"):
self.socket.setsockopt(socket.SOL_IP, 10, 2)
elif (sys.platform == "win32"):
self.socket.setsockopt(socket.SOL_IP, 14, 1)
elif (sys.platform == "darwin"):
log.error("do-not-fragment can not be set on darwin")
else:
log.error("unsupported OS, ignore do-not-fragment option")
else:
if (sys.platform == "linux2"):
self.socket.setsockopt(socket.SOL_IP, 10, 0)
def __init__(self, group_addr, port):
bind_addr = '0.0.0.0'
# Create a IPv4/UDP socket
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Avoid error 'Address already in use'.
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Construct a membership_request
membership_request = socket.inet_aton(group_addr) + socket.inet_aton(bind_addr)
# Send add membership request to socket
self.sock.setsockopt(socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP, membership_request)
# Bind the socket to an interfaces
self.sock.bind((bind_addr, port))
# Set non-blocking receiving mode
self.sock.setblocking(False)
self.publisher = rospy.Publisher('/raw_vision', std_msgs.msg.String, queue_size=10)
def _socketpair_compat():
"""TCP/IP socketpair including Windows support"""
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listensock.bind(("127.0.0.1", 0))
listensock.listen(1)
iface, port = listensock.getsockname()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock1.setblocking(0)
try:
sock1.connect(("127.0.0.1", port))
except socket.error as err:
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
raise
sock2, address = listensock.accept()
sock2.setblocking(0)
listensock.close()
return (sock1, sock2)
def _socketpair_compat():
"""TCP/IP socketpair including Windows support"""
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listensock.bind(("127.0.0.1", 0))
listensock.listen(1)
iface, port = listensock.getsockname()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock1.setblocking(0)
try:
sock1.connect(("127.0.0.1", port))
except socket.error as err:
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
raise
sock2, address = listensock.accept()
sock2.setblocking(0)
listensock.close()
return (sock1, sock2)
def init_func(self, creator_fd):
self.__creator_fd = creator_fd
self.__sent = []
family = socket.AF_INET
s = socket.socket(family, socket.SOCK_RAW,
socket.IPPROTO_UDP | socket.IPPROTO_ICMP | socket.IPPROTO_UDP | 136)
s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
s.setblocking(0)
self.__socket = s
self.set_fileno(s.fileno())
self.register(self.fileno)
self.add_evt_read(self.fileno)
return self.fileno
def test_unplugged(self, mock_ioctl, mock_unpack):
"""
The link speed for an unplugged interface is reported as 0.
"""
sock = socket.socket(
socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_IP)
# ioctl always succeeds
mock_unpack.return_value = (65535, False)
result = get_network_interface_speed(sock, b"eth0")
mock_ioctl.assert_called_with(ANY, ANY, ANY)
mock_unpack.assert_called_with("12xHB28x", ANY)
self.assertEqual((0, False), result)
def test_get_network_interface_speed_not_supported(self, mock_ioctl):
"""
Some drivers do not report the needed interface speed. In this case
an C{IOError} with errno 95 is raised ("Operation not supported").
If such an error is rasied, report the speed as -1.
"""
sock = socket.socket(
socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_IP)
theerror = IOError()
theerror.errno = 95
theerror.message = "Operation not supported"
# ioctl always raises
mock_ioctl.side_effect = theerror
result = get_network_interface_speed(sock, b"eth0")
mock_ioctl.assert_called_with(ANY, ANY, ANY)
self.assertEqual((-1, False), result)
def test_get_network_interface_speed_not_permitted(self, mock_ioctl):
"""
In some cases (lucid seems to be affected), the ioctl() call is not
allowed for non-root users. In that case we intercept the error and
not report the network speed.
"""
sock = socket.socket(
socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_IP)
theerror = IOError()
theerror.errno = 1
theerror.message = "Operation not permitted"
# ioctl always raises
mock_ioctl.side_effect = theerror
result = get_network_interface_speed(sock, b"eth0")
mock_ioctl.assert_called_with(ANY, ANY, ANY)
self.assertEqual((-1, False), result)
def get_fqdn():
"""
Return the current fqdn of the machine, trying hard to return a meaningful
name.
In particular, it means working against a NetworkManager bug which seems to
make C{getfqdn} return localhost6.localdomain6 for machine without a domain
since Maverick.
"""
fqdn = socket.getfqdn()
if "localhost" in fqdn:
# Try the heavy artillery
fqdn = socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET,
socket.SOCK_DGRAM, socket.IPPROTO_IP,
socket.AI_CANONNAME)[0][3]
if "localhost" in fqdn:
# Another fallback
fqdn = socket.gethostname()
return fqdn
def _create_mcast_socket(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if self._interface != 'any':
if platform.system() != "Windows":
sock.bind((self.MULTICAST_ADDRESS, self.MULTICAST_PORT))
else:
sock.bind((self._interface, self.MULTICAST_PORT))
mreq = socket.inet_aton(self.MULTICAST_ADDRESS) + socket.inet_aton(self._interface)
else:
sock.bind((self.MULTICAST_ADDRESS, self.MULTICAST_PORT))
mreq = struct.pack("4sl", socket.inet_aton(self.MULTICAST_ADDRESS), socket.INADDR_ANY)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
return sock
def sender(group):
addrinfo = socket.getaddrinfo(group, None)[0]
s = socket.socket(addrinfo[0], socket.SOCK_DGRAM)
# Set Time-to-live (optional)
ttl_bin = struct.pack('@i', MYTTL)
if addrinfo[0] == socket.AF_INET: # IPv4
s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, ttl_bin)
else:
s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_HOPS, ttl_bin)
while True:
data = repr(time.time())
s.sendto(data + '\0', (addrinfo[4][0], MYPORT))
time.sleep(1)
def connection_made(self, transport):
""" Protocol connection made """
if self._verbose:
print('Connection made')
self._transport = transport
sock = self._transport.get_extra_info('socket')
# sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.settimeout(2)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
sock.bind(('', self._upnp.ssdp_port))
tmpl = ('M-SEARCH * HTTP/1.1',
'Host: ' + self._upnp.ssdp_host + ':' + str(self._upnp.ssdp_port),
'Man: "ssdp:discover"',
'ST: {}'.format(self._search_target),
# 'ST: ssdp:all',
'MX: 3',
'', '')
msg = "\r\n".join(tmpl).encode('ascii')
self._transport.sendto(msg, (self._upnp.ssdp_host, self._upnp.ssdp_port))
def __init__(self, hostID, logFile,sharedBufferArray):
threading.Thread.__init__(self)
self.threadCmdLock = threading.Lock()
self.threadCallbackQueue = {}
self.threadCallbackLock = threading.Lock()
self.nPendingCallbacks = 0
self.threadCmdQueue = []
self.hostID = hostID
self.sharedBufferArray = sharedBufferArray
self.log = logger.Logger(logFile, "Host " + str(hostID) + " IPC Thread")
self.hostIDtoPowerSimID = None
self.powerSimIDtohostID = None
self.attackLayer = None
self.raw_sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
self.init_shared_ipc_buffer()
# self.raw_sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
def setEventCast(self, mcast='224.56.56.56', port=45654, bind='0.0.0.0'):
'''
Tie this CobraEventCore to any others which share the same multicast
ip and port. This basically creates a ( udp "unreliable" ) "bus" on
which events are serialized using json.
'''
# Setup a UDP casting socket
self._ce_mcastport = port
self._ce_mcasthost = mcast
self._ce_ecastsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self._ce_ecastsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._ce_ecastsock.bind((bind,port))
# Join the multicast IP
mreq = struct.pack("4sL", socket.inet_aton(mcast), socket.INADDR_ANY)
self._ce_ecastsock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
thr = threading.Thread(target=self._runSocketListener)
thr.setDaemon(True)
thr.start()
def _socketpair_compat():
"""TCP/IP socketpair including Windows support"""
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listensock.bind(("127.0.0.1", 0))
listensock.listen(1)
iface, port = listensock.getsockname()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock1.setblocking(0)
try:
sock1.connect(("127.0.0.1", port))
except socket.error as err:
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
raise
sock2, address = listensock.accept()
sock2.setblocking(0)
listensock.close()
return (sock1, sock2)
def run(self):
try:
PLUGIN.broadcasterLogger.debug("Broadcaster.run called")
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 20)
start_time = time.time()
end_time = start_time + (PLUGIN.globals['alexaHueBridge'][self.ahbDevId]['discoveryExpiration'] * 60)
PLUGIN.broadcasterLogger.debug("Broadcaster.run: sending first broadcast:\n{}".format(self.broadcast_packet))
while True:
sock.sendto(self.broadcast_packet, (BCAST_IP, UPNP_PORT))
for x in range(BROADCAST_INTERVAL):
time.sleep(1)
# Following code will only time out the Broadcaster Thread if PLUGIN.globals['alexaHueBridge'][self.ahbDevId]['discoveryExpiration'] > 0 (valid values 0 thru 10 inclusive)
# A value of zero means 'always on'
if PLUGIN.globals['alexaHueBridge'][self.ahbDevId]['discoveryExpiration'] and time.time() > end_time:
PLUGIN.broadcasterLogger.debug("Broadcaster thread timed out")
self.stop()
if self.interrupted:
PLUGIN.setDeviceDiscoveryState(False, self.ahbDevId)
sock.close()
return
except StandardError, e:
PLUGIN.broadcasterLogger.error(u"StandardError detected in Broadcaster.Run for '{}'. Line '{}' has error='{}'".format(indigo.devices[self.ahbDevId].name, sys.exc_traceback.tb_lineno, e))
def _socketpair_compat():
"""TCP/IP socketpair including Windows support"""
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listensock.bind(("127.0.0.1", 0))
listensock.listen(1)
iface, port = listensock.getsockname()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock1.setblocking(0)
try:
sock1.connect(("127.0.0.1", port))
except socket.error as err:
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
raise
sock2, address = listensock.accept()
sock2.setblocking(0)
listensock.close()
return (sock1, sock2)
def __init__(self, server_address):
self.server_address = server_address
self.logger = logging.getLogger('VisionReceiver')
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.bind(server_address)
if ip_address(server_address[0]).is_multicast:
self.socket.setsockopt(socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP,
struct.pack("=4sl", socket.inet_aton(server_address[0]), socket.INADDR_ANY))
self.field = Field()
self._detection_frame_queue = queue.Queue()
self._thread = threading.Thread(target=self.receive_packet, daemon=True)
def create_sockets(mcst_ipaddr, mcst_port):
mreq = struct.pack("4sl", socket.inet_aton(mcst_ipaddr),
socket.INADDR_ANY)
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
if platform.system() == "Windows":
s.bind(("", mcst_port))
return (s, )
else:
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
s.bind((mcst_ipaddr, mcst_port))
bsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
bsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
bsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
bsock.bind(("", 1901))
return (s, bsock)
def setup_ipv4_multicast_socket(ifaddrs, if_name, addr):
#todo: if_name ignored
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(("", Config.udp_multicast.port))
s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, Config.udp_multicast.ttl)
s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 0)
mreq = struct.pack("4sl", socket.inet_aton(addr), socket.INADDR_ANY)
s.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
s.setblocking(0)
multicast_socket_ipv4.append((s,addr))
return True
def _socketpair_compat():
"""TCP/IP socketpair including Windows support"""
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listensock.bind(("127.0.0.1", 0))
listensock.listen(1)
iface, port = listensock.getsockname()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock1.setblocking(0)
try:
sock1.connect(("127.0.0.1", port))
except socket.error as err:
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
raise
sock2, address = listensock.accept()
sock2.setblocking(0)
listensock.close()
return (sock1, sock2)
def _socketpair_compat():
"""TCP/IP socketpair including Windows support"""
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listensock.bind(("127.0.0.1", 0))
listensock.listen(1)
iface, port = listensock.getsockname()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock1.setblocking(0)
try:
sock1.connect(("127.0.0.1", port))
except socket.error as err:
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
raise
sock2, address = listensock.accept()
sock2.setblocking(0)
listensock.close()
return (sock1, sock2)
def runAttack(self, targetList):
# targetList = [{'ipaddress:':'127.0.0.1', 'port':53, 'payload':'blablabla']
for counter in range(0, self.replayCount):
for port in self.bindPorts:
requestPool = Pool(processes=self.maxProcesses)
sharedSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sharedSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sharedSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
#sharedSocket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 64)
try:
sharedSocket.bind(('', port))
print("Sending packets from port %s" % port)
taskList = [(sharedSocket, targetParams.get('ipaddress'), targetParams.get('port'), targetParams.get('payload')) for targetParams in targetList]
results = requestPool.starmap(asyncSendPayload, taskList)
except Exception as e:
print("Failed binding port %s: %s" % (port, e))
print("Closing process pool")
requestPool.close()
print("Joining process pool")
requestPool.join()
print("Closing shared socket")
sharedSocket.close()
return True
def _socketpair_compat():
"""TCP/IP socketpair including Windows support"""
listensock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listensock.bind(("127.0.0.1", 0))
listensock.listen(1)
iface, port = listensock.getsockname()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_IP)
sock1.setblocking(0)
try:
sock1.connect(("localhost", port))
except socket.error as err:
if err.errno != errno.EINPROGRESS and err.errno != errno.EWOULDBLOCK and err.errno != EAGAIN:
raise
sock2, address = listensock.accept()
sock2.setblocking(0)
listensock.close()
return (sock1, sock2)
def _decode(self):
try:
ip = IPHeader(self.ip_frame)
self.layer[socket.IPPROTO_IP] = ip
payload_start = ip.header_length * 4
if ip.protocol == socket.IPPROTO_TCP:
tcp = TCPHeader(self.ip_frame, ip.header_length * 4)
self.layer[socket.IPPROTO_TCP] = tcp
payload_start += tcp.data_offset * 4
else:
print("Unsupported IP protocol: %s" % ip.protocol)
except Exception as e:
raise ValueError("Failed to decode packet: %s" % e)
def discover(self):
service = "ssdp:all"
group = ("239.255.255.250", 1900)
message = "\r\n".join([
'M-SEARCH * HTTP/1.1',
'HOST: {0}:{1}',
'MAN: "ssdp:discover"',
'ST: {st}','MX: 3','',''])
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.settimeout(5)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
sock.sendto(message.format(*group, st=service), group)
while True:
try:
response = SSDPResponse(sock.recv(1024))
if response.type == SSDPResponse.ST_ROOT_DEVICE:
pass
elif response.type == SSDPResponse.ST_DEVICE:
device = Device.fromSSDPResponse(response)
self.devices[response.uuid] = device
except socket.timeout:
break
self.__discoveryDone()
