def start(keystore, keystorealias, keypass, keystorepassphrase, hostandport,
timeout):
verify(keystore, keystorealias, keypass, keystorepassphrase, hostandport)
sslContext = getOpensslContext(keystore, keystorealias, keypass,
keystorepassphrase)
socket = socket_any_family()
socket.settimeout(timeout)
hostandport = hostandport.split(":", 2)
socket.connect((hostandport[0], int(hostandport[1])))
sslConnection = Connection(sslContext, socket)
sslConnection.set_connect_state()
sslConnection.set_tlsext_host_name(hostandport[0].encode('utf-8'))
while True:
try:
sslConnection.do_handshake()
except OpenSSL.SSL.WantReadError:
rd, _, _ = select.select([socket], [], [], socket.gettimeout())
if not rd:
raise timeout('select timed out')
continue
except OpenSSL.SSL.Error as e:
raise ssl.SSLError('bad handshake: %r' % e)
break
sslContext.set_timeout(timeout)
sslConnection.send(b"GET / HTTP/1.0\r\n\r\n")
socket.recv(1024)
def _receive_message_bytes(self, socket):
"""Receives the message's header, gets the length, then receives the
body of the message.
"""
bytes_header = socket.recv(Message.HEADER_LENGTH)
if len(bytes_header) == 0:
raise ZeroLengthMessageException()
_, _, _, _, length = self._decode_header(bytes_header)
bytes_message_text = socket.recv(length)
return bytes_header + bytes_message_text
def run(self, socket):
socket.settimeout(3) # 设置超时时间
while self.__running:
try:
print("正在忙.....")
socket.recv(8192)
sleep(1)
break
except Exception:
print("超时处理")
break
def get_tracker_port(self) -> int:
""" Connects to the tracker via TCP and receive the port to reconnect to.
Returns:
A port number to connect to via.
"""
try:
socket, self_port = utils.bind_TCP_port("")
socket.connect((self.tracker_addr, self.main_tracker_port))
except PortBindingException:
_logger.error(f"Could select a port to bind to.")
return -1
except ConnectionRefusedError as e:
_logger.error(
f"Could not connect to tracker node to set up individual port. Error: {str(e)}."
)
return -1
msg = socket.recv(constants.MAX_BUFFER_SIZE).decode()
try:
port = int(msg)
except ValueError:
socket.close()
return -1
else:
socket.close()
return port
def _apns_read_and_unpack(socket, data_format):
length = struct.calcsize(data_format)
data = socket.recv(length)
if data:
return struct.unpack_from(data_format, data, 0)
else:
return None
def recv(self, buflen=1024, flags=0):
if self._sslobj:
if flags != 0:
raise ValueError("non-zero flags not allowed in calls to recv() on %s" % self.__class__)
return self.read(buflen)
else:
return socket.recv(self, buflen, flags)
def signHandle(socket):
# Get the login/register info from client
struct = socket.recv(BUFFRSIZE).decode()
stripped = ProtocolDeconstruct(struct)
# Client is trying to login into an existing account
if stripped[4] == 'L' or stripped[4] == 'l':
if accountExists(stripped[1], stripped[2]):
# Login exists
stripped[5] = 'GOOD LOGIN'
serverPrint('GOOD LOGIN', Fore.GREEN)
stripped[3] = getNickname(stripped[1])
return stripped
else:
stripped[5] = 'BAD LOGIN'
serverPrint('BAD LOGIN', Fore.RED)
return stripped
# Client is trying to create a new account
elif stripped[4] == 'R' or stripped[4] == 'r':
if not usernameExists(stripped[1]):
addAccount(stripped[1], stripped[2], stripped[3])
stripped[5] = 'GOOD REGISTER'
serverPrint('GOOD REGISTER', Fore.GREEN)
stripped[3] = (stripped[3], ) # ? TEST
return stripped
else:
stripped[5] = 'BAD REGISTER'
serverPrint('BAD REGISTER', Fore.RED)
return stripped
# Wrong request
else:
raise Exception('Invalid request')
def __init__(self, db):
self._ipcPath = db.getSettingPath()
SocketlikeIPC.__init__(self, self._ipcPath)
# super(type(self),self).__init__(self._ipcPath)
# if super(type(self),self)._connect():
if SocketlikeIPC._connect(self):
print('IPC connect succeed. Welcome back, administrator.')
return
print('IPC failed. proceeding with TCP.')
super(type(self)) #unbound
socket.__init__(self)
try:
socket.connect(self, ('racu.idea.sh', PortEnum.MAIN_SERVER.value))
lastPin = db.getConfig()
print('lastPin =', lastPin, len(lastPin))
pinmsg = int.to_bytes(
SocketEnum.PIN.value, 1, 'big') + int.to_bytes(
lastPin[0]) if 10**3 <= lastPin['lastPIN'] < 10**4 else b''
msg = ''
# while not msg:
socket.sendall(self, pinmsg)
msg = socket.recv(self)
if not msg:
print('main server connect error')
return
except:
print('main server connect error')
def session(name, socket, aeskey):
'''
handles the communication with the client
'''
while True:
msg = decrypt_aes(socket.recv(BUFFER_SIZE).decode('utf-8'), aeskey)
if msg.startswith('PUSH*'):
print('push recieved')
global VERSION
global FOLDER
f = open(
FOLDER + FILENAME.rsplit('.', 1)[0] + '_v' + str(VERSION) +
'.' + FILENAME.rsplit('.', 1)[1], 'w+'
) #FILENAME.rsplit('.',1)[*] splits the extension and filename
f.write(msg.split('*', 1)[1])
f.close()
VERSION += 1
broadcast(msg, mode='CUSTOM')
elif msg == 'QUIT':
send_aes_encrypted(socket, "Quitting", aeskey)
socket.close()
del clients[socket]
broadcast(LEFT_CHAT_MESSAGE.format(name), SYSTEM_MESSAGE_PREFIX)
break
else:
broadcast(msg, name)
def _get_command(self, socket: socket) -> BaseCommand:
try:
msg_header = socket.recv(settings.HEADER_LENGTH)
cmd_type, length = msg_header.decode(settings.FORMAT).split(" ", 1)
msg_content = socket.recv(int(length))
json = msg_content.decode(settings.FORMAT)
cmd = self._command_parser.parse(cmd_type, json)
cmd.context = self._get_command_context(socket)
return cmd
except ClientException:
raise
#TODO: more spcific error handling as to not assume problem with client
except:
raise MalformedInputException("Malformed input")
def recv():
'''Receive messages'''
while True:
# If the connection is lost, properly stop the program.
try:
data = socket.recv(buffer_size).decode('utf8')
except Exception:
socket.close()
print('The connection with the server has been lost')
print('Press ENTER to quit the program.')
exit()
# If the connection has been ended properly,
# just display this message and exit
if data == '':
print('Press ENTER to quit the program.')
exit()
# When receiving a message, uses this 'experimental' method to undisplay
# what the user was writing and display the message instead.
sys.stdout.write("\n") #Go to next line
sys.stdout.write("\033[A") #Cursor up
sys.stdout.write("\033[2K") #clear line
sys.stdout.write(data)
def __init__(self,db):
self._ipcPath=db.getSettingPath()
SocketlikeIPC.__init__(self, self._ipcPath)
# super(type(self),self).__init__(self._ipcPath)
# if super(type(self),self)._connect():
if SocketlikeIPC._connect(self):
print('IPC connect succeed. Welcome back, administrator.')
return
print('IPC failed. proceeding with TCP.')
super(type(self)) #unbound
socket.__init__(self)
try:
socket.connect(self,('racu.idea.sh', PortEnum.MAIN_SERVER.value))
lastPin = db.getConfig()
print('lastPin =', lastPin, len(lastPin))
pinmsg = int.to_bytes(SocketEnum.PIN.value, 1, 'big') + int.to_bytes(lastPin[0]) if 10**3<=lastPin['lastPIN']<10**4 else b''
msg = ''
# while not msg:
socket.sendall(self,pinmsg)
msg = socket.recv(self)
if not msg:
print('main server connect error')
return
except:
print('main server connect error')
def recv(self, buflen=1024, flags=0):
self._checkClosed()
if self._sslobj:
if flags != 0:
raise ValueError('non-zero flags not allowed in calls to recv() on %s' % self.__class__)
return self.read(buflen)
return socket.recv(self, buflen, flags)
def check(socket, pattern):
BUFFER_SIZE = 2048
# host = socket.gethostname()
while True:
msg = socket.recv(BUFFER_SIZE)
msg = msg.decode("utf-8")
print("CLIENT " + msg)
return re.search(pattern, msg.lower())
def recvall(socket):
data = b''
while True:
received = socket.recv(BUFF_SIZE)
data += received
if len(received) < BUFF_SIZE:
break
return data
def read_response(socket, code):
result = ""
exit_condition = False
while not exit_condition:
message = socket.recv(2048).lstrip()
result += message
exit_condition = message[0:4] == "{0} ".format(code)
return result
def process_message(self, socket):
recive_data = ""
while True:
data = socket.recv(1024).decode()
recive_data = recive_data + data
if ("\r\n" in recive_data):
break
return recive_data.split("\r\n")[0]
def drain_socket(self, socket):
received_data = bytearray()
while True:
chunk = socket.recv(1024)
received_data.extend(chunk)
if not chunk:
break
return received_data
def recv(self, buffersize, flags = 0, raw = False):
if not raw:
data = self._sslobj.recv(buffersize, flags)
#print("RECV: {0}".format(data))
return data
else:
data = socket.recv(self, buffersize, flags)
#print("RECV (raw): {0}".format(data))
return data
def recvall(sock, bite):
mes = b""
for i in range(bite):
rec = sock.recv(1)
mes += rec
if rec == b'' or rec is None:
raise timeout
elif len(mes) > 1 and mes[-2:] == b"\r\n":
return mes
def receive_file(file):
with open(CLIENT_HOME_PATH + file, 'w') as file:
while True:
m = socket.recv(recv_buffer_length)
if len(m) != 0:
file.write(m)
else:
break
return
def recv(self, buflen=1024, flags=0):
if self._sslobj:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to recv() on %s" %
self.__class__)
return self.read(buflen)
else:
return socket.recv(self, buflen, flags)
def receive_handler(self, socket, receive_block):
self.connection_status = True
while self.connection_status:
try:
receive_message = socket.recv(1024)
except:
break
receive_block.delete('1.0', END)
receive_block.insert(END, receive_message.decode())
def checkFilename(socket, numBytes):
data = ""
while len(data) < numBytes:
try:
data += socket.recv(numBytes - len(data))
except Exception as e:
print e.strerror
sys.exit(1)
return data
def recv(self, buffersize, flags=0, raw=False):
if not raw:
data = self._sslobj.recv(buffersize, flags)
#print("RECV: {0}".format(data))
return data
else:
data = socket.recv(self, buffersize, flags)
#print("RECV (raw): {0}".format(data))
return data
def recv_bytes(socket, n):
# Helper function to recv n bytes or return None if EOF is hit
data = b''
while len(data) < n:
packet = socket.recv(n - len(data))
if not packet:
return None
data += packet
return data
def RecvData(socket, requestedSize):
returnStream = ''
while len(returnStream) < requestedSize:
databytes = socket.recv(requestedSize - len(returnStream))
if databytes == '':
raise RuntimeError, "connection broken"
returnStream += databytes
return returnStream
def on_new_client(socket, addr, username):
while 1:
msg = socket.recv(size)
cipher = AESCipher(
self.serverRegistry.sRegistry[username]['private_key'])
msg = cipher.decrypt(msg)
# print addr,' >> ', msg
msg = json.loads(msg)
# stuff
return
def getRequest (socket) :
"""
receive bytes from a socket
socket the socket of the client
return a string containing the client's request
"""
request = socket.recv(MAX_FILE_SIZE)
request = bytes.decode(request)
print(request)
return request
def read(socket, mask, sel):
data = socket.recv(1024)
logger.info("Received Message from %s", socket)
if data: #If the data received is valid
msgQ.put((socket, data)) #Put it in the queue
else:
logger.info('Closing %s', socket) #Terminate that socket
sel.unregister(socket)
socket.close()
def recvbody(sock):
mes = b""
try:
while True:
rec = sock.recv(1)
if rec == b"":
return mes
mes += rec
except timeout:
return mes
def receive_data(socket, data_length):
print("In receive_data")
tmpbuffer = ""
data = ""
while len(data) < float(data_length):
print("receiving")
tmpbuffer = socket.recv(30000)
data += tmpbuffer
print("Returning data")
return data
def exchange_keys():
# at the beginning of the communication each other's
# public key and n get sent to the other
msg = '%s;%s' % cert.getPubKey()
socket.send(bytes(msg, 'utf8'))
keys = socket.recv(BUFSIZ).decode('utf8')
pub, n = keys.split(';')
global server_cert
server_cert = RSA(int(pub), int(n))
def send_recv(socket, msg, code):
if msg != None:
print "Sending==> ", msg
socket.send(msg + '\r\n')
recv = socket.recv(1024)
print "<==Received:\n", recv
if recv[:3] != code:
print '%s reply not received from server.' % code
return recv
def recvFile(socket, numBytes):
# Retrieve the given number of bytes.
data = "";
while len(data) < numBytes:
try:
data += socket.recv(numBytes - len(data))
except Exception as e:
print e.strerror
sys.exit(1);
return data
def send(self, topic, msg):
if type(topic) != bytes:
topic = bytes(str(topic), 'utf-8')
messagedata = bytes(json.dumps(msg), 'utf-8')
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect(self._relay_in)
socket.send(topic + b' ' + messagedata)
reply = socket.recv()
assert reply
def readClientMessage(self, socket):
data = socket.recv(1024)
if not data:
socket.close()
self.sockets.remove(socket)
return None
else:
print '\tRead:', data, 'on', id(socket)
tokens = string.split(data)
return tokens
def receiveData(socket, bytesNumber):
# data will collect the number of bytes
# will be called a number of times
# source: http://stackoverflow.com/questions/7174927/when-does-socket-recvrecv-size-return
data = "";
while len(data) < bytesNumber:
try:
data += socket.recv(bytesNumber - len(data))
except Exception as e:
print e.strerror
sys.exit(1);
return data
def recv(self, buflen=1024, flags=0):
self._checkClosed()
if self._sslobj:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to recv_into() on %s" %
self.__class__)
while True:
try:
return self.read(buflen)
except SSLError as x:
if x.args[0] == SSL_ERROR_WANT_READ:
continue
else:
raise x
else:
return socket.recv(self, buflen, flags)
"""
Created on 2012-12-22
@author: Administrator
"""
from socket import socket
HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)
socket = socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect(ADDR)
while True:
line = input('> ')
if not line:
break
socket.send(line.encode('utf-8'))
buffer = socket.recv(BUFSIZ)
if not buffer:
break
print(buffer.decode('utf-8'))
socket.close()
lContact = [c1, c2]
ss = socket(AF_INET, SOCK_STREAM)
ss.bind(('192.168.28.83', 4269))
ss.listen(5)
print("Serveur lancé en écoute")
msg = "\n 1 = findNom \n 2 = findTel \n 3 = addByNomTel \n 4 = deleteByNom"
print(msg)
socket, info = ss.accept()
while (True):
commande = socket.recv(16)
commande = commande.decode()
print(commande)
socket.send((sys.argv[1] + "\rtoast\n").encode())
if commande == "1":
nom = socket.recv(512)
nom = nom.decode()
c = findContactByNom(lContact, nom)
socket.sendto(c)
if commande == "2":
nom = socket.recv(512)
nom = nom.decode()
def recv (self, buflen=1024, flags=0):
if self._sslobj:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to sendall() on %s" %
self.__class__)
while True:
try:
return self.read(buflen)
except SSLError, x:
if x.args[0] == SSL_ERROR_WANT_READ:
continue
else:
raise x
else:
return socket.recv(self, buflen, flags)
def recv_into (self, buffer, nbytes=None, flags=0):
if buffer and (nbytes is None):
nbytes = len(buffer)
elif nbytes is None:
nbytes = 1024
if self._sslobj:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to recv_into() on %s" %
self.__class__)
while True:
try:
tmp_buffer = self.read(nbytes)
v = len(tmp_buffer)
def recv(self, *args, **kwargs): time.sleep(random.random() * seconds) return _socket.recv(self, *args, **kwargs)
