def _send_socket(self, cmd, rtnCmd, ip, port):
socket = self._socket
try:
_LOGGER.debug('Sending to GW {0}'.format(cmd))
self._read_unwanted_data()
socket.settimeout(30.0)
socket.sendto(cmd.encode(), (ip, port))
socket.settimeout(30.0)
data, addr = socket.recvfrom(1024)
if len(data) is not None:
resp = json.loads(data.decode())
_LOGGER.debug('Recieved from GW {0}'.format(resp))
if resp["cmd"] == rtnCmd:
return resp
else:
_LOGGER.error(
"Response from {0} does not match return cmd".format(
ip))
_LOGGER.error(data)
else:
_LOGGER.error("No response from Gateway")
except socket.timeout:
_LOGGER.error("Cannot connect to Gateway")
socket.close()
def run(self):
if self.timeout:
socket.settimeout(self.timeout)
while self.connected:
try:
recv=self.channel.recv(1024)
if recv:
new=b''
for r in recv:
if not r ==b'\0':
new+=r
elif r==b'\0':
newmsg=msg(new[:5],new[5:-5],new[-5])
MGSS.append(newmsg)
self.OnMsgRecv(newmsg)
new=b''
newmsg=0
## Errors ##
except socket.error as e:
if e.errno==errno.ETIMEDOUT:
continue
else:
self.connected=False
except socket.herror as e:
error_report(e)
self.channel.close()
self.connected=False
def connect(self):
# Initialize context
self.socket = None
if self.secure:
client_pfile, client_cert_file, ca_cert_file = self.secure
#server_pkey=crypto.load_privatekey(crypto.FILETYPE_PEM,server_ptext)
#server_cert=crypto.load_certificate(crypto.FILETYPE_PEM,server_cert_text)
#ca_cert=crypto.load_certificate(crypto.FILETYPE_PEM,ca_cert_text)
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.set_verify(SSL.VERIFY_PEER,
verify_client_certificate) # Demand a certificate
#ctx.use_privatekey(server_pkey)
#ctx.use_certificate(server_cert)
#ctx.use_verify_locations(ca_cert)
ctx.use_privatekey_file(client_pfile)
ctx.use_certificate_file(client_cert_file)
ctx.load_verify_locations(ca_cert_file)
self.socket = SSL.Connection(
ctx, socket.socket(socket.AF_INET, socket.SOCK_STREAM))
else:
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if self.timeout and socket != None:
try:
socket.settimeout(self.timeout)
except:
pass
self.socket.connect((self.hostname, self.port))
register_cmd = (0, "Register_Client", (os.environ["USER"],
os.environ["HOSTNAME"]))
self.queueCmd(register_cmd)
def sendFile(fname, socket):
blockSize = 32000
msg = ''
try:
source = open(fname, 'rb')
sizeBytes = os.path.getsize(fname)
utils.log('Sending file ' + fname + ' of ' + str(sizeBytes) + ' bytes')
bytesOut = 0
start = utils.getUTCTime()
prev = 0
for data in utils.chunked(source, blockSize):
utils.log('sending data ' + str(len(data)))
socket.sendall(data)
bytesOut += len(data)
if (bytesOut - sizeBytes) > 1024:
utils.log('WARNING - truncating send because send file appears to be growing.')
break;
diff = utils.getSecondsBetweenTwoDates(start, utils.getUTCTime())
diff = (int(diff/30))*30
if diff > prev:
prev = diff
utils.log('So far sent ' + str(bytesOut) + ' read')
utils.log('Completed send of ' + str(bytesOut) + ' bytes')
socket.settimeout(20)
c = socket.recv(4096)
utils.log('Received ' + repr(c))
return msg
#except(socket.error):
#utils.log("timeout in sendFile - possibly no received confirmation data")
except Exception, errorcode:
if errorcode[0] != "timed out":
utils.logTrace('Exception ' + repr(errorcode))
def __init__(self, socket, buffer):
self.__dict__['_socket'] = socket
self.__dict__['_buffer'] = buffer
self.__dict__['_io_refs'] = 0
self.__dict__['_closed'] = False
self.__dict__['_timeout'] = socket.gettimeout()
# We are setting the socket timeout to zero here, regardless of what it
# was before, because we want to operate the socket in non-blocking
# mode. This requires some context.
#
# Python sockets have three modes: blocking, non-blocking, and timeout.
# However, "real" (OS-level) sockets only have two: blocking and
# non-blocking. Internally, Python builds sockets with timeouts by
# using the select syscall to implement the timeout.
#
# We would also like to use select (and friends) in this wrapped
# socket, so that we can ensure that timeouts apply per
# ``send``/``recv`` call, as they do with normal Python sockets.
# However, if we did that without setting the socket timeout to zero
# we'd end up with *two* selectors for each socket: one used in this
# class, and one used in the socket. That's gloriously silly. So
# instead we take responsibility for managing the socket timeout
# ourselves.
socket.settimeout(0)
def threadPool(self, socket):
self.newslot.acquire()
while self.tcount >= self.MaxThreads:
self.newslot.wait() # wait for new client slots
self.tcount += 1 # update client counts
self.newslot.release()
while 1:
socket.settimeout(
10
) # set and update timeout at setup or after every input received
try:
strings = socket.recv(
1024) # try to recive input if connection is still valid
while len(strings) > 0:
strings = eval_input(
strings,
socket) # parsing, checking and operating commands
except:
self.newslot.acquire()
self.tcount += -1 # update client counts when clients drop out
self.newslot.notify(
) # notify a waiting client for the new slot avaliable
self.newslot.release()
socket.sendall('connection closed: timed out\n')
socket.close()
print('Disconnect one inactive connection.\n')
break
def recv(socket, size):
'''Recieve and decode data'''
try:
socket.settimeout(0)
recvd = socket.recv(size)
byteArray = recvd
if len(byteArray) > 0:
datalength = byteArray[1] & 127
indexFirstMask = 2
if datalength == 126:
indexFirstMask = 4
elif datalength == 127:
indexFirstMask = 10
masks = [m for m in byteArray[indexFirstMask : indexFirstMask+4]]
indexFirstDataByte = indexFirstMask + 4
decodedChars = []
i = indexFirstDataByte
j = 0
while i < len(byteArray):
decodedChars.append( chr(byteArray[i] ^ masks[j % 4]) )
i += 1
j += 1
ret = u''.join(decodedChars).encode('utf-8')
print('\033[32m' + ret.decode('utf-8') + '\033[0m')
return ret
else:
return None
except BlockingIOError:
return None
except TimeoutError:
return None
def send_data(data, socket, timeout=None):
if timeout is not None and timeout < 0:
raise Exception("Timeout cannot be lower than 0")
msg = pickle.dumps(data)
msg = bytes(f"{len(msg):<{HEADERSIZE}}", 'utf-8') + msg
socket.settimeout(timeout)
socket.sendall(msg)
def __init__(self,
asyncSocketsPool,
socket,
recvBufSlot=None,
sendBufSlot=None):
if type(self) is XAsyncSocket:
raise XAsyncSocketException(
'XAsyncSocket is an abstract class and must be implemented.')
self._asyncSocketsPool = asyncSocketsPool
self._socket = socket
self._recvBufSlot = recvBufSlot
self._sendBufSlot = sendBufSlot
self._expireTimeSec = None
self._state = None
self._onClosed = None
try:
socket.settimeout(0)
socket.setblocking(0)
if (recvBufSlot is not None and type(recvBufSlot) is not XBufferSlot) or \
(sendBufSlot is not None and type(sendBufSlot) is not XBufferSlot) :
raise Exception()
asyncSocketsPool.AddAsyncSocket(self)
except:
raise XAsyncSocketException(
'XAsyncSocket : Arguments are incorrects.')
def check():
try:
newstatus = []
#pick a timeout fast so that it can finish within (freq) seconds
socket.settimeout(self.timeout)
#perform a check on the ports
for port in self.ports:
#create socket to check port
active = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if (sock.connect_ex((self.host, port))):
#nonzero return means closed
newstatus.append(False)
else:
#zero means it's open
newstatus.append(True)
#close socket to check port
active.close()
except socket.error:
#socket may have other errors I'm not expecting, but...
log.error("Couldn't (re)connect to server at " + self.host)
#to represent this error to any API
newstatus = "connection error"
finally:
#update variables
self.safe = False
tmp = self.status
self.status = newstatus
self.prev = tmp
self.safe = True
def run(self):
""" Run the loop """
while True:
readable, writable, exceptable = select.select(
self.INPUTS, self.INPUTS, [])
for socket in readable:
# receive data from socket
socket.settimeout(5)
data = socket.recv(1024)
socket.settimeout(None)
# there is data to be received
if data:
# check the data
data = data.decode("utf-8")
print(data)
self.check_data(data)
# register on server
if not self.CONNECTED_SERVER:
self.handshake()
# join a channel
if self.CONNECTED_SERVER and not self.JOINED:
self.join()
# listen for commands
if self.CONNECTED_SERVER and self.JOINED and not self.PONG:
self.cmds(data)
# connection was closed
else:
self.CONNECTED_SOCKET = False
for socket in writable:
try:
# get the msg
next_msg = self.MESSAGES[socket].get_nowait()
except queue.Empty:
# shutdown
if self.SHUTDOWN:
sys.exit(0)
# redo handshake and close socket
if self.MIGRATE:
self.handshake()
self.MIGRATE = False
self.OLD_SCKT.close()
continue
else:
# send the msg
socket.send(next_msg)
def check():
try:
newstatus=[]
#pick a timeout fast so that it can finish within (freq) seconds
socket.settimeout(self.timeout)
#perform a check on the ports
for port in self.ports:
#create socket to check port
active = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if(sock.connect_ex((self.host, port))):
#nonzero return means closed
newstatus.append(False)
else:
#zero means it's open
newstatus.append(True)
#close socket to check port
active.close()
except socket.error:
#socket may have other errors I'm not expecting, but...
log.error("Couldn't (re)connect to server at " + self.host)
#to represent this error to any API
newstatus="connection error"
finally:
#update variables
self.safe=False
tmp=self.status
self.status=newstatus
self.prev=tmp
self.safe=True
def listen(self, count):
self.sock.listen(count)
#пауза
socket.settimeout(0.1)
logging.info("Server is listenning")
def connectTo(peer): socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) socket.settimeout(10) try: socket.connect(peer) except: return False return True
def __init__(self, socket, target_obj):
self.socket = socket
if socket.timeout is None:
socket.settimeout(.1)
self.target_obj = weakref.ref(target_obj)
self.thread = threading.Thread(target=self, daemon=True)
self.thread.start()
self.poison_ev = threading.Event()
def do_check(nowip, condition):
result = False
import OpenSSL
import socket
import re
context = OpenSSL.SSL.Context(OpenSSL.SSL.TLSv1_METHOD)
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.settimeout(1)
connection = OpenSSL.SSL.Connection(context, socket)
if condition["sni"]:
connection.set_tlsext_host_name(condition["host"])
try:
connection.connect(
(nowip, condition["port"]))
except KeyboardInterrupt:
exit()
except:
print(nowip + " Error")
return
connection.setblocking(True)
try:
connection.do_handshake()
except KeyboardInterrupt:
exit()
except OpenSSL.SSL.WantReadError:
print(nowip + " Timeout")
return
except:
print(nowip + " Error")
return
cert = connection.get_peer_certificate()
data = []
for no in range(0, cert.get_extension_count()):
if cert.get_extension(no).get_short_name() != b"subjectAltName":
continue
data = re.sub(
r"\\[\s\S]", "#",
re.sub(
r"\\x[0-9a-zA-Z]{2}", "#",
(str(cert.get_extension(no).get_data())
.replace(r"b\"", "").replace("\"", "")
.replace(r"b'", "")
.replace(r"'", "").replace("\\\\", "\\")))).split("#")
for item in data:
if item != "" and item != "0":
if item.find(condition["common_name_has"]) != -1:
print(nowip + " True, DNS Name=" + item)
result = True
else:
print(nowip + " False, DNS Name=" + item)
if len(data) == 0:
certname = OpenSSL.crypto.X509Name(cert.get_subject())
if certname.commonName.find(condition["common_name_has"]) != -1:
print(nowip + " True, CN=" + certname.commonName)
result = True
else:
print(nowip + " False, CN=" + certname.commonName)
return result
def jnr_updater():
print("Starting jnr_updater")
# start session with database
Session = sessionmaker(bind=engine)
session = Session()
# create socket and listen
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("0.0.0.0", JNRCOUNTER_PORT))
sock.listen(10)
while True:
# wait for connection
client, address = sock.accept()
# timeout the connection if the client takes to long to send a response
sock.settimeout(6)
print(f"Connection from {address[0]} on jnr port")
# TODO: replace this verification system with SSL
# create random string of bytes for verification
plaintext = bytes([random.randint(0, 0xff) for _ in range(16)])
# send encrypted verification string
print("Sending verification string")
client.send(aesenc.encrypt(plaintext) + b"\n")
try:
# receive new string and check if the connecting client can decrypt it
msg = client.recv(16)
if msg == plaintext:
print("Verification succeeded")
while True:
# once verification has succeeded, no time limit is required
sock.settimeout(None)
# receive the update to the number of people in the junior library (+x or -x)
print("Recieving message")
msg = client.recv(1024)
print(msg)
inc = eval(
msg + b"+0"
) # add a "+0" at the end in case the string has a trailing + or - (due to weird bug where requests get merged)
print(inc)
# update the count in the junior library
session.query(Count).first().jnrvalue += inc
session.commit()
else:
# if verification is failed, raise an error and let the try/except statement catch it
raise Exception("Verification failed")
except Exception as e:
socket.settimeout(None)
# print the error (due to verification taking too long, verification being unsuccessful, client closing the connection or some other unknown error
print(repr(e), "(recieved from jnr port)")
client.close()
def send(addr_dest, data, socket, filename, timeout): ##get
print("\n")
print("Requête get du fichier ", filename,
" vers l'adresse de destination = ", addr_dest)
data = data.decode()
data = data.split("\x00")
try:
blksize = data[4]
blksize = int(blksize)
except:
blksize = 512
print(blksize)
ack = 1
filename = filename
isExist = os.path.exists(filename)
if (not isExist):
print("Le fichier n'existe pas")
ack_error_msg = b'\x00\x05\x00\x11' + bytes("FILE NOT FOUND",
'utf-8') + b'\x00'
socket.sendto(ack_error_msg, addr_dest)
socket.close()
return
with open(filename, mode='rb') as f:
while True:
data_bytes = f.read(blksize)
print('data_bytes=', data_bytes)
data_paquet = b'\x00\x03' + ack.to_bytes(2, 'big') + data_bytes
print("Envoi du paquet", data_paquet)
socket.sendto(data_paquet, addr_dest)
socket.settimeout(timeout)
try:
data_ack, _ = socket.recvfrom(512) #ACK donc a ne pas changer
except:
print("Timeout exceeded")
timeout_error_msg = b'\x00\x05\x00\x05' + bytes(
"TIMEOUT", 'utf-8') + b'\x00'
socket.sendto(timeout_error_msg, addr_dest)
break
socket.settimeout(None)
print("Reception ACK:", data_ack)
ack_msg = (b'\x00\x04') + ack.to_bytes(2, byteorder='big')
if (ack_msg != data_ack):
print("Le ACK attendu ne correspond pas au ACK reçu")
ack_error_msg = b'\x00\x05\x00\x10' + bytes(
"ACK ERR", 'utf-8') + b'\x00'
socket.sendto(ack_error_msg, addr_dest)
break
ack += 1
if (len(data_bytes) < blksize):
print("Fin de l'envoi")
f.close()
socket.close()
break
f.close()
socket.close()
print("Requête get du fichier ", filename, "terminé")
def __init__(self, ip, socket, rQue, tQue):
threading.Thread.__init__(self)
self.threadDoneFlag = False
# TODO: increate timeout for dicrease network control interval
socket.settimeout(2.0)
self.trapData = ClientData(ip, socket, self, rQue, tQue)
self.logger = logging.getLogger("ClientThread[" + str(ip) + "]")
self.logger.setLevel(logging.DEBUG)
def scan_port(ip, port):
try:
socket.settimeout(2)
# default family=2, type=1, proto=0
s = socket.socket()
s.connect((ip, port))
s.close()
return True
except:
return False
def accept(self):
socket, addr = self._socket.accept()
socket.settimeout(STCPSocket.DEFAULT_TIME_OUT) # timeout for non-blocking socket
self._log(StdUsers.USER, StdLevels.INFO, "Server accepted {}.".format(addr))
self._log(StdUsers.DEV, StdLevels.INFO, "Server accepted {}.".format(addr))
socket = self._fromsocket(socket, addr, start_serve=True)
socket._is_working = True
return socket, addr
def __init__(self, socket, address, port, groups):
self.socket = socket
self.groups = groups
self.address = address
self.port = int(port)
self.id = "%s:%s" % (self.address, self.port)
self.stop_running = False
socket.settimeout(TIMEOUT)
threading.Thread.__init__(self)
def __init__(self, socket, *, max_message_bytes=0):
''' A max_message_bytes of <= 0 means unlimited, otherwise a positive
value indicates this many bytes to limit the message size by. This is
used by get(), which will raise MessageSizeExceeded if the message size
received is larger than max_message_bytes. '''
self.socket = socket
socket.settimeout(0)
self.recv_time = time.time()
self.max_message_bytes = max_message_bytes
self.recv_buf = bytearray()
self.send_buf = bytearray()
def register(self, socket, address, read=True, write=True, timeout=60):
socket.settimeout(timeout)
socket.setblocking(False)
events = (selectors.EVENT_READ if read else 0) | (selectors.EVENT_WRITE
if write else 0)
connection = Connection(address)
data = types.SimpleNamespace(
connection=connection,
address=address,
)
self.selector.register(socket, events, data=data)
return connection
def receive_from(self, socket):
buffer = ""
socket.settimeout(1)
try:
while True:
data = socket.recv(4096)
if not data:
break
buffer += data
except:
pass
return buffer
def handler(socket):
socket.settimeout(30.0)
while (True):
message = ""
try:
request = str(socket.recv(lilith_defines.recv_val))
except:
socket.close()
return
if (len(request) == 0):
socket.close()
return
method = request.split("\r\n")[0].split(" ")
if method[0] == "GET":
if (-1 == request.split("\r\n")[0].split(" ")[1].find("?")):
content, content_type, g_status = get.get(
request, lilith_defines.server_root)
message = make_http_header(status=g_status,
server=lilith_defines.server_name,
Content_Length=str(len(content)),
Content_Type=content_type) + content
else:
R = request.split("\r\n")[0].split(" ")[1].split("?")[0]
content, content_type, p_status = Lilith_action.post.post(
"POST " + R + " HTTP/1.1\r\n\r\n" +
request.split("\r\n")[0].split(" ")[1])
message = make_http_header(status=p_status,
server=lilith_defines.server_name,
Content_Length=str(len(content)),
Content_Type=content_type) + content
elif method[0] == "POST":
content, content_type, p_status = Lilith_action.post.post(request)
message = make_http_header(status=p_status,
server=lilith_defines.server_name,
Content_Length=str(len(content)),
Content_Type=content_type) + content
elif method[0] == "BOST":
while True:
if (request[-5:] == "[END]"):
break
try:
data = str(socket.recv(lilith_defines.recv_val))
except:
socket.close()
return
request += data
content, content_type, p_status = Lilith_action.post.post(
request[:-5])
message = make_http_header(status=p_status,
server=lilith_defines.server_name,
Content_Length=str(len(content)),
Content_Type=content_type) + content
socket.send(message)
def handleClient():
"""Check for new client connection and process the request
"""
global server, poller
# Note:don't call poll() with 0, that would randomly cause
# reset with "Fatal exception 28(LoadProhibitedCause)" message
res = poller.poll(1)
if res: # There's a new client connection
(socket, sockaddr) = server.accept()
socket.settimeout(0.02) # set timeout for readline to avoid blocking
handle(socket)
socket.close()
def listen(self):
self.sock.listen(10)
while True:
socket, address = self.sock.accept()
address = addressToBinary(address[0])
socket.settimeout(1)
self.clients[socket] = (None, address)
print("New connection: " + textIp(address))
thr1 = threading.Thread(target=self.listenToClient,
args=(socket, address)).start()
thr2 = threading.Thread(target=self.keepAliveClient,
args=(socket, 42)).start()
def __init__(self, socket):
self.udp_socket = socket
socket.settimeout(0)
self.vehicle_index = {}
self.team_index = {}
self._renderer = None
self.my_id = None
self._running = False
self._thread = None
def scanPortsTask(port):
import socket
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.settimeout(1.0)
try:
socket.connect((targetForScan, port))
with lock_output:
click.echo('port:' + str(port) + ' is open')
except Exception as e:
pass
def receive_from(self, socket):
buffer = ""
socket.settimeout(1)
try:
while True:
data = socket.recv(4096)
if not data:
break
buffer += data
except:
pass
return buffer
def tem_bastao(clisock, server_address):
global bastao, meunumero, first, tipobastao, maxtimeout
if (not first):
try:
# set timeout 5 second
socket.settimeout(10)
data, address = sock.recvfrom(const)
except:
print("Timeout! Tentando novamente...")
if (maxtimeout > 0):
maxtimeout-=1
tem_bastao(clisock, server_address)
else:
print('Cheque sua conexão e tente novamente')
clisock.close()
sys.exit(0)
message = data[1:-1].split(',')
sender = int(message[1])
# print ('enviado por "%d"' % sender)
# print ('recebido por "%d"' % meunumero)
if (meunumero == sender):
acertor = message[4]
if (acertor == 'True'):
print('Você destruiu um navio inimigo. Aguarde sua próxima jogada.')
else:
print ('Ataque enviado. Você atirou no vazio do oceano. Aguarde a sua vez.')
passa_o_bastao()
return
message = data[1:-1].split(',')
sender = int(message[1])
# print ('enviado por "%d"' % sender)
# print ('recebido por "%d"' % meunumero)
if (meunumero == sender):
acertor = message[4]
if (acertor == 'True'):
print('Voce destruiu um navio inimigo. Aguarde sua proxima jogada.')
else:
print ('Ataque enviado. Aguarde a sua vez.')
passa_o_bastao()
return
# print ('first')
print('Sua vez!')
first = False
targ = int(raw_input('Qual mapa deseja atacar? '))
xy = int(raw_input('Qual coordenada desse mapa? (De 1 a 25) '))
message = (tipojogada, meunumero, targ, xy, False)
# Send data
# print ('sending "%s"' % (message,))
sent = clisock.sendto(str(message), server_address)
print ('enviei')
def run(self):
cmd_input = threading.Thread(target=self.input).start()
while True:
readable, writable, exceptable = select.select(
self.INPUTS, self.INPUTS, [])
for socket in readable:
if not self.STATE is None:
time.sleep(5)
socket.settimeout(5)
data = socket.recv(1024)
socket.settimeout(None)
# there is data to be received
if data:
# check the data
data = data.decode("utf-8")
#
self.check_data(data)
# register on server
if not self.CONNECTED_SERVER:
self.handshake()
# join a channel
if self.CONNECTED_SERVER and not self.JOINED:
self.join()
# connection was closed
else:
self.CONNECTED_SOCKET = False
for socket in writable:
try:
# get the msg
next_msg = self.MESSAGES[socket].get_nowait()
except queue.Empty:
# shutdown
if self.SHUTDOWN:
sys.exit(0)
continue
else:
# send the msg
socket.send(next_msg)
def __init__(self, socket):
def condition():
for thread in enumerate_threads():
if thread.name == Logger.name:
return False
return True
super(LogServerSession, self).__init__(name=LogServerSession.name,
condition=condition, countdown=COUNTDOWN, latter=True)
self._mapping = {}
self._stream = LogSocketStream(self, socket)
socket.settimeout(self.quantum)
def __init__(self, socket, timeout = 1.0, bufsize = 4096):
threading.Thread.__init__(self)
self.message_buffer = {}
self.message_events = {}
self.open = False
self.socket = socket
self.write_lock = threading.Lock()
self.handler = None
self.bufsize = bufsize
socket.settimeout(timeout)
self.address = socket.getpeername()
def recMessage (socket): socket.settimeout(2) # time out of 2000ms length,address = receivingData(socket) length_str = str(length[0:]) ACK = '1' # ACK: 1 for message received, 0 for vise versea #sendSeg(ACK,socket,host,port) socket.sendto(ACK,address) #print length_str recData,address = receivingData(socket) socket.sendto(ACK,address) counter = recData[0] recData = recData[1:] return recData, address, counter
def receive_from(socket):
buffer = ""
#We need to set a timer because of the network latency
socket.settimeout(2)
try:
while True:
data = socket.recv(4096)
if not data:
break
buffer += data
except:
pass
return buffer
def KlientKeep():
socket.settimeout(20)
try:
recv = socket.recvfrom(13)[0]
except:
print("Spojenie bolo stratene")
return 1
else:
Keep = '1'
HEAD = struct.pack(">ciii", Keep[0].encode('ascii'), 0, 0, 0)
socket.sendto(HEAD, addr)
print("Spojenie je stale aktivne")
return 2
def recieve(addr_dest, data, socket, filename, timeout): #Put
data = data.decode() #
data = data.split("\x00")
try:
blksize = data[4]
blksize = int(blksize)
except:
blksize = 512
socket.sendto(b'\x00\x04\x00\x00', addr_dest) #On envoie l'ACK0
numPaquet = 1
with open(
filename, "wb"
) as f: #On ouvre un fichier dans lequel écrire les dats qu'on reçoit
while (True):
socket.settimeout(timeout)
try:
data, _ = socket.recvfrom(1500)
except:
print("Timeout exceeded")
timeout_error_msg = b'\x00\x05\x00\x05' + bytes(
"TIMEOUT", 'utf-8') + b'\x00'
socket.sendto(timeout_error_msg, addr_dest)
break
socket.settimeout(None)
if (data[:2] != b'\x00\x03'): #On vérifie l'opcode du paquet
print(
"Erreur : L'opcode du paquet reçu n'est pas celui attendu")
sys.exit(1)
onlyData = data[4:]
f.write(onlyData)
socket.sendto(
b'\x00\x04' + numPaquet.to_bytes(2, 'big'),
addr_dest) #On envoie un ACK avec le bon numéro de block
if (
len(onlyData) != blksize
): #Si le data reçu est plus petit que blksize, c'est le dernier paquet... #... donc on ferme la socket et on break
break
numPaquet += 1
socket.close()
pass
def Aztec(socket):
string = ""
socket.settimeout(1)
try:
while True:
data = socket.recv(4096)
if not data:
break
string += data
except:
pass
return string
def run_server(self, server):
socket, file = self._server_accept_connection(server)
threading.Thread(target=self._writer, args=[file]).start()
try:
while True:
line = file.readline()
if not line:
break
resp = json.loads(line)
self._process_response(resp)
socket.settimeout(HEARTBEAT_TIMEOUT)
finally:
self.close()
def _server_alive_watchog(self, socket, list_of_servers):
'''The watch dog listens if the server is still alive.
If not - sets a particular flag.
'''
socket.settimeout(WATCHDOG_PING)
try:
while self.is_alive:
message, address = socket.recvfrom(8192)
if message == '\DIE':
if address == globvar[1]: # If the registered server is the one that broadcasted, then it's alive
self.is_alive = False
print 'Watchdog thread ended!'
socket.close()
except Exception:
socket.close()
def recv_from(socket):
buffer = b""
socket.settimeout(TIMEOUT)
try:
while True:
data = socket.recv(4096)
if not data:
break
buffer += data
except:
pass
return buffer
def read_socket(socket, addr):
print 'Waiting for data from:', addr
socket.settimeout(None)
data = None
try:
msg = socket.recv(2048)
while msg:
if data:
data = data + msg
else:
data = msg
msg = socket.recv(2048)
except socket.timeout as msg:
print msg
except socket.error as msg:
print msg
return data
def sendSeg (data,socket,address,counter):
ACKreceived = False
socket.sendto(counter+data, address)
ACK = '0'
for i in range (0,2):
ACK,address = receivingData(socket)
#print ('inside loop' + ACK)
if ACK == '1': #if the message sent is received
#print ('sent onceeee')
counter = toggle(counter)
ACKreceived = True
return True,counter
break
socket.sendto(counter+data,address)
socket.settimeout(0.5) # time out of 500ms
if ACKreceived == False:
print >> sys.stderr, "Failed to send message. Terminating"
sys.stdout.flush()
exit(1)
def getMsg(socket):
global list
try:
ret=socket.recv(4096)
socket.settimeout(.1)
if str(ret) == "/quit" or str(ret) == "/Quit":
host,port=socket.getpeername()
print ("["+str(host)+" :"+str(port)+"] ha salido.")
list.remove(socket)
socket.close()
return None
return ret
except:
host,port=socket.getpeername()
print ("["+str(host)+" :"+str(port)+"] ha salido.")
list.remove(socket)
return None
def receive(socket):
global message_buf
while True:
if message_buf.find('\r\n') != -1:
break
else:
try:
socket.settimeout(10)
message_buf += socket.recv(500)
socket.settimeout(None)
except socket.error:
print('client> time out')
return
message_return = message_buf[0:message_buf.find('\r\n')]
message_buf = message_buf[message_buf.find('\r\n')+2: ]
return message_return
def listen_for_incoming_server(self,socket):
print "Listening for incoming packets from the server"
print "Receiving data..."
response = socket.recv(8192)
self.return_response_to_client(response)
print "Timeout: " + str(socket.gettimeout())
data = response
try:
while len(data) > 0:
socket.settimeout(socket.gettimeout() + 0.01)
print "Timeout: " + str(socket.gettimeout())
data = socket.recv(8192)
self.return_response_to_client(data)
print "Receiving more data..."
print "Length: " + str(len(data))
finally:
print "Response Length: " + str(len(response))
socket.close()
print "Killing thread..."
return
def take_picture():
cam = cv2.VideoCapture(0)
ret, img = cam.read()
socket.settimeout(1)
sock = socket.socket()
neterror = sock.connect_ex((HOST_IP, HOST_PORT))
if neterror:
return img
else:
encode_param=[int(cv2.IMWRITE_JPEG_QUALITY),90]
result, imgencode = cv2.imencode('.jpg', img, encode_param)
data = numpy.array(imgencode)
stringData = data.tostring()
sock.send( str(len(stringData)).ljust(16));
sock.send( stringData );
sock.close()
return img
def readsocket(self, socket):
if (len(self.bufferLines)==0):
totalData='';
data='';
try:
socket.settimeout(self.Timeout);
data = socket.recv(1024);
while (data):
totalData +=data;
data = socket.recv(1024);
except:
pass;
self.bufferLines=totalData.split('\n');
if (len(self.bufferLines) > 0):
self.bufferLines.pop(-1);
if (len(self.bufferLines) > 0):
result=self.bufferLines.pop(0);
else:
result = '';
return result;
def __init__(self, microWebSrv, socket, addr) :
socket.settimeout(2)
self._microWebSrv = microWebSrv
self._socket = socket
self._addr = addr
self._method = None
self._path = None
self._httpVer = None
self._resPath = "/"
self._queryString = ""
self._queryParams = { }
self._headers = { }
self._contentType = None
self._contentLength = 0
if hasattr(socket, 'readline'): # MicroPython
self._socketfile = self._socket
else: # CPython
self._socketfile = self._socket.makefile('rwb')
self._processRequest()
def __init__(self, ip, port, socket, auth, handle, logger):
super(ClientThread, self).__init__()
self.ip = ip
self.port = port
self.name = "Client: {0}:{1}".format(ip, port)
self.socket = socket
# time out the connection on purpose to check for events
# TODO: maybe find a better way
socket.settimeout(2)
self.logger = logger
self._kick = threading.Event()
self._handle_function = handle
self._auth_function = auth
self._authenticated = False
self._auth_tries_left = 3
self.logger.debug("New thread spwaned for %s:%s" % (self.ip, self.port))
def handle(self):
if self.request[0].strip():
try:
data = json.loads(self.request[0].strip())
except ValueError:
return;
socket = self.request[1]
socket.settimeout(1);
if data.has_key('ctime') and data.has_key('logtype'):
#print 'connection from', self.client_address,
#print data['logtype'], data['ctime'];
sqlitedbfile = self.server.log_dirname + "/postgresql.log.sqlite"
conn = sqlite.connect(sqlitedbfile);
cur = conn.cursor();
if data['logtype'] != "duration":
res = cur.execute("select * from %s_log where ctime = ?" % (data['logtype']), [data['ctime'][0]]);
else: #duration
if data['ctime'][1] > 0:
wherectime = "ctime >= %d and ctime <= (%d + %d)" % (data['ctime'][0], data['ctime'][0], data['ctime'][1]);
else:
wherectime = "ctime = %d" % (data['ctime'][0]);
if data['ctime'][2] == data['ctime'][3]:
wherectime += " and query_pos = %d" % (data['ctime'][2]);
else:
if data['ctime'][3] < 0:
wherectime += " and query_pos >= %d" % (data['ctime'][2]);
else:
wherectime += " and query_pos >= %d and query_pos <= %d" % (data['ctime'][2], data['ctime'][3]);
res = cur.execute("select * from %s_log where %s" % (data['logtype'], wherectime));
rows = res.fetchall();
del res;
cur.close();
conn.close();
try:
for row in rows:
socket.sendto(json.dumps(row), self.client_address)
socket.sendto('bye', self.client_address)
except:
print 'except!'
pass;
def invoke(self, request, retfile=False):
"""
Open a connection.
@param request: A suds Request
@type Request: suds.transport.Request
@param retfile: indicates if a file-like object is to be returned
@type: bool
@return: A file-like object or a suds Reply
@rtype: file or suds.transport.Reply
"""
tm = self.options.timeout
request = self.prerequest(request)
u2request = urllib2.Request(request.url, request.message, request.headers)
self.addcookies(u2request)
request.headers = u2request.headers
log.debug('request final headers:\n%s', request.headers)
urlopener = self.u2opener()
try:
if self.u2ver() < 2.6:
socket.settimeout(tm)
u2response = urlopener.open(u2request)
else:
u2response = urlopener.open(u2request, timeout=tm)
except urllib2.HTTPError, e:
# This error is to mimic the original exception code
if not retfile and e.code in (202, 204):
result = None
else:
# use the same postreply() call to decode an error response
body = e.read()
reply = Reply(e.code, e.headers, body)
reply = self.postreply(reply)
memfile = cStringIO.StringIO(reply.message)
raise TransportError(reply.message, e.code, memfile)
def fetch(self, url):
import time
# Delay to ensure we don't anger the API server
while self.last + self.delay > time.time():
time.sleep(0.001)
# Nab
if self.debug:
print "Fetching %s" % url
else:
pass #print >> sys.stderr, "Fetching %s" % url
try:
socket.settimeout(10)
handle = urllib.urlopen(url)
data = handle.read()
#print >> sys.stderr, dict(handle.headers), "for", url
except (AttributeError, IOError):
try:
time.sleep(0.1)
data = urllib.urlopen(url).read()
except (AttributeError, IOError):
try:
time.sleep(0.2+random.random()*0.2)
data = urllib.urlopen(url).read()
except (AttributeError, IOError):
try:
time.sleep(0.3)
data = urllib.urlopen(url).read()
except (AttributeError, IOError):
try:
time.sleep(0.4)
data = urllib.urlopen(url).read()
except (AttributeError, IOError):
raise IOError("Cannot contact last.fm")
self.last = time.time()
return data
def send(socket, data, fStopped=None, bClose=True, fPercentUpdate=None):
if fStopped:
socket.settimeout(SOCKET_TIMEOUT)
total = 0
data = pack.pack(data)
size = len(data)
data = str(size) + ';' + data
size = float(len(data))
while 1:
try:
sent = socket.sendall(data[total:])
total += sent
if fPercentUpdate:
fPercentUpdate(total/size)
if total >= size:
if bClose:
socket.close()
return True
except AttributeError, e:
if fStopped and fStopped():
if bClose:
socket.close()
return False
def __init__(self, socket, initiator, db_name, db, usersdb, server_send_sockets):
Thread.__init__(self)
self.daemon = True
socket.settimeout(None)
self.socket = socket
self.unprocessed_packets = ""
self.command = ""
self.otherSocketName = ""
self.db_name = db_name
self.db = db
self.usersdb = usersdb
self.server_send_sockets = server_send_sockets # only need this for command
print("tyring to print server connection")
print(self.server_send_sockets)
print("finsihed tryign to print")
self.server_send_sockets = server_send_sockets
if initiator:
print("I am the initator and am trying to figure it out")
self.otherSocketName = self.socket.recv(500)
self.socket.send(self.db_name)
else:
print("trying to send and am not the initator")
self.socket.send(self.db_name)
self.otherSocketName = self.socket.recv(500)
if len(sys.argv)<2:
print("Usage: echo msg | %s <channel1> <channel2>" %(sys.argv[0]))
sys.exit(1)
# comment out to disable
import imp
passwords = imp.load_source("passwords", os.path.join(os.path.dirname(__file__), "passwords.py"))
username = passwords.username
password = passwords.password
channels = set(sys.argv[1:])
template = "JOIN $CHANNEL$\n"
for line in sys.stdin:
template += "SAY $CHANNEL$ " + line + "\n"
buf = 'LOGIN ' + username + ' ' + password + ' 0 * TASClient 0.33\t0\tcl sp p\n'
for channel in channels:
buf += template.replace("$CHANNEL$", channel)
buf += "EXIT Thanks for using rapid! https://github.com/spring/RapidTools\n"
socket = socket.socket()
socket.settimeout(2.0)
socket.connect(('lobby.springrts.com', 8200))
socket.sendall(buf)
time.sleep(1.0)
socket.close()
def __init__(self, socket):
# In case that the default timeout is not None.
socket.settimeout(None)
self._socket = socket
self._buf = ''
