def _setup_connection(self, dstaddr, timeout=None):
port = randint(10000, 60000)
af, socktype, proto, _canonname, _sa = socket.getaddrinfo(dstaddr, port, socket.AF_INET, socket.SOCK_DGRAM)[0]
s = socket.socket(af, socktype, proto)
has_bind = 1
for _i in range(0, 10):
# We try to bind to a port for 10 tries
try:
s.bind((INADDR_ANY, randint(10000, 60000)))
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
has_bind = 1
except socket.error:
pass
if not has_bind:
raise NetBIOSError, ('Cannot bind to a good UDP port', ERRCLASS_OS, errno.EAGAIN)
self.__sock = s
python类SO_BROADCAST的实例源码
def __init__(self, port, callback, bindaddress=''):
asyncore.dispatcher.__init__(self)
# self.lock = threading.RLock()
self.MAX_MTU = 1500
self.callback = None
self.port = port
if callback is not None and isinstance(callback, IUdpCallback):
self.callback = callback
else:
raise Exception('callback is None or not an instance of IUdpCallback class')
try:
self.create_socket(socket.AF_INET, socket.SOCK_DGRAM)
self.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
# self.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.set_reuse_addr()
self.bind((bindaddress, port))
except Exception as e:
print e
traceback.print_exc()
self.send_queue = Queue.Queue() # thread-safe queue
AsyncController.instance().add(self)
if self.callback is not None:
self.callback.on_started(self)
# Even though UDP is connectionless this is called when it binds to a port
def __init__(self,HOST=None,PORT='9999',DEBUG_FLAG=True):
#-----------------------------------------------------------------------------
# Name: init fuction
# param: HOST:host name PORT:PORT
# explain: initialize the myudp class
# Author: gongke
#
# Created: 2013/01/15
#-----------------------------------------------------------------------------
self.host = HOST
self.port = string.atoi(PORT)
if string.atoi(DEBUG_FLAG)==1:
self.debugflag = True
else:
self.debugflag = False
#self.debugflag = DEBUG_FLAG
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.sock.settimeout(20)
def discover_peers(self, port=None):
"""This method can be invoked (periodically?) to broadcast message to
discover peers, if there is a chance initial broadcast message may be
lost (as these messages are sent over UDP).
"""
ping_msg = {'signature': self._signature, 'name': self._name, 'version': __version__}
def _discover(addrinfo, port, task=None):
ping_sock = AsyncSocket(socket.socket(addrinfo.family, socket.SOCK_DGRAM))
ping_sock.settimeout(2)
if addrinfo.family == socket.AF_INET:
ping_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
else: # addrinfo.family == socket.AF_INET6
ping_sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_HOPS,
struct.pack('@i', 1))
ping_sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_IF, addrinfo.ifn)
ping_sock.bind((addrinfo.ip, 0))
if not port:
port = addrinfo.udp_sock.getsockname()[1]
ping_msg['location'] = addrinfo.location
try:
yield ping_sock.sendto('ping:'.encode() + serialize(ping_msg),
(addrinfo.broadcast, port))
except:
pass
ping_sock.close()
for addrinfo in self._addrinfos:
SysTask(_discover, addrinfo, port)
def discover_peers(self, port=None):
"""This method can be invoked (periodically?) to broadcast message to
discover peers, if there is a chance initial broadcast message may be
lost (as these messages are sent over UDP).
"""
ping_msg = {'signature': self._signature, 'name': self._name, 'version': __version__}
def _discover(addrinfo, port, task=None):
ping_sock = AsyncSocket(socket.socket(addrinfo.family, socket.SOCK_DGRAM))
ping_sock.settimeout(2)
if addrinfo.family == socket.AF_INET:
ping_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
else: # addrinfo.family == socket.AF_INET6
ping_sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_HOPS,
struct.pack('@i', 1))
ping_sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_IF, addrinfo.ifn)
ping_sock.bind((addrinfo.ip, 0))
if not port:
port = addrinfo.udp_sock.getsockname()[1]
ping_msg['location'] = addrinfo.location
try:
yield ping_sock.sendto('ping:'.encode() + serialize(ping_msg),
(addrinfo.broadcast, port))
except:
pass
ping_sock.close()
for addrinfo in self._addrinfos:
SysTask(_discover, addrinfo, port)
def _send_magic_packets(task, dest_host, dest_port):
"""Create and send magic packets.
Creates and sends a magic packet for each MAC address registered in
the Node.
:param task: a TaskManager instance containing the node to act on.
:param dest_host: The broadcast to this IP address.
:param dest_port: The destination port.
:raises: WOLOperationError if an error occur when connecting to the
host or sending the magic packets
"""
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
with contextlib.closing(s) as sock:
for port in task.ports:
address = port.address.replace(':', '')
# TODO(lucasagomes): Implement sending the magic packets with
# SecureON password feature. If your NIC is capable of, you can
# set the password of your SecureON using the ethtool utility.
data = 'FFFFFFFFFFFF' + (address * 16)
packet = bytearray.fromhex(data)
try:
sock.sendto(packet, (dest_host, dest_port))
except socket.error as e:
msg = (_("Failed to send Wake-On-Lan magic packets to "
"node %(node)s port %(port)s. Error: %(error)s") %
{'node': task.node.uuid, 'port': port.address,
'error': e})
LOG.exception(msg)
raise exception.WOLOperationError(msg)
# let's not flood the network with broadcast packets
time.sleep(0.5)
def mkcmdsock(ip_address=None, port=0):
"Create a command socket."
ip_address = gethostip() if not ip_address else ip_address
cmdsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
cmdsock.bind((ip_address, port))
cmdsock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
cmdsock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, SOCKET_BUFSIZE)
return cmdsock
def make_data_sender_socket(ip_address=None):
"""Create a socket for sending multicast data."""
ip_address = gethostip() if not ip_address else ip_address
datasock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
datasock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
datasock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
datasock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 20)
# print("Binding source socket to %s" % ip_address)
datasock.bind((ip_address, 0))
return datasock
def listener(db, cursor):
"""
this is the UDP listener, the main loop.
"""
s = socket(AF_INET, SOCK_DGRAM)
s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
try:
s.bind(('', config.N1MM_BROADCAST_PORT))
except:
logging.critical('Error connecting to the UDP stream.')
return
operators = Operators(db, cursor)
stations = Stations(db, cursor)
seen = set()
run = True
while run:
try:
udp_data = s.recv(BROADCAST_BUF_SIZE)
process_message(db, cursor, operators, stations, udp_data, seen)
except KeyboardInterrupt:
logging.info('Keyboard interrupt, shutting down...')
s.close()
run = False
def __init__(self, interface_ip=''):
# Start server to listen for incoming connections
listen_port = 1200
logger.debug('Binding TCP socket to %s:%s', interface_ip, listen_port)
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server.bind((interface_ip, listen_port))
self.server.settimeout(5.0) # Timeout defines time between broadcasts
self.server.listen(5)
# Creating and binding broadcast socket
logger.debug('Binding UDP socket to %s:%s', interface_ip, 0)
self.bc_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.bc_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.bc_sock.bind((interface_ip, 0))
def list_identity(target_ip='255.255.255.255', target_port=44818, udp=True):
sockets = []
responses = []
delay = 1000
header = ENIPEncapsulationHeader(ENIPCommandCode.ListIdentity, 0, 0, 0, delay, 0)
data = header.export_data()
networks = networking.list_networks()
for ifc in networks:
if udp:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((ifc, 0))
s.setblocking(0)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
else:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.sendto(data, (target_ip, target_port))
sockets.append(s)
time.sleep(1.1*delay/1000)
packets = []
for s in sockets:
try:
while True:
packets.append(s.recv(65535))
except BlockingIOError:
pass
for packet in packets:
if len(packet) < 42:
continue
rsp_header = ENIPEncapsulationHeader()
offset = rsp_header.import_data(packet)
li = ListIdentityRsp()
offset += li.import_data(packet, offset)
responses.append(li)
return responses
# this ideally will use asyncio to manage connections
def __init__(self):
util.Thread.__init__(self)
self.cv = threading.Condition()
self.servers = []
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.sock.bind(('', 17935))
self.setDaemon(True)
self.start()
def __init__(self, thisNode):
logging.info('Initializing listener')
self.thisNode = thisNode
self.MCAST_PORT = 4242
self.MCAST_GRP = '192.168.1.255'
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.sock.bind(('', self.MCAST_PORT))
def main():
self.broadcast_port = 8080
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.sock.bind(('', 0))
index = 1
while True:
self.sock.sendto('...' + index, ("<broadcast>", self.broadcast_port))
index += 1
sys.stdout.flush()
def __init__(self, broadcast_port=BROADCAST_PORT):
self.broadcast_port = int(os.environ.get('BROADCAST_PORT', BROADCAST_PORT))
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.sock.bind(('', 0))
def runMaster(address, broadcast, clear, force, path, update_stats, test_break,use_ssl=False,cert_path="",key_path=""):
httpd = createMaster(address, clear, force, path)
httpd.timeout = 1
httpd.stats = update_stats
if use_ssl:
import ssl
httpd.socket = ssl.wrap_socket(
httpd.socket,
certfile=cert_path,
server_side=True,
keyfile=key_path,
ciphers="ALL",
ssl_version=ssl.PROTOCOL_SSLv23,
)
if broadcast:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
start_time = time.time() - 2
while not test_break():
try:
httpd.handle_request()
except select.error:
pass
if time.time() - start_time >= 2: # need constant here
httpd.timeoutSlaves()
httpd.updateUsage()
if broadcast:
print("broadcasting address")
s.sendto(bytes("%i" % address[1], encoding='utf8'), 0, ('<broadcast>', 8000))
start_time = time.time()
httpd.server_close()
if clear:
clearMaster(httpd.path)
else:
saveMaster(path, httpd)
def _generateHeader(self, cmd, size):
packet = bytearray()
packet.append(cmd)
packet.append(size & 0xFF)
packet.append(size >> 8)
return packet
# s = socket(AF_INET, SOCK_DGRAM)
# s.bind(('', 0))
# s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
def register(ssid, key):
"""
the entrance function of SmartConfig(tmd)
:type ssid: str
:type key: str
"""
port = 8514
data = {'key':encode(key), 'ssid':encode(ssid)}
s = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
for i in xrange(10):
send(s, port, data, ssid, key)
sleep(100)
def setup(ssid, password, security_mode):
# Security mode options are (0 - none, 1 = WEP, 2 = WPA1, 3 = WPA2, 4 = WPA1/2)
payload = bytearray(0x88)
payload[0x26] = 0x14 # This seems to always be set to 14
# Add the SSID to the payload
ssid_start = 68
ssid_length = 0
for letter in ssid:
payload[(ssid_start + ssid_length)] = ord(letter)
ssid_length += 1
# Add the WiFi password to the payload
pass_start = 100
pass_length = 0
for letter in password:
payload[(pass_start + pass_length)] = ord(letter)
pass_length += 1
payload[0x84] = ssid_length # Character length of SSID
payload[0x85] = pass_length # Character length of password
payload[0x86] = security_mode # Type of encryption (00 - none, 01 = WEP, 02 = WPA1, 03 = WPA2, 04 = WPA1/2)
checksum = 0xbeaf
for i in range(len(payload)):
checksum += payload[i]
checksum = checksum & 0xffff
payload[0x20] = checksum & 0xff # Checksum 1 position
payload[0x21] = checksum >> 8 # Checksum 2 position
sock = socket.socket(socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.sendto(payload, ('255.255.255.255', 80))
def receive_udp(self):
#set up UDP socket to receive data from robot
port = 5678
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(10)
if self.address == '255.255.255.255':
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.bind(("", port)) #bind all intefaces to port
print("waiting on port: %d for data" % port)
message = 'irobotmcs'
s.sendto(message.encode(), (self.address, port))
roomba_dict = {}
while True:
try:
udp_data, addr = s.recvfrom(1024) #wait for udp data
#print('Received: Robot addr: %s Data: %s ' % (addr, udp_data))
if len(udp_data) > 0:
if udp_data != message:
try:
if self.address != addr[0]:
self.log.warn(
"supplied address %s does not match "
"discovered address %s, using discovered "
"address..." % (self.address, addr[0]))
if udp_data.decode() != message:
parsedMsg = json.loads(udp_data)
roomba_dict[addr]=parsedMsg
except Exception as e:
print("json decode error: %s" % e)
print('RECEIVED: %s', pformat(udp_data))
# print('Robot Data: %s '
# % json.dumps(parsedMsg, indent=2))
else:
break
except socket.timeout:
break
s.close()
return roomba_dict
