Пример #1
0
 def _get_listener(self, options, defaults):
     key = hash(tuple(options.iteritems()))
     if key in self.cached_listeners:
         existing = self.cached_listeners[key]
         listener_copy = self._copy_listener(existing)
         self.listeners[key] = listener_copy
         return listener_copy
     type = options.get('type', 'tcp')
     new_listener = None
     if type in ('tcp', 'udp', 'unix'):
         if type == 'tcp':
             interface = options.get('interface', defaults.get('interface'))
             port = int(options.get('port', defaults.get('port')))
             new_listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             address = (interface, port)
         elif type == 'udp':
             interface = options.get('interface', defaults.get('interface'))
             port = int(options.get('port', defaults.get('port')))
             new_listener = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             address = (interface, port)
         elif type == 'unix':
             new_listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             address = options.get('path', defaults.get('path'))
         new_listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         new_listener.setblocking(0)
         new_listener.bind(address)
         if type != 'udp':
             backlog = int(options.get('backlog', 256))
             new_listener.listen(backlog)
     elif type == 'custom':
         new_listener = self._load_from_custom(options)
     else:
         raise ValueError('Unknown listener type: {0}'.format(type))
     self.listeners[key] = new_listener
     return new_listener
Пример #2
0
 def test_channel_binding(self):
     self._create_certificate('server.pem', '/CN=foo/')
     cb = []; data = []
     def server(sock):
         conn, addr = sock.accept()
         sslsock = SSLSocket(conn, server_side=True,
                          keyfile='server.pem', certfile='server.pem')
         cb.append(sslsock.get_channel_binding())
         buf = sslsock.read()
         data.append(buf)
         conn = sslsock.unwrap()
         conn.close()
     def client(sock, addr):
         sock.connect(addr)
         sslsock = SSLSocket(sock)
         cb.append(sslsock.get_channel_binding())
         sslsock.write('foo')
         data.append('foo')
         sslsock.unwrap()
     s1 = socket.socket()
     s1.bind(('localhost', 0))
     s1.listen(2)
     s2 = socket.socket()
     g1 = gevent.spawn(server, s1)
     g2 = gevent.spawn(client, s2, s1.getsockname())
     gevent.joinall([g1, g2])
     s1.close(); s2.close()
     assert len(cb) == 2
     assert len(cb[0]) in (12, 36)
     assert cb[0] == cb[1]
     assert len(data) == 2
     assert data[0] == data[1]
Пример #3
0
def _get_local_ips():
    local_ips = []

    # get local ip using UDP and a  broadcast address
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
    # Not using <broadcast> because gevents getaddrinfo doesn't like that
    # using port 1 as per hobbldygoop's comment about port 0 not working on osx:
    # https://github.com/sirMackk/ZeroNet/commit/fdcd15cf8df0008a2070647d4d28ffedb503fba2#commitcomment-9863928
    s.connect(('239.255.255.250', 1))
    local_ips.append(s.getsockname()[0])

    # Get ip by using UDP and a normal address (google dns ip)
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(('8.8.8.8', 0))
        local_ips.append(s.getsockname()[0])
    except:
        pass

    # Get ip by '' hostname . Not supported on all platforms.
    try:
        local_ips += socket.gethostbyname_ex('')[2]
    except:
        pass

    # Delete duplicates
    local_ips = list(set(local_ips))

    # Probably we looking for an ip starting with 192
    local_ips = sorted(local_ips, key=lambda a: a.startswith("192"), reverse=True)

    return local_ips
Пример #4
0
 def keep_alive(self):
     print 'keep_alive'
     #心跳包
     #heartbeat_pkt=struct.pack('!B',0x80)
     while True:
         #每隔4s 发送一次心跳
         sleep(4)
         try:
             #self.sock.sendall(heartbeat_pkt)
             self.pro.encodeData(0x02,'')
             pass
         #except error:
         except:
             #尝试重连
             self.isalive = False
             self.sock = socket(_socket.AF_INET, _socket.SOCK_STREAM)
             while not self.isalive:
                 try:
                     self.sock.connect(self.ipp)
                     self.sock.sendall(self.uuidstr)
                     self.pro.setfileobj(self.sock.makefile())
                     
                     self.isalive = True
                 except error,e:
                     #print e
                     self.sock = socket(_socket.AF_INET, _socket.SOCK_STREAM)
                     self.isalive = False
                     #print 'kkkkk'
                     sleep(1)
                 except:
                     print '2k2k2k2k2'
                     sleep(1)
Пример #5
0
	def __init__(self,service,hostname='',ipv6=False,port=0,backlog=10,reuse_addr=True,authenticator=None,registrar=None,auto_register=None,protocol_config={},logger=None,listener=None):
		self.active = False
		self._closed = False
		self.service = service
		self.authenticator = authenticator
		self.backlog = backlog
		if auto_register is None:
			self.auto_register = bool(registrar)
		else:
			self.auto_register = auto_register
		self.protocol_config = protocol_config
		self.clients = set()
		if listener is None:
			if ipv6:
				if hostname == 'localhost' and sys.platform != 'win32':
					hostname = 'localhost6'
				self.listener = socket.socket(socket.AF_INET6,socket.SOCK_STREAM)
			else:
				self.listener = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
			if reuse_addr and sys.platform != 'win32':
				self.listener.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
			self.listener.bind((hostname,port))
		else:
			self.listener = listener
		sockname = self.listener.getsockname()
		self.host, self.port = sockname[0], sockname[1]
		if logger is None:
			logger = logging.getLogger("%s/%d" % (self.service.get_service_name(), self.port))
		self.logger = logger
		if "logger" not in self.protocol_config:
			self.protocol_config["logger"] = self.logger
		if registrar is None:
			registrar = UDPRegistryClient(logger=self.logger)
		self.registrar = registrar
Пример #6
0
	def __heartbeat_dispatcher(self):
		"""Send out heartbeats, to all hosts."""
		while True:
			heartbeat = None;

			self.__debug(self.__server_table);

			if (self.config['SEND_HEARTBEATS']):
				# Build the heartbeat.
				if (self.config['IGNORE']):
					heartbeat = str(self.config['NODE_DL_HOSTNAME'] + ',IGNORE,IGNORE');
				else:
					heartbeat = str(self.config['NODE_DL_HOSTNAME'] + ',' + str(getloadavg()[0] / CPU_CORES) + ',' + str(self.__netload));

			# And send it to every host in the list.
			for host in self.__server_table.keys():
				try:
					if (self.__server_table[host]):
						if (self.__server_table[host]['yet_to_be_named_metric'] > int(self.config['SERVER_TIMEOUT'])):		# If it's been less than SERVER_TIMEOUT seconds since we got a heartbeat...
							del self.__server_table[host];												# ...delete the host from server_table.
							continue;
						else:																			# Otherwise...
							self.__server_table[host]['yet_to_be_named_metric'] += 1;					# ...update the count since we last heard from them.

					if (heartbeat):
						socket.socket(socket.AF_INET, socket.SOCK_DGRAM).sendto(sha256(heartbeat + self.config['SHARED_SECRET']).hexdigest() + heartbeat, (host, int(self.config['HEARTBEAT_PORT'])));
				except Exception as err:
					self.__debug("Error sending heartbeat: " + str(err));

			sleep(int(self.config['HEARTBEAT_INTERVAL']) / 1000.0);
Пример #7
0
def childproxy(conn, headers, conn_name='', serv_name=''):
	if proxy_type == 'http':
		s = socket.socket()
		connect_proxy(conn, s, headers, conn_name, serv_name)
	elif proxy_type == 'https':
		print('https')
		sock = ssl.wrap_socket(socket.socket())
		connect_proxy(conn, sock, headers, conn_name, serv_name)
	elif proxy_type == 'socks':
		method, version, scm, address, path, params, query, fragment = parse_header(headers)
		s = socket.socket()
		geventsocks.connect(s, address)
		print('connect {} success'.format(serv_name))
		if headers.startswith('CONNECT'):
			conn.sendall(b'HTTP/1.1 200 Connection established\r\n\r\n')
			create_pipe(conn, s, conn_name=conn_name, serv_name=serv_name)
		else:
			raw_headers = headers
			headers = make_headers(headers)
			s.sendall(headers.encode())
			print(conn_name,
				  '[{}]'.format(time.strftime('%Y-%m-%d %H:%M:%S')),
				  raw_headers.split('\r\n')[0])
			g = gevent.spawn(from_serv_to_cli, conn, s, conn_name, serv_name)
			try:
				from_cli_to_serv(conn, s, conn_name, serv_name)
				# for buf in iter(lambda:conn.recv(1024*16), b''):
				# 	s.sendall(buf)
			except (BrokenPipeError, ConnectionResetError):
				print('server: {} client: {} close'.format(serv_name, conn_name) )
			g.kill()
			return
Пример #8
0
def check_port(port, rais=True, ipv4=True, ipv6=True):
    """ True -- it's possible to listen on this port for TCP/IPv4 or TCP/IPv6
    connections (UNIX Sockets in case of file path). False -- otherwise.
    """
    try:
        if isinstance(port, (int, long)):
            if ipv4:
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.bind(('127.0.0.1', port))
                sock.listen(5)
                sock.close()
            if ipv6:
                sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
                sock.bind(('::1', port))
                sock.listen(5)
                sock.close()
        else:
            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            sock.connect(port)
    except socket.error as e:
        if rais:
            raise RuntimeError(
                "The server is already running on port {0}".format(port))
        return False
    return True
Пример #9
0
def BuildSocket(ip):
	if IPy.IP(ip).version() == 4:
		s = socket.socket()  
	elif IPy.IP(ip).version() == 6:
		s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)  
	else:
		print "There is an invalid string in SSL_Test Func:",ip
		raise socket.error
	s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
	return s
Пример #10
0
    def __init__(self, addr, timeout=None):
        if isinstance(addr, basestring):
            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        elif isinstance(addr, tuple):
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
        else:
            raise ValueError('Address must be a tuple or a string not %s', type(addr))

        sock.connect(addr)
        super(ClientConnection, self).__init__(sock)
Пример #11
0
	def TCPInitialize(self, ServerMode, address, port):
		self._ServerMode = ServerMode
		self._address = address
		self._port = port
		if(self._ServerMode):
			self._server = socket.socket()
			self._server.bind((self._address, self._port))
			self._server.listen(500)
		else:
			self._client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
			self._client.connect((self._address, self._port))
Пример #12
0
 def test_mutiple_clients(self):
     csock1 = socket.socket()
     csock1.connect(self.address)
     client1 = MessageBusConnection(csock1, self.authtok)
     csock2 = socket.socket()
     csock2.connect(self.address)
     client2 = MessageBusConnection(csock2, self.authtok)
     client1.call_method('set_value', 10)
     reply = client2.call_method('get_value')
     assert reply == 10
     client1.close()
     client2.close()
Пример #13
0
 def _connect(self,):
     """
     """
     assert self._stream == None or self._stream.closed()
     if isinstance(self._address, str):
         s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     else:
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     s.settimeout(10)
     s.connect(self._address)
     self._stream = IOStream(s)
     self._stream.read_bytes(struct.calcsize("!I"), self._get_buffer_size)
Пример #14
0
    def connect(self):
        host = self._host
        port = self._port
        if self._fd is None:
            #try to find the server on the same sub-net
            if host is None or port is None:
                udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
                # go through all interfaces, and issue broadcast on each
                for addr in ip4_broadcast_addresses(host is None):
                    udp.sendto('Hello',(addr,protocol.DEFAULT_UDP_SERVER_PORT))
                timeout = 3.
                server_found = []
                while 1:
                    rlist,_,_ = select.select([udp],[],[],timeout)
                    if not rlist:
                        if port is None:
                            if server_found:
                                msg = "Could not find the conductor on host %s\n" % self._host
                                msg += "But other conductor servers replied:\n"
                                msg += '\n'.join(('%s on port %s' % (host,port) for host,port in server_found))
                                raise ConnectionException(msg)
                            else:
                                raise ConnectionException("Could not find the conductor")
                        else:
                            break
                    else:
                        msg,address = udp.recvfrom(8192)
                        host,port = msg.split('|') 
                        port = int(port)
			if self._host == 'localhost':
			    localhost = socket.gethostname()
			    if localhost == host:
				break	
                        elif self._host is not None and host != self._host:
                            server_found.append((host,port))
                            host,port = None,None
                            timeout = 1.
                        else:
                            break
                self._host = host
                self._port = port
            self._fd = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
            self._fd.setsockopt(socket.IPPROTO_TCP,socket.TCP_NODELAY,1)
            self._fd.setsockopt(socket.SOL_IP, socket.IP_TOS, 0x10)
            self._fd.connect((host,port))
            self._raw_read_task = gevent.spawn(self._raw_read)
            self._cnx = self._fd
            if posix_ipc:
                self._g_event.clear()
                self._fd.sendall(protocol.message(protocol.POSIX_MQ_QUERY,socket.gethostname()))
                self._g_event.wait(1.)
Пример #15
0
 def test_pair_and_sync(self):
     # Create two databases and two models
     database1 = Database(self.tempfile())
     model1 = create(Model, database1)
     assert instance(Model) is model1
     vault1 = model1.create_vault('Vault1', 'Passw0rd')
     database2 = Database(self.tempfile())
     model2 = Model(database2)
     vault2 = model2.create_vault('Vault2', 'Passw0rd', uuid=vault1['id'])
     # Start a message bus server and client connection
     lsock = socket.socket()
     lsock.bind(('localhost', 0))
     lsock.listen(2)
     mbserver = create(MessageBusServer, lsock, 'S3cret', None)
     #mbserver.set_trace('/tmp/server.txt')
     mbserver.start()
     csock = socket.socket()
     csock.connect(lsock.getsockname())
     mbhandler = MBTestHandler()
     mbclient = MessageBusConnection(csock, 'S3cret', mbhandler)
     #mbclient.set_trace('/tmp/client.txt')
     # Start the syncapi
     lsock = socket.socket()
     lsock.bind(('localhost', 0))
     lsock.listen(2)
     address = lsock.getsockname()
     syncapp = SyncAPIApplication()
     syncapp.allow_pairing = True
     server = SyncAPIServer(lsock, syncapp)
     server.start()
     # Pair with vault1
     client = SyncAPIClient(lsock.getsockname())
     client.connect()
     kxid = client.pair_step1(vault1['id'], 'foo')
     assert kxid is not None
     assert mbhandler.name == 'foo'
     certinfo = { 'name': 'node2', 'node': vault2['node'] }
     keys = certinfo['keys'] = {}
     for key in vault2['keys']:
         keys[key] = { 'key': vault2['keys'][key]['public'],
                       'keytype': vault2['keys'][key]['keytype'] }
     peercert = client.pair_step2(vault1['id'], kxid, mbhandler.pin, certinfo)
     assert isinstance(peercert, dict)
     assert model1.check_certinfo(peercert)[0]
     model2.add_certificate(vault2['id'], peercert)
     # Sync
     version1 = model1.add_version(vault1['id'], {'foo': 'bar'})
     client.sync(vault1['id'], model2)
     version2 = model2.get_version(vault1['id'], version1['id'])
     assert version2 is not None
     assert version2['foo'] == 'bar'
Пример #16
0
def stream_udp(bind_addr, target_addr):
    # Setup the sockets
    source = {
        "socket": socket.socket(socket.AF_INET, socket.SOCK_DGRAM),
        "addr": None
    }
    source["socket"].bind(bind_addr)
    target = {
        "socket": socket.socket(socket.AF_INET, socket.SOCK_DGRAM),
        "addr": target_addr
    }

    # Source -> Target
    _stream_udp(source, target)
Пример #17
0
    def accept(self):

        if self.protocol == 'ipc':
            try:
                os.remove(self.host)
            except OSError:
                pass

            # s.bind(self.host)

            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            s.bind(self.host)
            os.chmod(self.host, 0770)
            if self.user:
                import pwd

                pe = pwd.getpwnam(self.user)
                os.chown(self.host, pe.pw_uid, pe.pw_gid)
        else:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            s.bind((self.host, self.port))

        s.listen(self.backlog)

        self.listeningsock = s

        #log.info("Listening on %s (%s) ..." % (self.address, self))
        # print "Listening on %s (%s) ..." % (self.address, self)
        exec_count = 0

        while True:
            try:
                connection, addr = self.listeningsock.accept()
                connection = Connection(socket.socket(_sock=connection), self._remove_connection)
                self.connections.add(connection)
                yield connection, addr
            except Exception as e:
                if not self.listeningsock:
                    break
                #log.exception('Could not accept a connection...')
                # print 'Could not accept a connection...'
                # print traceback.print_exc()
                sleep(0.5 * exec_count)
                exec_count += 1
            else:
                #log.debug("New connection at %s" % self.address)
                # print "New connection at %s" % self.address
                exec_count = 0
Пример #18
0
    def connect_to_resource(self, addr, connect_timeout=None,
            inactivity_timeout=None):

        with gevent.Timeout(connect_timeout, ConnectionError):
            try:
                if is_ipv6(addr[0]):
                    sock = socket.socket(socket.AF_INET6, 
                            socket.SOCK_STREAM)
                else:
                    sock = socket.socket(socket.AF_INET, 
                            socket.SOCK_STREAM)
                sock.connect(addr)
            except socket.error, e:
                raise ConnectionError(
                        "socket error while connectinng: [%s]" % str(e))
Пример #19
0
def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind(('', 80))
    s.listen(1)
    while True:
        conn, addr = s.accept()
        gevent.spawn(lambda: handle_client(conn, addr))
Пример #20
0
  def setup_tunnel(self):
    """
    Sets up the L2TPv3 kernel tunnel for data transfer.
    """
    try:
      self.socket = gsocket.socket(gsocket.AF_INET, gsocket.SOCK_DGRAM)
      self.socket.bind((self.manager.address, self.port))
      self.socket.connect(self.endpoint)
      self.socket.setsockopt(gsocket.IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_PROBE)
    except gsocket.error:
      raise TunnelSetupFailed

    # Setup some default values for PMTU
    self.pmtu = 1446
    self.probed_pmtu = 0

    # Make the socket an encapsulation socket by asking the kernel to do so
    try:
      self.manager.netlink.tunnel_create(self.id, self.peer_id, self.socket.fileno())
      session = self.create_session()
    except L2TPTunnelExists:
      self.socket.close()
      raise
    except NetlinkError:
      self.socket.close()
      raise TunnelSetupFailed
Пример #21
0
    def unwrap(self):
        if self._sslobj:
            while True:
                try:
                    s = self._sslobj.shutdown()
                    break
                except SSLWantReadError:
                    if self.timeout == 0.0:
                        return 0
                    self._wait(self._read_event)
                except SSLWantWriteError:
                    if self.timeout == 0.0:
                        return 0
                    self._wait(self._write_event)

            self._sslobj = None
            # The return value of shutting down the SSLObject is the
            # original wrapped socket, i.e., _contextawaresock. But that
            # object doesn't have the gevent wrapper around it so it can't
            # be used. We have to wrap it back up with a gevent wrapper.
            sock = socket(family=s.family, type=s.type, proto=s.proto, fileno=s.fileno())
            s.detach()
            return sock
        else:
            raise ValueError("No SSL wrapper around " + str(self))
	def __init__(self, sock=None, address=None):
		self.socket = socket.socket() if sock is None else sock
		self.address = address
		self.msg_id_counter = 0
		self.start_time = time.time()
		self.ignored_messages = []
		self.leftover = ""
Пример #23
0
 def test_connection_refused(self):
     s = socket()
     try:
         s.connect(('127.0.0.1', 81))
     except error as ex:
         assert ex.args[0] == ECONNREFUSED, repr(ex)
         assert 'refused' in str(ex).lower(), str(ex)
Пример #24
0
def socket_server(host, port):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind((host, port))
    sock.listen(256)
    while True:
        client, address = sock.accept()
        gevent.spawn(socket_accept, client, address)
Пример #25
0
def perform_m_search(local_ip):
    """
    Broadcast a UDP SSDP M-SEARCH packet and return response.
    """
    search_target = "urn:schemas-upnp-org:device:InternetGatewayDevice:1"

    ssdp_request = ''.join(
        ['M-SEARCH * HTTP/1.1\r\n',
         'HOST: 239.255.255.250:1900\r\n',
         'MAN: "ssdp:discover"\r\n',
         'MX: 2\r\n',
         'ST: {0}\r\n'.format(search_target),
         '\r\n']
    )

    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    sock.bind((local_ip, 0))

    sock.sendto(ssdp_request, ('239.255.255.250', 1900))
    if local_ip == "127.0.0.1":
        sock.settimeout(1)
    else:
        sock.settimeout(5)

    try:
        return sock.recv(2048)
    except socket.error:
        raise UpnpError("No reply from IGD using {} as IP".format(local_ip))
    finally:
        sock.close()
Пример #26
0
 def unwrap(self):
     if self._sslobj:
         s = self._sslobj_shutdown()
         self._sslobj = None
         return socket(_sock=s) # match _ssl2; critical to drop/reuse here on PyPy
     else:
         raise ValueError("No SSL wrapper around " + str(self))
Пример #27
0
	def _connect(cls,host='0.0.0.0',port=0,family=socket.AF_INET,socktype=socket.SOCK_STREAM,proto=0,timeout=3,nodelay=False):
		s = socket.socket(family,socktype,proto)
		s.settimeout(timeout)
		s.connect((host,port))
		if nodelay:
			s.setsockopt(socket.IPPROTO_TCP,socket.TCP_NODELAY,1)
		return s
Пример #28
0
    def check(self, url, host_info):
        host_info[self.description()] = None
        host_ip = socket.getaddrinfo(url, 443)[0][4][0]
        try:
            sock = socket.socket()
            sock.connect((host_ip, 443))
        except socket.error:
            host_info["ssl checked"].set(True)
            host_info[self.description()] = True
            return True

        try:
            sock = ssl.wrap_socket(sock,
                ca_certs="/etc/ssl/certs/ca-certificates.crt",
                cert_reqs=ssl.CERT_NONE,
            )
            cert = sock.getpeercert()
        except ssl.SSLError:
            host_info["ssl checked"].set(True)
            host_info[self.description()] = True
            return True

        host_info["ssl checked"].set(False)
        host_info[self.description()] = False
        return False
Пример #29
0
def server_thread(port):
    global server_run

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_socket.bind(('0.0.0.0', port))

    while server_run:
        try:
            with Timeout(2, False):
                (data, from_ip) = server_socket.recvfrom(1024)

            if data is None:
                continue

            ping = ping_parse(data)
            if ping is None:
                continue

            msg = 'Received - Seq: %d, Timestamp: %d' % (ping.seq, ping.timestamp)
            print colored(msg, 'green')

            pong = make_pong(ping)

            server_socket.sendto(pong, from_ip)

        except timeout:
            continue
        except KeyboardInterrupt:
            server_run = False
Пример #30
0
    def _run(self):
        MCAST_GRP = '224.1.1.1'
        MCAST_PORT = 8001


        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.bind(('', MCAST_PORT))
        mreq = struct.pack("=4sl", socket.inet_aton(MCAST_GRP), socket.INADDR_ANY)
        s.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)


        self._ready.set()

        while not self._complete.is_set():
            try:
                data, address = s.recvfrom(1024)
                t = data.split('|')
                if t[0] == 'V':
                    self._manager.vms[t[1]] = time.time()*100
                else:
                    self._manager.ternimals[t[1]] = int(time.time())*100

                print (t[0], t[1], address[0])
            except :
                self._complete.wait(timeout=1)
                continue
Пример #31
0
    def login(self, ipaddress, port, user_passwd_pair_list):
        for user_passwd_pair in user_passwd_pair_list:
            husername = binascii.b2a_hex(user_passwd_pair[0])
            lusername = len(user_passwd_pair[0])
            lpassword = len(user_passwd_pair[1])
            hpwd = binascii.b2a_hex(user_passwd_pair[1])
            address = binascii.b2a_hex(ipaddress) + '3a' + binascii.b2a_hex(
                str(port))
            data = '0200020000000000123456789000000000000000000000000000000000000000000000000000ZZ5440000000000000000000000000000000000000000000000000000000000X3360000000000000000000000000000000000000000000000000000000000Y373933340000000000000000000000000000000000000000000000000000040301060a09010000000002000000000070796d7373716c000000000000000000000000000000000000000000000007123456789000000000000000000000000000000000000000000000000000ZZ3360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000Y0402000044422d4c6962726172790a00000000000d1175735f656e676c69736800000000000000000000000000000201004c000000000000000000000a000000000000000000000000000069736f5f31000000000000000000000000000000000000000000000000000501353132000000030000000000000000'
            data1 = data.replace(data[16:16 + len(address)], address)
            data2 = data1.replace(data1[78:78 + len(husername)], husername)
            data3 = data2.replace(data2[140:140 + len(hpwd)], hpwd)
            if lusername >= 16:
                data4 = data3.replace('0X',
                                      str(hex(lusername)).replace('0x', ''))
            else:
                data4 = data3.replace('X',
                                      str(hex(lusername)).replace('0x', ''))
            if lpassword >= 16:
                data5 = data4.replace('0Y',
                                      str(hex(lpassword)).replace('0x', ''))
            else:
                data5 = data4.replace('Y',
                                      str(hex(lpassword)).replace('0x', ''))
            hladd = hex(len(ipaddress) + len(str(port)) + 1).replace('0x', '')
            data6 = data5.replace('ZZ', str(hladd))
            data7 = binascii.a2b_hex(data6)

            try:
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                s.settimeout(self.timeout)
                s.connect((ipaddress, port))
            except Exception as E:
                logger.debug('ConnectException: {} {} {}'.format(
                    E, ipaddress, port))
                return

            try:
                s.send(data7)
                if 'master' in s.recv(1024):
                    log_success("MSSQL", ipaddress, port, user_passwd_pair)
                else:
                    logger.debug('AuthenticationFailed')
            except Exception as E:
                logger.debug('AuthenticationException: %s' % E)
                continue
Пример #32
0
    def test_proxy(self):
        self.test_input = 'Hiya, this is a test'
        mock_service = StreamServer(('127.0.0.1', 0), self.echo_server)
        gevent.spawn(mock_service.start)
        gevent.sleep(1)

        proxy = Proxy('proxy', '127.0.0.1', mock_service.server_port)
        server = proxy.get_server('127.0.0.1', 0)
        gevent.spawn(server.start)
        gevent.sleep(1)

        s = socket()
        s.connect(('127.0.0.1', server.server_port))
        s.sendall(self.test_input)
        received = s.recv(len(self.test_input))
        self.assertEqual(self.test_input, received)
        mock_service.stop(1)
Пример #33
0
    def test_proxy(self):
        self.test_input = "Hiya, this is a test".encode("utf-8")
        mock_service = StreamServer(("127.0.0.1", 0), self.echo_server)
        gevent.spawn(mock_service.start)
        gevent.sleep(1)

        proxy = Proxy("proxy", "127.0.0.1", mock_service.server_port)
        server = proxy.get_server("127.0.0.1", 0)
        gevent.spawn(server.start)
        gevent.sleep(1)

        s = socket()
        s.connect(("127.0.0.1", server.server_port))
        s.sendall(self.test_input)
        received = s.recv(len(self.test_input))
        self.assertEqual(self.test_input, received)
        mock_service.stop(1)
Пример #34
0
def run_client():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.connect(('localhost', 2786))
    session = Session(sock.makefile('rw'), True)
    start = time.time()

    # [beam(session) for _ in range(NUM_CALLS)]
    parallel(session)

    dt = time.time() - start
    print('call: %d KB/s, dt=%.4f' % (NUM_CALLS * SZ / dt / 1024, dt))
    print "client: active strems", session.stream_count
    print "client: SessionClose and await exit"
    session.close()
    gevent.sleep(0.1)
    print "client: final stream count", session.stream_count
Пример #35
0
    def run(self):
        while True:
            try:
                self.socket = socket.socket(family=socket.AF_UNIX)
                self.socket.connect("/var/run/devd.xml.pipe")
                f = self.socket.makefile("rb", 0)

                while True:
                    line = self.read_until_nul(f)
                    if line is None:
                        # Connection closed - we need to reconnect
                        # return
                        raise OSError('Connection closed')

                    event = self.__tokenize(line.decode('utf-8', 'replace'))
                    if not event:
                        # WTF
                        continue

                    if "system" not in event:
                        # WTF
                        continue

                    if event["system"] == "DEVFS":
                        self.__process_devfs(event)

                    if event["system"] == "IFNET":
                        self.__process_ifnet(event)

                    if event["system"] == "ZFS":
                        self.__process_zfs(event)

                    if event["system"] == "ISCSI":
                        self.__process_iscsi(event)

                    if event["system"] == "SYSTEM":
                        self.__process_system(event)

            except OSError as err:
                # sleep for a half a second and retry
                self.dispatcher.logger.info(
                    '/var/run/devd.pipe read error: {0}'.format(str(err)))
                self.dispatcher.logger.info('retrying in 1s')
                time.sleep(1)

            self.socket.close()
Пример #36
0
def getLocalIP():
    ''' Get the local IP address as a string

    Derived from https://github.com/n8henrie/fauxmo
    '''
    hostname = socket.gethostname()
    ip_address = socket.gethostbyname(hostname)

    # Workaround for Linux returning localhost
    # See: SO question #166506 by @UnkwnTech
    if ip_address in ['127.0.1.1', '127.0.0.1', 'localhost']:
        tempsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        tempsock.connect(('8.8.8.8', 0))
        ip_address = tempsock.getsockname()[0]
        tempsock.close()

    return ip_address
Пример #37
0
 def init(self, host="172.16.16.41", port=6000):
     self.host = host
     self.port = int(port)
     # self.soc = socket(AF_INET, SOCK_STREAM)
     self.soc = socket()
     self.data = b''
     self.tempData = None
     ADDR = (self.host, self.port)
     try:
         self.soc.connect(ADDR)
     except Exception as err:
         raise
     else:
         # self.soc.settimeout(20)
         self.soc.setblocking(0)  # 设置为非阻塞
         self.greenlet.spawn(self.__heart)
         self.greenlet.spawn(self.__loopCheck)
Пример #38
0
def is_port_open(host, port):
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.settimeout(3.0)
        if s.connect_ex((host, int(port))) == 0:
            return True
        else:
            return False
    except Exception as e:
        return False
    finally:
        try:
            s.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
                         struct.pack('ii', 1, 0))
            s.close()
        except Exception as e:
            pass
Пример #39
0
 def __init__(self, discovery_port, delay=1):
     #print("port discovery ",self._etc["DISCOVERY_port"])
     self._PROC["dsc_client"] = socket.socket(socket.AF_INET,
                                              socket.SOCK_DGRAM)
     self._PROC["dsc_client"].setsockopt(socket.SOL_SOCKET,
                                         socket.SO_REUSEADDR, 1)
     self._PROC["dsc_client"].setsockopt(socket.SOL_SOCKET,
                                         socket.SO_BROADCAST, 1)
     self._PROC["dsc_client"].settimeout(delay)
     self._etc["dsc_delay"] = delay
     self.discovery_port = discovery_port
     #print("discovery on port:",discovery_port)
     self._PROC["dsc_server"] = DatagramServer(('', self.discovery_port),
                                               handle=self._receive)
     self._PROC["dsc_server"].start()
     #print(self.__dict__)
     self._PROC["dsc_enabled"] = False
Пример #40
0
    def __init__(self, ac, msgCallback):
        '''

        :param PHPAgentConf ac:
        '''
        self.address = ac.Address

        if os.path.exists(self.address):
            os.remove(self.address)
        self.listen_socket = gsocket.socket(gsocket.AF_UNIX,
                                            gsocket.SOCK_STREAM)
        self.listen_socket.bind(self.address)
        self.listen_socket.listen(256)
        self.server = StreamServerLayer(self.listen_socket, self._recvData,
                                        self._phpClientSayHello)
        self.msgHandleCallback = msgCallback
        self.hello_cb = []
Пример #41
0
def graphite_worker(host, port):
    """The worker pops each item off the queue and sends it to graphite."""
    sock = socket()
    try:
        sock.connect((host, port))
    except Exception as e:
        LOG.error("Failed to connect to Graphite at {0}:{1}".format(
            host, port))
        LOG.error("{0}".format(e))
        return

    LOG.info("Connected to graphite at {0}:{1}".format(host, port))

    while True:
        data = graphite_queue.get()
        # print "graphite_worker: got data {0!r}".format(data)
        sock.sendall(data)
Пример #42
0
 def connect(self):
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.sock.settimeout(self.timeout)
     try:
         self.sock.connect((self.host, self.port))
     except socket.timeout:
         raise NotConnectedError('Connection timed out after %s seconds' %
                                 self.timeout)
     self.connected = True
     self.sock.settimeout(None)
     self.sock_file = self.sock.makefile()
     self.start_event_handlers()
     self._auth_request_event.wait()
     if not self.connected:
         raise NotConnectedError('Server closed connection, check '
                                 'FreeSWITCH config.')
     self.authenticate()
Пример #43
0
 def test_do_TRACE(self):
     """
     Objective: Test the web server with a trace request
     """
     # requests has no trace method.. So resorting to the good'ol socket - sending raw data
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     s.connect(("127.0.0.1", self.http_server.server_port))
     s.sendall(b"TRACE /index.html HTTP/1.1\r\nHost: localhost\r\n\r\n")
     data = s.recv(1024)
     # FIXME: Omitting the time etc from data - mechanism to check them needed as well?
     self.assertIn(b"HTTP/1.1 200 OK", data)
     # test for 501 - Disable TRACE method
     self.http_server.cmd_responder.httpd.disable_method_trace = True
     s.sendall(b"TRACE /index.html HTTP/1.1\r\nHost: localhost\r\n\r\n")
     data = s.recv(1024)
     s.close()
     self.assertIn(b"501", data)
Пример #44
0
def control_loop(opts):
    handler = ControlHandler(opts)
    address = opts.control_socket
    _log.debug("address from options: {}".format(address))
    if address[:1] == '@':
        address = '\00' + address[1:]
    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0)
    status = sock.bind(address)
    _log.debug("Binding to address: {}".format(address))
    _log.debug("Status of bind: {}".format(str(status)))
    sock.listen(5)
    while True:
        client, client_address = sock.accept()
        if _verify_request(opts, client, client_address):
            gevent.spawn(_handle_request, client, handler)
        else:
            client.close()
Пример #45
0
def main_task():
    server_addr = ('0.0.0.0', 8888)
    tcp_server = socket()
    # tcp_server.setsockopt(socket.SOL_SOCKET,
    #                       socket.SO_REUSEADDR, 1)
    tcp_server.bind(server_addr)
    tcp_server.listen()

    # 导入多线程
    from threading import Thread
    while True:
        user_socket, addr = tcp_server.accept()
        print('addr=', addr)
        # 创建协程greenlet对象
        p = gevent.spawn(process_client_request, user_socket)
        # 在此处回收已经死了的线程 is_alive() 来判断
    tcp_server.close()
Пример #46
0
    def connect(self):
        """\
        Connect to the IRC server using the nickname
        """
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            self._sock.connect((self.server, self.port))
        except socket.error:
            self.logger.error('Unable to connect to %s on port %d' %
                              (self.server, self.port),
                              exc_info=1)
            return False

        self._sock_file = self._sock.makefile()
        self.register_nick()
        self.register()
        return True
Пример #47
0
    def send_message(self, address, message):
        """ Send a message  """
        from gevent import socket

        message_json = message.json()

        # Send message
        sock = socket.socket(type=socket.SOCK_DGRAM)
        sock.connect(address)
        sock.send(message_json)
        try:
            data, address = sock.recvfrom(8192)  # Read 8KB
            #self.logger.info("[{source}] replied: '{resp}'".format(
            #    source=self.source_format(address), resp=data))
        except Exception, e:
            self.logger.error("[{source}] replied: {error}".format(
                source=self.source_format(address), error=e))
Пример #48
0
    def try_to_connect(self):
        print "Trying to connect"
        # use a new socket when attempting to reconnect!
        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        i = 2
        while True:
            try:
                a = self.client_socket.connect((self.host, self.port))
                print "Connected...", a
                break
            except:
                print "Retrying connecting..."
                gevent.sleep(i)
                i += 0.1
                max_period = 2
                i = max_period if i > max_period else i
Пример #49
0
            def wrapped(self, command, client_socket, *args, **kwargs):
                current_thread = threading.current_thread()
                tid = current_thread.name.rsplit('-', 1)[-1]
                current_thread.name = '%s-%s-%s' % (self.client_id[:14],
                                                    command.cmd, tid)

                # Create a gevent socket for this thread from the other tread's socket
                # (using the raw underlying socket, '_sock'):
                client_socket = socket.socket(_sock=client_socket._sock)

                self.client_socket = client_socket
                try:
                    command.executed(func(self, *args, **kwargs))
                except (IOError, RuntimeError, socket.error) as e:
                    command.error(e)
                except DeadException:
                    command.cancelled()
Пример #50
0
    def __init__(self, host=DEFAULT_HOST, port=DEFAULT_PORT, parse_yaml=True,
                 connect_timeout=socket.getdefaulttimeout()):
        self.port = port
        self.host = host
        if parse_yaml:
            try:
                import yaml
            except ImportError:
                parse_yaml = False

        self.parse_yaml = parse_yaml

        self.server_errors = ["OUT_OF_MEMORY", "INTERNAL_ERROR", "BAD_FORMAT", "UNKNOWN_COMMAND"]

        self._connect_timeout = connect_timeout
        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connect()
Пример #51
0
    def start(self, tcp_port):
        try:
            self._tcp_server = socket.socket()
            self._tcp_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
                                        1)
            self._tcp_server.bind(('', tcp_port))
            self._tcp_server.listen(100)
        except socket.error as msg:
            self._tcp_server.close()
            logger.error("cannot start due to socket error: %s" % msg)
            return False
        self._greenlets = [gevent.spawn(f) for f in self._spawn_handlers]
        gevent.sleep(0)  # Make the greenlet start first and return

        logger.info("greenlet spawn and TCP server listens on %s:%s" %
                    self._tcp_server.getsockname()[:2])
        return True
Пример #52
0
    def __init__(self, counter, host, port):
        self.sock = socket.socket()
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)

        self.sock.bind((host, port))
        self.sock.listen(24511)

        for process_id in range(counter):
            p1 = Process(target=self.handle_process,
                         args=(
                             self.sock,
                             process_id,
                         ))
            p1.start()
        print("Server started at http://%s:%s Running core:%s" %
              (host, port, counter))
Пример #53
0
 def test(self):
     sock = socket.socket()
     sock.connect(('127.0.0.1', self.server_port))
     try:
         sock.settimeout(0.1)
         try:
             result = sock.recv(1024)
             raise AssertionError(
                 'Expected timeout to be raised, instead recv() returned %r'
                 % (result, ))
         except socket.error:
             ex = sys.exc_info()[1]
             self.assertEqual(ex.args, ('timed out', ))
             self.assertEqual(str(ex), 'timed out')
             self.assertEqual(ex[0], 'timed out')
     finally:
         sock.close()
Пример #54
0
def graphite_worker():
    """The worker pops each item off the queue and sends it to graphite."""
    print 'connecting to graphite on (%s, %s)' % (HOST, PORT)
    sock = socket()
    try:
        sock.connect((HOST, PORT))
    except Exception as e:
        raise Exception(
            "Couldn't connect to Graphite server {0} on port {1}: {2}".format(
                HOST, PORT, e))
    print 'done connecting to graphite'

    while True:
        data = graphite_queue.get()
        print "graphite_worker: got data {0!r}".format(data)
        print "sending data"
        sock.sendall(data)
Пример #55
0
def get_server_certificate(addr, ssl_version=PROTOCOL_SSLv23, ca_certs=None):
    """Retrieve the certificate from the server at the specified address,
    and return it as a PEM-encoded string.
    If 'ca_certs' is specified, validate the server cert against it.
    If 'ssl_version' is specified, use it in the connection attempt."""

    host, port = addr
    if (ca_certs is not None):
        cert_reqs = CERT_REQUIRED
    else:
        cert_reqs = CERT_NONE
    s = wrap_socket(socket(), ssl_version=ssl_version,
                    cert_reqs=cert_reqs, ca_certs=ca_certs)
    s.connect(addr)
    dercert = s.getpeercert(True)
    s.close()
    return DER_cert_to_PEM_cert(dercert)
Пример #56
0
 def send_udp_request(self, host, port, payload, timeout):
     """Send udp payloads by port number.
     """
     data = ''
     try:
         with contextlib.closing(socket.socket(AF_INET,
                                               SOCK_DGRAM)) as client:
             client.settimeout(timeout)
             client.sendto(payload, (host, port))
             while True:
                 _, addr = client.recvfrom(SOCKET_READ_BUFFERSIZE)
                 if not _:
                     break
                 data += _
     except Exception as err:
         return None
     return data
Пример #57
0
    def get_socket(self, level='', flag=True):
        """
        与域名WHOIS信息注册商进行连接查询,level表示顶级或者二级查询,flag表示是否需要添加"="标志
        Args:
            level: 查询WHOIS顶级注册商(top),还是二级注册商(second)
            flag: 是否需要在查询域名前增加标志位'=',True不添加,False为添加
        
        Returns:
            data_result: 返回在域名注册商查询所得到的结果
        
        Exception:
            1、socket错误,连接或发送造成错误
            异常则返回False
        """
        if flag:  #判断是否需要包含标志位'='
            query_domain = self.domain  # 无flag

        else:
            query_domain = '=' + self.domain  # 有'='

        # 顶级、二级域名查询
        if level == 'top':
            if type(self.top_whois_server) == list:  # 若WHOIS注册商为列表,则随机选择一个
                HOST = choice(self.top_whois_server)
            else:
                HOST = self.top_whois_server
        elif level == 'second':
            HOST = self.sec_whois_server

        data_result = ''
        PORT = 43
        BUFSIZ = 1024
        ADDR = (HOST, PORT)
        EOF = "\r\n"
        data_send = query_domain + EOF
        try:
            tcpCliSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            tcpCliSock.connect(ADDR)
            tcpCliSock.settimeout(15)
            tcpCliSock.send(data_send)
        except socket.error, e:
            # print 'Socket Wrong'
            print e
            tcpCliSock.close()
            return False
Пример #58
0
    def main(self, name, mesh, host, port, parent):
        """."""
        state = 'unconnected'
        sock = None
        to = 1
        up = False

        dataq = queue.Queue()
        last_heard_from = None

        while True:

            if state == 'unconnected':
                if sock is None:
                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

                sock.setTimeout(0.1)
                try:
                    sock.connect((host, port))
                except (socket.error, gevent.Timeout):
                    to = to + random.random() * self.variance
                else:
                    state = 'connected'
                    receiver = gevent.spawn_link(self.recv, sock, dataq)
                    sender = gevent.spawn_link(self.send, sock, dataq)
                    to = 0

                to = to + random.random() * self.variance

            if up and state != 'connected':
                if last_heard_from 

            try:
                pat, msg = self.receive(self.DIE, self.DATA,
                                        timeout=to)
            except gevent.LinkedExited:
                # Our receiver died for some reason.
                state, sock = 'unconnected', None
                continue
            else:
                if pat is self.DIE:
                    # The endgame.  Someone told us to die.
                    break
                elif pat is self.DATA:
                    pass
Пример #59
0
def _tcp_listener(address,
                  backlog=50,
                  reuse_addr=None,
                  family=_socket.AF_INET):
    """A shortcut to create a TCP socket, bind it and put it into listening state."""
    sock = socket(family=family)
    if reuse_addr is not None:
        sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, reuse_addr)
    try:
        sock.bind(address)
    except _socket.error as ex:
        strerror = getattr(ex, 'strerror', None)
        if strerror is not None:
            ex.strerror = strerror + ': ' + repr(address)
        raise
    sock.listen(backlog)
    sock.setblocking(0)
    return sock
Пример #60
0
    def ping(self, addr='localhost', port=53):
        """
        js9 'print(j.servers.dns.ping(port=53))'
        """

        address = (addr, port)
        message = b'PING'
        sock = socket.socket(type=socket.SOCK_DGRAM)
        sock.connect(address)
        print('Sending %s bytes to %s:%s' % ((len(message), ) + address))
        sock.send(message)
        try:
            data, address = sock.recvfrom(8192)
        except Exception as e:
            if "refused" in str(e):
                return False
            raise RuntimeError("unexpected result")
        return True