def run(socket):
socket.bind((address, port))
socket.listen()
launched_event.set()
try:
socket.accept(timeout=self.DEFAULT_TIMEOUT)
self.end_event.wait()
socket.free()
except Exception, e:
traceback.print_exc(e)
self.network.close()
def Serve(socket, upload=True, download=True):
while True:
(s, addr) = socket.accept()
if upload:
thread.start_new_thread(Spew, (s, ))
if download:
thread.start_new_thread(Sink, (s, ))
def accept_client_to_secure_channel(socket):
conn, addr = socket.accept()
# 首次连接，客户端会发送diffle hellman密钥
ip = conn.recv(1024)
certname = ip + "_cert.pem".encode()
# 把服务器的证书发送给客户端
with open("admin_cert.pem", 'rb') as f:
server_cert = f.read()
f.close()
conn.send(server_cert)
client_cert = conn.recv(1024)
with open(certname, 'wb') as f:
f.write(client_cert)
f.close()
# 计算出共享密钥
their_secret = crypt.getpk_from_cert(client_cert)
shared_secert = crypt.get_shared_secret(their_secret)
sc = SecureChannel(conn, shared_secert)
return sc
def serve(self):
while True:
try:
inputready,outputready,exceptready = select.select(self.servers.keys(), [], [], 0)
except e:
print e
break
for socket in inputready:
if socket == self.server:
client, address = socket.accept()
self.recvConnection(client, address)
else:
try:
data = socket.recv(2048)
if data:
if self.servers[socket].ready:
self.recvData(socket, data)
else:
self.recvHandshake(socket, data)
else:
self.dropConnection(socket)
except:
self.dropConnection(socket)
time.sleep(0.05)
for client in self.servers.keys():
if client != self.server:
frame = self.servers[client].popFrameBuffer()
if frame != None:
self.handler[frame.opcode](client, frame)
self.server.close()
def send_shares(shares):
socket = setup_socket(8109)
i = 0
while True:
connection, address = socket.accept()
connection.sendall('Sending shares!'.encode())
connection.send(shares[i].encode())
def serve(self, socket):
"""
This works a little differently from a normal server:
1. We tell the car that we support HFP over SDP
2. We wait for the car to connect to us to get its MAC address
the connection the car makes is not suitable for AT commands, even
though the car tries to send us AT commands over it. Any replies we
send to the car over RFCOMM are lost.
3. We query the car's MAC address over SDP for HFP (111e). Be aware that
some cars (like my Ford Focus) will refuse to list all services they
offer over SDP. However, you will receive a reply if you query for HFP
specifically. We will get the channel number to connect to over SDP.
4. We initiate an RFCOMM connection to the car on the correct port for it.
"""
while True:
connection, address = socket.accept()
port = bluetooth.find_service(uuid="111e",
address=address[0])[0]['port']
connection.close()
print("HFP connecting to %s on port %i" % (address[0], port))
connection = common.Socket()
time.sleep(1)
connection.connect((address[0], port))
self.connected = True
while self.connected:
request = self.request_handler.decode(connection)
self.process_request(connection, request)
def __init__(self,socket):
Thread.__init__(self)
(conn, (ip,port)) = socket.accept()
self.conn = conn
self.ip = ip
self.port = port
print "[+] New thread started for "+ ip+ ":"+port
def listenAndCreateNewSession():
max_connections = 50
while True:
socket.listen(max_connections)
clientSocket, addr = socket.accept()
example = Oracle(key, flag, IV, message, clientSocket, addr)
return
def init():
socket.bind(('', 1550))
socket.listen(5)
print('Waiting for connexion...')
client, address = socket.accept()
print("{} connected".format(address))
print('Generate key...')
key = Fernet.generate_key()
print('Done')
print('Saving key with base64...')
with open('key_for_' + str(address) + '.txt', 'w') as f:
f.write(base64.b64encode(key).decode('utf-8'))
f.close()
print('Done')
print('Sending key...')
client.send(base64.b64encode(key))
print('Done')
def main():
print("[HTT] Start server")
socket = HTTPSocket()
print("[HTT] bind 8080")
socket.bind(8080)
# get connection
conn, addr = socket.accept()
while conn is not None:
thread = HTTPMainThread(conn, 1024, addr[0], addr[1])
thread.run()
conn, addr = socket.accept()
def accept(self, socket, m):
conn, addr = socket.accept()
conn.setblocking(False)
#self.add_socket_to_group(conn)
self.connection_without_team_name[conn] = ""
self.selector.register(conn, selectors.EVENT_READ, self.recv_user_name)
def accept_multi_connections(): #|
global conn #|
global clients #|
global client_address #|
#|
clients = [] #|
client_address = [] #|
for connection in clients: #|
connection.close(
) # This will close all connections each time the server runs, a way to ensure signal is constantly refreshed.
#del clients[:] # These two will clear out the client connection and address list every time server runs.
#del client_address[:] #|
#while 1: #|
try: #|
conn, address = socket.accept() #|
conn.setblocking(
1
) # This sets blocking timeout to infinty. It works with the connection object[conn] not the whole socket
clients.append(conn) #|
client_address.append(address) #|
banner() #|
interactive_shell() #|
conn.close(
) # Offcourse you have to close your connection to complete action. #|
except Exception as sok_Err: #|
print('\n') #|
print(ERROR + 'Failed to receive socket connection from target: ' +
str(sok_Err)) #|
def serve(self):
self._running = True
socket = evtapi.tcp_listener((self.host,self.port))
while self._running:
client, _ = socket.accept()
Dispatcher(client,self.mapper).dispatch()
socket.close()
def get_connect(socket, number):
print("I am thread number", number)
clientsocket, address = socket.accept()
clientsocket.send(b'Please enter your name: ')
name = clientsocket.recv(1024)
name = name.decode("utf-8")
messages[name] = []
print(name, 'is connected')
while True:
data = clientsocket.recv(1024)
if data == b'q':
print(name, 'left the chat')
break
else:
if data != b'.':
message = name + ':' + data.decode("utf-8")
print(message)
for key in messages:
if key != name:
messages[key].append(message.encode("utf-8"))
while True:
if bool(messages[name]):
clientsocket.send(messages[name].pop(0) + b'\n')
else:
break
def accept_wrapper(socket):
conn, addr = socket.accept()
print("Accepted connection from", addr)
conn.setblocking(False)
data = types.SimpleNamespace(addr=addr, inb=b'', outb=b'')
events = selectors.EVENT_READ | selectors.EVENT_WRITE
sel.register(conn, events, data=data)
def replicate_func(socket):
conn1, addr1 = socket.accept()
BUFSIZE = 1024
print("Debug: Inside Broad_cast_func")
while True:
print('New connection from %s:%d' % (addr1[0], addr1[1]))
data = conn1.recv(BUFSIZE)
command = data.split()
if not data:
break
elif command[0] == 'exit':
conn1.send('\0')
quit(conn)
else:
print(data)
for i in command:
print("Debug: Value of command received:")
print(i)
if command[0] == 'set': #Handling set command
key = command[1]
value = command[2]
time_id = command[3]
#data_1 [key] = value
#time_1 [key] = time_id
#update = 1
# print ("Debug: printing dict value: ")
# print data_1
# print time_1
success = set_func(key, value, time_id)
print("%s", success)
def accept(self, socket, selector):
connection, address = socket.accept()
logging.info('accepted connection from ' + str(address))
connection.setblocking(False)
data = types.SimpleNamespace(addr=address, intb=b'', outb=b'')
events = selectors.EVENT_READ | selectors.EVENT_WRITE
selector.register(connection, events, data=data)
def Serve(socket, upload=True, download=True):
while True:
(s, addr) = socket.accept()
if upload:
thread.start_new_thread(Spew, (s,))
if download:
thread.start_new_thread(Sink, (s,))
def imageStreamer(socket):
cam = cv2.VideoCapture(0)
socket.bind(("",8081)) # 8081 is the port this socket will be listening for, this number has to match the video port assigned in the app.
socket.listen(1)
cam.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, 1280)#modify to set camera resolution width
cam.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, 720)#modify to set camera resolution height
imageQuality = 50 #1-100 higher = better quality but more data
# set flip image to True if you want the image to be flipped
flipImage = False
while True:
try:
client,address = socket.accept()
ret,camImage = cam.read()
if flipImage:
camImage = cv2.flip(camImage,1)
# reduce size of image for potentially faster streaming. Keep the 'fx' and 'fy' values the same or the image will become skewed.
camImage = cv2.resize(camImage, (0,0), fx=0.5, fy=0.5)
byteString = bytes(cv2.imencode('.jpg', camImage,[int(cv2.IMWRITE_JPEG_QUALITY), imageQuality])[1].tostring())
fileSize = len(byteString)
totalSent = 0
byteString = structureByteHeader(str(fileSize).encode(),8)+byteString
totalSent = 0
while totalSent < fileSize:
totalSent += client.send(byteString[totalSent:])
except Exception as e:
print(e)
break
def run(self):
import socket
# Create the server socket for receiving commands from the web interface.
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('127.0.0.1', 3126))
# become a server socket
s.listen(5)
try:
# Set the last schedule run time to now so that the first time round it won't run anything.
last_schedule_run_time = datetime.datetime.now().time()
while not self.got_sigterm():
ready_to_read, ready_to_write, in_error = \
select.select(
[s],
[],
[],
10)
for socket in ready_to_read:
conn, addr = socket.accept()
returned = conn.recv(1024)
self.logger.warn(returned)
conn.send(bytes("Confirmed", 'UTF-8'))
conn.close()
run_schedule(last_schedule_run_time, self.logger)
last_schedule_run_time = datetime.datetime.now().time()
self.logger.info("I'm working...")
finally:
s.close()
def run(self):
"""main loop : accepts incoming connections and receive messages"""
self.log("run")
while True:
sockets_to_read = select.select([self.server_socket] + self.connected_clients + list(self.logged_clients.values()), [], [])[0]
self.log("sockets_to_read : {}".format(sockets_to_read))
for socket in sockets_to_read:
if socket is self.server_socket:
self.log("new connection")
# accept the new connection
client_socket = socket.accept()[0]
# add it to the client sockets list
self.connected_clients.append(client_socket)
else:
self.log("new message")
try:
message = self.read_message(socket)
if message:
self.log(message.decode(ENCODING))
self.handle_message(message, socket)
else:
# the client has properly disconnected
self.close_client(socket)
except ConnectionResetError:
# the client has abruptly disconnected
self.error("connection reset for socket {}".format(socket))
self.close_client(socket)
# clean up
self.server_socket.close()
def listen_broadcast(socket):
c, addr = socket.accept()
# wait for message to be sent
while True:
msg = c.recv(4096)
#checks if message has been received, only runs following code upon submission of a vote
if msg:
#turns message into utf-8
msg = msg.decode('utf-8')
msg = json.loads(msg)
#print(msg)
#clientsocket.send("received".encode('utf-8'))
#break out of while loop
break
#Close connection
#socket.close()
# take information out of dictionary and put into block
block = Block(msg['index'], msg['parent_hash'], msg['data'])
block.index = msg['index']
block.hash = msg["hash"]
block.hashed = msg["hashed"]
block.parent_hash = msg["parent_hash"]
block.timestamp = msg['timestamp']
block.nonce = msg['nonce']
block.data = msg['data']
return block
def createnewchannel(self, socket, host, port, client_name):
#socket.listen(100)
print("Channel Info:")
print("IP Address: " + host)
print("Channel Clientid:" + str(port))
print("Waiting for users....")
client_sock, addr = socket.accept()
print("UserId " + str(addr[1]) + "connected to the channel")
print("Enter Bye to exit the channel")
#client_sock.connect((host, port))
while True:
try:
userMeg = client_sock.recv(4096)
userMeg_decode = pickle.loads(userMeg)
for x, y in userMeg_decode.items():
print(x + ": " + y)
user_input = input(str(client_name) + ": ")
user_input = str(user_input)
user_name_msg[client_name] = user_input
if "bye" in user_input:
print("You have disconnect server")
break
user_encode = pickle.dumps(user_name_msg)
client_sock.send(user_encode)
except:
print("Client Disconnected!")
break
def do_accept(socket, mask):
logging.info("Accepting new client...")
# When SSL is turned on, this can block waiting for the client to send an SSL handshake.
# Maybe consider running it in a thread, too? (That's a lot of threading though. And
# clients are more under our control than remote servers are.)
try:
connection, address = socket.accept() # and hope it works
except ssl.SSLError as e:
logging.error("SSL error in do_accept(): {}".format(e))
return
except Exception:
kind, val, traceback = sys.exc_info()
logging.error("Error in do_accept(): {}".format(val))
return
logging.info("Accepted {} from {} (mask={}).".format(
repr(connection), repr(address), repr(mask)))
if cfg.get("warn_about_connections", True):
self.wall("A client has connected from {}.".format(
repr(address)))
self.socket_wrappers[connection] = LocalClient(connection)
self.unauthenticated_sockets += [connection]
self.sel.register(connection, selectors.EVENT_READ)
try:
self.socket_wrappers[connection].add_filters(
client_filters, self.filter_prototypes)
except FilterSpecificationError as e:
self.socket_wrappers[connection].tell_err(
"Error setting up client filters: {}".format(str(e)))
def __init__(self, socket):
Thread.__init__(self)
(conn, (ip, port)) = socket.accept()
self.conn = conn
self.ip = ip
self.port = port
print "[+] New thread started for " + ip + ":" + port
def loop(self):
while not self.stop or self.clientManager.clients:
read = []
write = []
error = []
for client in self.clientManager.clients:
if client.shouldSelectForRead:
read.append(client)
if client.shouldSelectForWrite:
write.append(client)
if client.shouldSelectForError:
error.append(client)
if not self.stop:
# Add the server only if we're not stopping it
read.append(self.ssocket)
readable, writable, errored = select(read, write, error)
for socket in readable:
if socket is self.ssocket:
self.clientManager.clientJoined(*socket.accept())
else:
if not socket.read():
# Client left
self.clientManager.clientLeft(socket)
def serve(self):
self._running = True
socket = evtapi.tcp_listener((self.host, self.port))
while self._running:
client, _ = socket.accept()
Dispatcher(client, self.mapper).dispatch()
socket.close()
def accept(self, socket, peers_addr_listen_socket):
"""
listening connection from other peers
:param socket: socket
:param peers_addr_listen_socket: (str, int)
"""
while True:
peer_socket, peer_addr_port_tuple = socket.accept()
# peer_addr => (ip, port)
peers_addr_listen_socket[peer_addr_port_tuple] = peer_socket
logger.debug(" recv socket from " + str(peer_addr_port_tuple),
extra=self.my_detail)
try:
temp_thread = threading.Thread(
target=self.receive_from_one_peer_newline_delimiter,
args=(peer_addr_port_tuple, ))
temp_thread.daemon = True
temp_thread.start()
# _thread.start_new_thread(self.receive_from_one_peer_newline_delimiter, (peer_addr_port_tuple, ))
logger.debug(" creating recv thread successful => " +
str(peer_addr_port_tuple),
extra=self.my_detail)
except Exception as e:
logger.debug(" creating recv thread failed => " +
str(peer_addr_port_tuple),
extra=self.my_detail)
def manual():
print('Starting manual mode...')
turret_active = True
# bind pwm in @arduino via nanpy (knob) to turret rot
# bind 2/3-pos switch to tilt via nanpy
# bind 2-pos switch to capture start/stop + delay writz via console
try:
# delay is stored in capture.cfg - could add user prompt for auto file write later
duration = input('How long do you want capture to run (seconds)? ')
name = input('What name do you want for your KLG file? ')
destination = '/home/logger/logs/' + name + '.klg'
print('Destination is: ' + destination)
capture.prepare_and_run_capture(duration, destination) # mandatory
turret = Turret()
print('Starting client...')
vehicle.start_client('192.168.0.102', 'pi', 'aqw743zsx') # start client
print('Listening to client for ' + duration + ' seconds...')
socket.listen(5) # listening for radio_knob_level update
client, address = socket.accept()
print("{} connected".format( address ))
print("Press Ctrl+C to stop...")
last_pwm_input = int(787/2)
last_tilt_input = int(787/2)
max_time = time.time() + int(duration)
while(turret_active):
response = client.recv(255)
try:
response_int = int(response)
print('Int response: ' + str(response_int))
response_str = str(response_int)
except:
print('Bad data received from client...')
if response != "":
radio_knob_level = int(response_str[0] + response_str[1] + response_str[2] + response_str[3])
print('Pan: ' + str(radio_knob_level))
radio_tilt_level = int(response_str[4] + response_str[5] + response_str[6] + response_str[7])
print('Tilt: ' + str(radio_tilt_level))
# execute command after data fetch
turret.write_pwm_pan(radio_knob_level, last_pwm_input)
turret.write_pwm_tilt(radio_tilt_level, last_tilt_input)
last_pwm_input = radio_knob_level
last_tilt_input = radio_tilt_level
if radio.get_2_pos_level() >= 100:
turret_active = False
elif time.time() > max_time:
turret_active = False
print("Closing server connection...")
client.close()
socket.close()
manual_stop()
except KeyboardInterrupt:
sys.exit("The program will now stop.")
def run(self):
while not self._stop_event.is_set():
events = self._poller.poll()
for fd, flag in events:
if fd == self._pipe[0]:
# Stop requested
for client in (client for client in self.fd_map.values() if client is not self.server):
self._poller.unregister(client)
client.close()
self.fd_map = {}
break
socket = self.fd_map[fd]
if flag & (select.POLLIN | select.POLLPRI):
# Ready to read
if socket is self.server:
sock, addr = socket.accept()
if self.use_ssl:
try:
client_sock = ssl.wrap_socket(sock,
server_side=True,
certfile=self.cert,
keyfile=self.key)
except ssl.SSLError:
sock.close()
continue
else:
client_sock = sock
client = self.client_cls(client_sock, self.handler)
self.fd_map[client.fileno()] = client
self._poller.register(client, READ_WRITE)
else:
data = socket.recv(1024)
if data:
socket.data_received(data)
else:
self.fd_map.pop(fd)
self._poller.unregister(socket)
socket.close()
elif flag & select.POLLHUP:
# Client hung up
self.fd_map.pop(fd)
self._poller.unregister(socket)
socket.close()
elif flag & select.POLLOUT:
# Ready to send
try:
data = socket.write_queue.get_nowait()
except Queue.Empty:
pass
else:
if data is WSClientClose:
socket.close()
else:
socket.send(data)
elif flag & select.POLLERR:
# Error
self.fd_map.pop(fd)
self._poller.unregister(socket)
socket.close()
def newConnections(socket):
while True:
sock, address = socket.accept()
global total_connections
connections.append(Client(sock, address, total_connections, "Name", True))
connections[len(connections) - 1].start()
print("New connection at ID " + str(connections[len(connections) - 1]))
total_connections += 1
def run(self):
while True:
socket.listen(5)
client, address = socket.accept()
response = client.recv(1000000)
serponse = parse(response)
if serponse != "":
print serponse
def main():
print "Starting server..."
options.read_configuration()
socket = get_socket()
while True:
print "Waiting for clients on TCP port " + globals.port
sock, addr = socket.accept()
Connect(sock, addr).start()
def handle_request(self, socket):
request, client_address = socket.accept()
request = ssl.wrap_socket(request, keyfile=server_pkey, certfile=server_cert,
server_side=True)
self.log(client_address)
prox = Proxy()
prox.connect(request)
self.proxy.append(prox)
def __prepare_read(self, input_id):
input_format, socket, conn, file_like = self.inputs[input_id]
if not conn:
socket.listen(1)
c = socket.accept()
new_conn, addr = c
conn = new_conn
self.inputs[input_id] = (input_format, socket, conn, conn.makefile())
def main_loop(self, socket):
while True:
client_socket, client_address = socket.accept()
thread = Thread(target=self.handle_client_connection,
args=(client_socket, ),
daemon=True)
self.all_threads.add(thread)
thread.start()
def _accept_cb():
connection, client_address = socket.accept()
# Note: We don't have to put this socket in non blocking mode.
# This can cause crashes when sending big packets on OS X.
posix_connection = PosixSocketConnection(connection)
accept_callback(posix_connection)
def accept_client_to_secure_channel(socket):
"""
服务器建立安全通道
"""
conn, addr = socket.accept() # 这里仍然使用socket接收
sc = ExtendedSocket(conn)
print('安全通道建立成功')
return sc
def recvObj(socket):
new_sock, addr = socket.accept()
all_data = b''
while True:
data = new_sock.recv(BUFFER_SIZE)
if not data: break
all_data = all_data + data
return pickle.loads(all_data)
def connection(socket):
while True:
conn, address = socket.accept()
if address:
print("conn: {} \naddress: {}".format(conn, address))
break
print("connecting...\n")
time.sleep(2)
def get_player_connections(socket, connections):
while(len(connections) < MAX_PLAYERS):
connection, client_addr = socket.accept()
if connection and client_addr:
connections.append([connection, client_addr])
msg = connection.recv(MAX_MSG_SIZE)
print("player connected with message:" + msg)
connection.sendall("\"ok\"")
def _accept_cb():
connection, client_address = socket.accept()
# Note: We don't have to put this socket in non blocking mode.
# This can cause crashes when sending big packets on OS X.
posix_connection = PosixSocketConnection(connection)
accept_callback(posix_connection)
def main():
print "Starting server..."
options.read_configuration()
socket = get_socket()
while True:
print "Waiting for clients on TCP port " + globals.port
sock, addr = socket.accept()
Connect(sock, addr).start()
def connection_handler(self, socket):
conn, _ = socket.accept()
buffer = conn.recv(4096)
cmd = buffer.decode('utf-8')
if cmd == 'restart':
conn.close()
self.restart()
def Accept( q, socket, port, id ):
conn, addr = socket.accept()
message = Message.fromRaw( conn.recv(1024) )
if message.type == MessageType.AUTH:
response = Message( MessageType.CONNECT, { "port" : port, "id" : id, "name" : message.get("name") } )
q.put( response )
conn.send( response.raw() )
conn.close()
def newConnections(socket):
while True:
sock, address = socket.accept()
global total_connections
connections.append(Client(sock, address, total_connections, "Name", True))
connections[len(connections) - 1].start()
print("New connection at ID " + str(connections[len(connections) - 1]))
total_connections += 1
def action():
nonlocal socket, callback
handle, peer = socket.accept()
wrapper = Socket(handle)
def init( cb_data, cb_halt ):
wrapper.disconnect = lambda: self.__disconnect(handle)
self.__add(handle, lambda: self.__receive(handle, cb_data, cb_halt), cb_halt)
return []
return [(callback, (peer, wrapper, init))]
def bob_get_from_alice(socket,debug): #wait to accept a connection - blocking call alice_socket, addr = socket.accept() data = alice_socket.recv(getReadSizeFromBuffer()) if(debug): print ' this received from Alice: '+data return (alice_socket,data)
def accept(self, socket):
while True:
try:
conn, addr = socket.accept()
print "connected from ", addr
t = ServerWorker(conn, addr)
t.start()
except KeyboardInterrupt:
break
def socket_callback(self, socket, cond):
assert socket == self.socket
if cond == GObject.IO_IN:
(clientsocket, address) = socket.accept()
log.info('connected: %s', address)
self.listen_to_file(clientsocket.makefile('r', 1))
else:
log.info('cmdin_callback: %s %s', cmdin, cond)
return True
def accept(self, socket, server):
''' Server has given a socket parent to accept this client on.
Return an identifier; the socket fileno. '''
sock, addr = socket.accept()
self.socket = sock
self.address = addr
fileno = sock.fileno()
sock.setblocking(0)
return fileno
def listen(self):
self.socket.listen(5) # max queue connect requests
while True:
(client_socket, address) = socket.accept()
client_socket.setblocking(0)
# save file descriptor for later use
fd = client_socket.fileno()
sockets[fd] = client_socket
write_to_file()
def accept_connections(node):
socket = getattr(node, 'socket')
while True:
try:
conn, addr = socket.accept()
except:
break
conn_thread = Thread(target = readMessages, args = (conn,node))
conn_thread.start()
def requestPath(startX,startY,goalX,goalY):
os.system("./demo.out " + str(startX) + " "+ str(startY) + " "+ str(goalX) + " "+ str(goalY))
try:
conn, addr = socket.accept()
data = conn.recv(buffer_size)
parseAndUseData(data, nodeMap, screen,scale)
except:
conn.close()
socket.close()
return
def handle_connections(self):
rlist, wlist, xlist = select.select([self.http_socket, self.https_socket] + self.open_http_sockets + self.open_https_sockets, [], [])
for socket in rlist:
if socket is self.http_socket:
# handle the server http socket
client, address = socket.accept()
print 'Got a new connection from: ' + address[0]
self.open_http_sockets.append(client)
elif socket is self.https_socket:
# handle the server https socket
client, address = socket.accept()
self.open_https_sockets.append(client)
else:
# handle all other http sockets
if socket in self.open_http_sockets:
self.http_communication(socket)
elif socket in self.open_https_sockets:
self.https_communication(socket)
# endregion -------------Class-----------
def listen(self, socket):
try:
socket.listen(1)
self._print("Listening for 1 client...")
conn, address = socket.accept()
self._print("Accepted client connection...")
except Exception, e:
print e
print "Error listening for clients"
exit(1)
def _accept(self, socket, pipeline_factory):
# Gimme dat socket
channel, address = socket.accept()
fileno = channel.fileno()
# Set non-blocking
channel.setblocking(0)
# Return a pipeline object
return ChannelPipeline(
channel,
HandlerPipeline(pipeline_factory),
address)
def listensock(socket):
while True:
conn, addr = socket.accept()
while True:
data = conn.recv(1024)
st = str(data, encoding='utf-8').strip()
if not data or st == 'close':
print('close connection')
break
else:
print(st)
conn.send(data)
conn.close()
def process(self, timeout):
"""子类可以覆盖该process方法， 处理具体的I/O请求"""
if self.client_sockets:
#===
# select -- I/O multiplexing
# select 告诉内核对那些描述符（可读，可写，或异常条件）进行监测，及等待时间
# 只要其中的任何一个描述符有事件发生，即可返回
#===
readable, writeabe, exceptional = select.select(self.client_sockets, self.client_sockets, self.client_sockets, timeout)
# ===
# 处理可读的socket
# ===
for socket in readable:
if socket is self.server_socket:
# 如果是服务器的可读socket， 则准备接受客户端的连接
connection, client_addr = socket.accept()
print "Connection from ", client_addr
connection.setblocking(0)
self.client_sockets.append(connection)
# 缓冲数据队列
self.packages[connection] = ''
else:
# 如果不是服务器的可读socket， 则准备接受客户端发送的数据, buffer_size = 4096
package = socket.recv(self.buffer_size)
if len(package) > 4:
print RED("Receive Data:"), "%s \b from %s " % (package, socket.getpeername())
self.packages[socket] += package
# 解包操作
self.unpack_package(socket)
else:
# 没有可用数据的socket，断开连接
self.client_sockets.remove(socket)
del self.packages[socket]
socket.close()
# ===
# 处理可写的socket
# ===
while not self.send_message_queue.empty():
package = self.send_message_queue.get_nowait()
for socket in writeabe:
socket.send(package)
# ===
# 处理出错的socket
# ===
for socket in exceptional:
self.client_sockets.remove(socket)
del self.packages[socket]
socket.close()
def _connection( self, socket ): '''Signal callback: Invoked on incoming connections.''' socket, addr = socket.accept() socket.setblocking( 0 ) if addr: client = '%s:%d' % ( addr[ 0 ], addr[ 1 ] ) else: client = '' CORE.info( 'Incoming connection from %s' % client ) if self.__magic: self.__bucket.new( client, socket ) else: self.signal_emit( 'session_new', client, socket ) return True
