def voyagerSearchResultsService(self,searchType=None,resultPointer="0",maxResultsPerPage="10",sortBy="TITLE",profileCode=None):
"""
Voyagers SearchResultsService
@param searchType: FIND,BROWSE,etc
@param resultPointer: Current position in result set.
@param maxResultsPerPage: Number of results returned
@param sortBy: Field to sort on.
@param profileCode: Ignore, used only one RELBIBS
@return: xml
"""
self.xmldoc = None
if searchType != None:
query = ("searchType=" + searchType +
"&resultPointer=" + resultPointer +
"&maxResultsPerPage=" + maxResultsPerPage +
"&sortBy=" + sortBy)
try:
print str(self._getVoyagerUrl()) + "/SearchResultsService?" + query
socket = self.session.open(str(self._getVoyagerUrl()) + "/SearchResultsService?" + query,timeout=self.DEFAULT_TIMEOUT_SECONDS)
self.xmldoc = minidom.parse(socket).documentElement
socket.close()
except Exception as e:
logger.warning(e)
#print self.xmldoc.toprettyxml(encoding='utf-8')
return self.xmldoc
def handle(self, socket, address):
"""
If not a leader, a node will simply return a single item list pointing
to the leader. Otherwise, it will add the host of the connected client
to the cluster roster, broadcast to all nodes the new roster, and wait
for keepalives. If no keepalive within timeout or the client drops, it
drops it from the roster and broadcasts to all remaining nodes.
"""
self.logger.debug('New connection from %s:%s' % address)
if not self.manager.is_leader:
socket.send(json.dumps({'leader': self.manager.client.leader_address[0],
'port': self.manager.client.leader_address[1]}))
socket.close()
self.logger.debug("Redirected to %s:%s" % self.manager.client.leader_address)
else:
socket.send(self._cluster_message())
sockfile = socket.makefile()
name = sockfile.readline()
if not name:
return
if name == '\n':
name = address[0]
else:
name = name.strip()
self._update(add={'host': name, 'socket': socket})
# TODO: Use TCP keepalives
timeout = self._client_timeout(socket)
for line in util.line_protocol(sockfile, strip=False):
timeout.kill()
timeout = self._client_timeout(socket)
socket.send('\n')
self.logger.debug("Keepalive from %s:%s" % address)
self.logger.debug("Client disconnected from %s:%s" % address)
self._update(remove=name)
def _rm_socket(self, socket):
try:
socket.close()
self._sockets.remove(socket)
socket.deleteLater()
except ValueError:
pass
def socket_timeout(self, key, aliases):
'''
check whether the connection timed out
This happens when a socket is still in self.master.pending_connections
after a certain amount of time
'''
then=time.time() + TIMEOUT
while time.time() < then:
with self.master.pending_connections_lock:
if not key in self.master.pending_connections:
return
time.sleep(CHECK_RATE)
with self.master.pending_connections_lock:
if not key in self.master.pending_connections:
return
(from_aliases, socket) = self.master.pending_connections.pop(key)
socket.close()
for bot_index in from_aliases:
with self.master.bots[bot_index].num_clients_lock:
self.master.bots[bot_index].num_clients -= 1
with self.master.peer_resources_lock:
if key[1] in self.master.peer_resources:
self.send_disconnect_error(key, from_aliases, self.master.peer_resources[key[1]])
else:
self.send_disconnect_error(key, from_aliases, key[1], message=True)
def server(self,parent,answer=False,pre_return=False):
while True:
print "server started"
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('',parent.port))
sock.listen(5)
try:
while True:
newSocket, address = sock.accept()
debug_print("ip address: "+str(address),1)
while True:
try:
print "ready to receive:"
receivedData=newSocket.recv(4*8192)#maybe we should increase the max receive data
except:
print "socket error"
if not receivedData:
print "no data"
break
if receivedData=="alive?":
print "alive"
newSocket.sendall("alive!"+";\r\n") #added TK
break
if pre_return:
try:
newSocket.sendall("RECEIVED!"+";\r\n") #added TK
except:
debug_print("error while sending return string",1)
debug_print("received data: " + str(receivedData),1)
start_time=time.time()
parent.server_create(receivedData)
stop_time=time.time()
used_time=round((stop_time-start_time)*1000)
parent.time_str="OK, execution_time, " +str(used_time)+";\n"
if (parent.error_string==""):
if answer:
print "trying to send"
string=parent.get_return_string()
try:
newSocket.sendall(string+"\r\n")
except:
debug_print("error while returning value",1)
debug_print("returned value"+str(parent.get_return_string())+"\r\n",1)
else:
print"trying to send error"
if answer:
newSocket.sendall(parent.error_string+"\r\n")
parent.error_string=""
print "sended error"
print "finish connected"
newSocket.close()
finally:
print "disconnected"
try:
socket.close()
except AttributeError:
debug_print("server crashed - restarting",1)
def broadcast (server_socket, sock, message):
# sending message to clients
for socket in SOCKET_LIST:
# send the message only to clients
if socket != server_socket and socket != sock :
try :
socket.send(message)
except :
# broken socket connection
socket.close()
# broken socket, remove it
if socket in SOCKET_LIST:
SOCKET_LIST.remove(socket)
#sending to other peers
for socket in PEER_SERVERS:
# send the message only to peers
if socket != server_socket and socket != sock :
try :
socket.send(message)
except :
# broken socket connection
socket.close()
# broken socket, remove it
if socket in SOCKET_LIST:
SOCKET_LIST.remove(socket)
def stop(self):
"""
Stops the backend process.
"""
if self._process is None:
return
if self._shared:
BackendManager.SHARE_COUNT -= 1
if BackendManager.SHARE_COUNT:
return
_logger().debug('stopping backend process')
# close all sockets
for socket in self._sockets:
socket._callback = None
socket.close()
self._sockets[:] = []
# prevent crash logs from being written if we are busy killing
# the process
self._process._prevent_logs = True
while self._process.state() != self._process.NotRunning:
self._process.waitForFinished(1)
if sys.platform == 'win32':
# Console applications on Windows that do not run an event
# loop, or whose event loop does not handle the WM_CLOSE
# message, can only be terminated by calling kill().
self._process.kill()
else:
self._process.terminate()
self._process._prevent_logs = False
_logger().info('backend process terminated')
def broadcast_MessageTo_Clients (sock, message):
len_of_msg = len(message)
msg = message[0:len_of_msg]
#sent_data_len = 0
for socket in ALL_CONNECTION_LIST:
sent_data_len = 0
while (sent_data_len != len_of_msg):
if socket != server_socket and socket != sock:
try :
temp = socket.send(msg)
sent_data_len = sent_data_len + temp
if(sent_data_len != len_of_msg):
msg = message[sent_data_len:len_of_msg]
else:
break
except Exception, e:
# broken socket connection may be, chat client pressed ctrl+c for example
print"{{%s}}" % e
socket.close()
ALL_CONNECTION_LIST.remove(socket)
break
else:
break
def test_preexisting_token_sans_splunk(self):
token = self.context.token
if token.startswith('Splunk '):
token = token.split(' ', 1)[1]
self.assertFalse(token.startswith('Splunk '))
else:
self.fail('Token did not start with "Splunk ".')
opts = self.opts.kwargs.copy()
opts["token"] = token
opts["username"] = "******"
opts["password"] = "******"
newContext = binding.Context(**opts)
response = newContext.get("/services")
self.assertEqual(response.status, 200)
socket = newContext.connect()
socket.write("POST %s HTTP/1.1\r\n" %\
self.context._abspath("some/path/to/post/to"))
socket.write("Host: %s:%s\r\n" %\
(self.context.host, self.context.port))
socket.write("Accept-Encoding: identity\r\n")
socket.write("Authorization: %s\r\n" %\
self.context.token)
socket.write("X-Splunk-Input-Mode: Streaming\r\n")
socket.write("\r\n")
socket.close()
def main():
print "Welcome to the IGV walker! Use the WASD keys to take Gir for a walk!\n"
# Make sure we can establish a connection with Gir
socket = 0
try:
#socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#socket.connect((SLAVE, PORT))
except:
print "A connection could not be made, giving up."
sys.exit(1)
# Setup keybindings
app = 0
root = 0
try:
app = Walker()
root = tk.Tk()
root.bind_all('<Key>', app.key_pressed)
root.bind_all('<KeyRelease>', app.key_released)
root.after(20, app.task, s)
root.withdraw()
except:
print "Could not bind keypress handlers, giving up."
try:
root.mainloop()
root.destroy()
socket.close()
except:
root.destroy()
socket.close()
raise
def get_replay(name, query, config, context=None):
endpoint = config.get('replay_endpoints', {}).get(name, None)
if not endpoint:
raise IOError("No appropriate replay endpoint "
"found for {0}".format(name))
if not context:
context = zmq.Context(config['io_threads'])
# A replay endpoint isn't PUB/SUB but REQ/REP, as it allows
# for bidirectional communication
socket = context.socket(zmq.REQ)
try:
socket.connect(endpoint)
except zmq.ZMQError as e:
raise IOError("Error when connecting to the "
"replay endpoint: '{0}'".format(str(e)))
# REQ/REP dance
socket.send(fedmsg.encoding.dumps(query))
msgs = socket.recv_multipart()
socket.close()
for m in msgs:
try:
yield fedmsg.encoding.loads(m)
except ValueError:
# We assume that if it isn't JSON then it's an error message
raise ValueError(m)
def handleGet(self, requestLineAsList, socket): responseFile = self.hostedDirectory + requestLineAsList[1] if os.path.isdir(responseFile): responseFile = responseFile + "/" if responseFile[-1] == '/': responseFile = responseFile + "index.html" content = "" response = "HTTP/1.1 " try: print "Trying to open file: " + responseFile file = open(responseFile, 'rb') content = file.read() response = response + "200 OK\r\n" response = response + "Content-Length: " + str(len(content)) + "\r\n\r\n" response = response + content file.close() #print "Response: ", response except: print "Exception" response = response + "404 Not Found\r\n\r\n<html><body><h1>404 Not Found</h1></body></html>" if socket.sendall(response) != None: print "Failed to send" print "Response successfully sent" socket.close()
def handle_tcp(socket, dstport): handler = tcp_handlers.get(dstport, handle_tcp_default) try: handler(socket, dstport) except Exception as err: print(traceback.format_exc()) socket.close()
def upload(self):
self.getDuration()
# Take screenshots at even increments between 20% and 80% of the duration
stops = range(20,81,60/(self.shots-1))
try:
count=0
imgs = []
for stop in stops:
imgs.append(tempdir()+"screen%d.png" % count)
subprocess.Popen([r"ffmpeg","-ss",str((self.duration * stop)/100), "-vframes", "1", "-i", self.path , "-y", "-sameq", "-f", "image2", imgs[-1] ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT).wait()
count+=1
except OSError:
sys.stderr.write("Error: Ffmpeg not installed, refer to http://www.ffmpeg.org/download.html for installation")
exit(1)
opener = urllib2.build_opener(MultipartPostHandler.MultipartPostHandler)
try:
for img in imgs:
params = ({'key' : self.key.decode('utf-8').encode('utf-8'), 'image' : open(img, "rb")})
socket = opener.open("http://api.imgur.com/2/upload.json", params)
read = json.loads(socket.read())
self.imageurl.append(read['upload']['links']['original'])
socket.close()
os.remove(img)
return True
except urllib2.URLError as s:
if self.tries < 3:
self.tries += 1
sys.stderr.write('Connection timed out, retrying to upload screenshots to imgur. This is try: ')
sys.stderr.write(str(self.tries))
sys.stderr.write('\n')
self.upload()
return True
def server(pid, ep):
"""
Worker for listening socket for communication with web server.
Parameters
----------
pid: int
Process id. Used to send SIGINT.
ep: mp.Pipe endpoint.
Used to communicate with model processor.
"""
context = zmq.Context()
socket = context.socket(zmq.REP)
port = socket.bind_to_random_port("tcp://0.0.0.0")
ep.send(port)
def sig_handler(signum, frame):
socket.close()
return
signal.signal(signal.SIGTERM, sig_handler)
while True:
message = socket.recv()
if message == "KILL":
socket.send("OK")
socket.close()
ep.send(None)
p = psutil.Process(pid)
p.send_signal(signal.SIGINT)
return
def start(self):
self.server_socket.bind(('', self.port))
self.server_socket.listen(5)
print "Listening for connections..."
self.keep_running = True
sockets = [self.server_socket]
nicknames = {}
while self.keep_running:
readable, writable, error = select.select(sockets, [], [])
if len(readable) > 0:
for sock in readable:
if sock is self.server_socket:
print "New client accepted."
(client_socket, address) = sock.accept()
sockets.append(client_socket)
else:
msg = sock.readnext()
if not sock in nicknames.keys():
if msg in nicknames.values():
sock.write("ERROR: Nickname already in use.")
else:
nicknames[sock] = msg
sock.write("SERVER: Welcome to chat!")
elif msg == "":
sock.close()
sockets.remove(sock)
print "Client disconnected."
else:
for client_socket in sockets:
if not client_socket is self.server_socket:
client_socket.write("[%s]> %s" % (nicknames[sock], msg))
print msg
for socket in sockets:
socket.close()
def send_data(socket):
while True:
data = input()
socket.send(data.encode('utf-8'))
if(data == 'exit'):
socket.close()
break
def main():
global wCapture, SHARED_DO_RUN, SHARED_CAPTURE_EDGE, SCREENSHOT_DIR, SCREENSHOT_NAME, SHARED_DISABLE_CORNERS
# get display height and width
width = sys.argv[1]
height = sys.argv[2]
shareEdge = int(sys.argv[3])
# shared variable for closing the winCapture
SHARED_DO_RUN = multiprocessing.Value("i", 1)
SHARED_CAPTURE_EDGE = multiprocessing.Value("i", shareEdge)
SHARED_DISABLE_CORNERS = multiprocessing.Value("i", 1)
# connect to QTcpServer
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1)
try:
sock.connect( ("127.0.0.1", 44556) )
print "Connected !"
except socket.error:
print "Failed to connect"
tb.print_exc()
# start the winCapture in another process... send it the shared DO_RUN
# variable and the pipe so it can talk to the GUI
wCapture = WinCapture(sock, width, height, SHARED_DO_RUN, SHARED_CAPTURE_EDGE, SHARED_DISABLE_CORNERS)
#wCapture.start()
wCapture.run()
socket.close()
def esperando_conexiones(self):
self.server_socket.listen(self.listen)
# Añadimos socket server a la lista
self.CONNECTION_LIST.append(self.server_socket)
while True:
# Obtener la lista sockets que están listos para ser leídos a través de selección
read_sockets,write_sockets,error_sockets = select.select(self.CONNECTION_LIST,[],[])
for socket in read_sockets:
# Nueva conexion
if socket == self.server_socket:
# Hay una nueva conexión recibida
client_socket, addr = self.server_socket.accept()
self.CONNECTION_LIST.append(client_socket)
print "Cliente (%s, %s) conectado" % addr
self.enviar_msg(client_socket, "Ingreso: [%s:%s].\n" % addr)
# Mensaje desde algun cliente chat
else:
# Datos del cliente
try:
data = socket.recv(self.recv_buffer)
if data:
self.enviar_msg(socket, "\r" + '<' + str(socket.getpeername()) + '> ' + data)
except:
self.enviar_msg(socket, "Cliente (%s, %s) desconectado." % addr)
print "Cliente (%s, %s) desconectado." % addr
socket.close()
self.CONNECTION_LIST.remove(socket)
continue
self.server_socket.close()
def packetized_receive(socket):
try:
message_len = socket.recv(16)
message_remaining = int(message_len)
message = ""
print "IN PACKETIZED RECEIVE RECEIVING: "+str(message_remaining)
while(message_remaining > 0):
if(message_remaining < 1024):
data = socket.recv(message_remaining)
if len(data) != message_remaining:
message_remaining -= len(data)
data = data + socket.recv(message_remaining)
message = message + data
message_remaining = 0
else:
data = socket.recv(1024)
if len(data) != 1024:
more = 1024 - len(data)
data = data + socket.recv(more)
message = message + data
message_remaining -= 1024
print "IN PACKETIZED RECEIVE RECEIVED: "+str(len(message))
return message
except Exception as e:
print "Peer disconnected, try again."
logging.info("Peer disconnected in packetized_receive:"+str(sys.exc_info()[0]))
socket.close()
def broadcast_data (sock, message, shout = None):
if shout:
for socket in CONNECTION_LIST:
if socket != server_socket and socket != sock :
for every in user[sock]['rooms']:
if every in user[socket]['rooms']:
try :
socket.send(message)
except :
# broken socket connection may be, chat client pressed ctrl+c for example
print "OH, he gettin removed and shit."
socket.close()
CONNECTION_LIST.remove(socket)
else:
#Do not send the message to master socket and the client who has send us the message
for socket in CONNECTION_LIST:
if socket != server_socket and socket != sock :
if user[socket]['current'] == user[sock]['current']:
try :
socket.send(message)
except :
# broken socket connection may be, chat client pressed ctrl+c for example
print "OH, he gettin removed and shit."
socket.close()
CONNECTION_LIST.remove(socket)
def _socketRequest(self, scheme, host, port, payload):
socket = self._getSocketForScheme(scheme)
socket.connect((host, port))
socket.sendall(payload)
data = socket.recv(1024)
socket.close()
return data
def handle(socket, address):
unparsed_data = socket.recv(1024)
parsed_http_response = HTTPRequestParser(unparsed_data)
# Message formatting and message sending are separated for ease of testing.
if parsed_http_response.error_code is not None:
server_response = return_error(parsed_http_response)
socket.send(server_response)
elif parsed_http_response.request_version != "HTTP/1.1":
server_response = return_unsupported_version(parsed_http_response)
socket.send(server_response)
elif parsed_http_response.command != "GET":
server_response = return_method_not_allowed(parsed_http_response)
socket.send(server_response)
elif parsed_http_response.error_code is None:
# note to self: feed the returns from
# return_requested_file_or_directory()
# into a response crafter which does header creation.
server_response = \
return_ok_http_file_or_directory_response(parsed_http_response)
socket.send(server_response)
socket.close()
def send_data_to(self, sock, message):
try:
sock.send(message)
except:
# broken socket connection may be, chat client pressed ctrl+c for example
socket.close()
self.CONNECTION_LIST.remove(sock)
def cleanup (arg1 = None, arg2 = None):
global clients
log("Cleaning up")
running = False
for socket in clients:
try:
socket.shutdown(socket.SHUT_RDWR)
except Exception as e:
pass
socket.close()
if unix_socket:
unix_socket.shutdown(socket.SHUT_RDWR)
unix_socket.close()
if tcp_socket:
tcp_socket.shutdown(socket.SHUT_RDWR)
tcp_socket.close()
if serial_con:
serial_con.close()
try:
os.remove('/tmp/lights')
except OSError, e: pass
try:
os.remove(config['pidfile'])
except OSError, e: pass
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 file_send(self, socket):
print('Thread for client ' + str(socket) + ' started! Waiting for input...')
# headers = conn.recv(1024)
# print('headers: %s' % headers)
# data = self.msg_get(socket)
# print(data)
#
# # socket.send('tarantino.jpg'.encode('utf-8'))
# self.msg_send(socket, 'tarantino.jpg')
# print('send filename')
# # socket.close()
# socket = self.connect()
with open(self.default_server_file, 'rb') as file:
print('File open')
l = file.read(1024)
while l:
socket.send(l)
# print('sending data...')
l = file.read(1024)
print('sending data: END...')
socket.close()
def listen_on_socket(socket, *args):
if socket is None:
return
command = ""
file = socket.makefile('rwb')
while True:
try:
data = file.read(1)
if data == b'':
sleep(0.001)
continue
else:
data = data.decode('ascii')
if data == AtHomeProtocol['end_of_communication']:
print('Communication ended', file=sys.stderr)
return
if data != AtHomeProtocol['end_of_command']:
command += data
else:
command = ""
continue
if command.endswith(AtHomeProtocol['end_of_line']):
command = command[0:-2]
if command in AtHomeCommands:
AtHomeCommands[command](file)
else:
command = ""
raise NameError('[Unknown Command] %s' % command)
command = ""
except EOFError:
file.close()
socket.close()
return
except Exception as e:
print('[Exception] %s' % e, file=sys.stderr)
def _closesocket(socket):
try:
socket.close()
return True
except:
print "Couldn't close the socket for some reason"
return False
def voyagerSearchService(self,searchCode="GKEY",searchArg=None,maxResultsPerPage="10",searchArgType="AND",displayRelevanceFlag="N"):
"""
Voyagers SearchService
@param searchCode: Code Constraint to search on.
@param searchArg: Item('s) to be searched.
@param maxResultsPerPage: Number of results returned
@param searchArgType: How to connect your searchArgs aka AND or OR
@param displayRelevanceFlag: Is Browse? Y|N
@return: xml
"""
self.xmldoc = None
if searchArg != None:
query = ("searchCode=" + searchCode +
"&searchArg=" + searchArg +
"&maxResultsPerPage=" + maxResultsPerPage +
"&searchArgType=" + searchArgType +
"&displayRelevanceFlag=" + displayRelevanceFlag)
try:
print str(self._getVoyagerUrl()) + "/SearchService?" + query
socket = self.session.open(str(self._getVoyagerUrl()) + "/SearchService?" + query,timeout=self.DEFAULT_TIMEOUT_SECONDS)
self.xmldoc = minidom.parse(socket).documentElement
socket.close()
except Exception as e:
logger.warning(e)
#print self.xmldoc.toprettyxml(encoding='utf-8')
return self.xmldoc
def Connect():
global masterServer_address, masterServer_port
while True:
try:
try:
socket.close()
except:
pass
debugOutput("Connecting to " + str(masterServer_address) + str(":") + str(masterServer_port))
socId = socket.socket()
# Establish socket connection to the server
socId.connect((str(masterServer_address), int(masterServer_port)))
# Get server version
serverVersion = socId.recv(3).decode()
debugOutput("Server version: " + serverVersion)
if (float(serverVersion) <= float(minerVersion)and len(serverVersion) == 3):
# If miner is up-to-date, display a message and continue
print(
now().strftime(Style.RESET_ALL + Style.DIM + "%H:%M:%S ")
+ Style.BRIGHT
+ Back.BLUE
+ Fore.WHITE
+ " net0 "
+ Back.RESET
+ Fore.YELLOW
+ getString("connected")
+ Style.RESET_ALL
+ Fore.WHITE
+ getString("connected_server")
+ str(serverVersion)
+ ")")
break
else:
print(
now().strftime(Style.RESET_ALL + Style.DIM + "%H:%M:%S ")
+ Style.BRIGHT
+ Back.GREEN
+ Fore.WHITE
+ " sys0 "
+ Back.RESET
+ Fore.RED
+ " Miner is outdated (v"
+ minerVersion
+ "),"
+ Style.RESET_ALL
+ Fore.RED
+ getString("server_is_on_version")
+ serverVersion
+ getString("update_warning"))
time.sleep(10)
break
except:
print(
now().strftime(Style.DIM + "%H:%M:%S ")
+ Style.RESET_ALL
+ Style.BRIGHT
+ Back.BLUE
+ Fore.WHITE
+ " net0 "
+ Style.RESET_ALL
+ Style.BRIGHT
+ Fore.RED
+ getString("connecting_error")
+ Style.RESET_ALL)
if debug == "y":
raise
time.sleep(5)
return socId
def methodV3(AUTH_REQUEST, VER_THREE, token, socket):
tokenLen = int(24)
signatureLen = int(40)
encrypt_key_number = int(5)
encodedToken = ""
encodedToken += str(
(base64.b64encode(bytes(token))).decode("utf-8")) #encoding in base64
encodedTokenLen = len(encodedToken) + 1
print('encodedTokenLen :', encodedTokenLen)
bodyLen = 0
pos = 0
written_len = 0
respond = 1
appId = "com.sanity.test"
skeys = [
"SM62KphYVQN1Y1OI", "O2bxWuezJ5JhrdeZ", "Yab4V6u8pzM3h9u8",
"mvLDu0c0tKw8fEd5", "K6Ja3ZsVF2WvBWsA", "7NPs6Q4xXddwUVVV",
"HmbJ6zGm5qddMiie", "sMyypdfUnXaPUS3g", "IrrsXwfr4CCD9MuQ",
"rzQ3HlVbtNVIQSrv"
]
buffr = "{\"isFg\" : \"true\",\"userId\" : \"testUser:79eec5bdfe7c6f03\",\"dUid\" : \"79eec5bdfe7c6f03\",\"dMk\" : \"HMD Global\",\"dMl\" : \"TA-1021\",\"mccMnc\" : \"405-53\"} }"
print("Buffer: ", buffr)
written_len = len(buffr)
print("signatureLen: ", sys.getsizeof(signatureLen))
bodyLen = 2 + encodedTokenLen + 2 + 8 + 40 + 1 + written_len + 2
#print("bodyLen : ", bodyLen)
buf = []
req_buf = []
pos_req = 0
myArray = array('B', [(AUTH_REQUEST << 4) + VER_THREE])
for x in myArray:
req_buf.append(x)
pos_req += 1
myArray = array('B', [encrypt_key_number])
for x in myArray:
req_buf.append(x)
pos_req += 1
'''
low = (bodyLen & 0x00ff);
high = ((bodyLen & 0xff00) >> 8)
myArray = array('B', [high,low])
for x in myArray:
buf.append(x)
pos_req+=2
'''
low = (respond & 0x00ff)
print("First low: ", low)
buf.append(low)
pos += 1
low = (encodedTokenLen & 0x00ff)
high = ((encodedTokenLen & 0xff00) >> 8)
buf.append(high)
buf.append(low)
pos += 2
print("Buf before adding token ", buf)
#encodedToken+="\0"
print("This is encodedToken")
print(encodedToken)
length = len(encodedToken)
print(length)
for item in encodedToken:
buf.append(ord(item))
pos += length
print("Buf after adding token ", buf)
buf.append(0)
#Adding current timestamp
#buf.append(0)
#pos+=1
tym = int(time.time() * 1000)
print("Time: ", tym)
#tym = 1528200938
p = int_to_bytes1(tym, 8)
#p = int_to_bytes1(1528200938,8)
for item in p:
buf.append(item)
#buf.append(0)
'''
buf.append(p[7])
buf.append(p[6])
buf.append(p[5])
buf.append(p[4])
buf.append(p[3])
buf.append(p[2])
buf.append(p[1])
buf.append(p[0])
'''
pos += 8
print("Buf after adding timestamp: ", buf)
#Adding Signature len
low = (signatureLen & 0x00ff)
high = ((signatureLen & 0xff00) >> 8)
buf.append(high)
buf.append(low)
pos += 2
ts_str = str(tym)
buf2 = token + ts_str + appId + skeys[0]
print("signatureLen: ", signatureLen)
print("This is buf2")
print(buf2)
#encrypting in SHA1
#encrypting in SHA1
digest = []
digest = sha1.sha1(buf2)
print("This is digest")
print(digest)
result = ""
x = 0
result += "".join("{:08x}".format(c) for c in digest)
#result+="".join("{:08x} ".format(ord(c)) for c in digest)
print("This is result:")
print(result)
print("signatureLen :", len(result))
# Putting digest key in buffer
for item in result:
buf.append(ord(item))
pos += 40
print("This is buf after adding result")
print(buf)
#Adding payload length
low = (len(buffr) & 0x00ff)
high = ((len(buffr) & 0xff00) >> 8)
buf.append(high)
buf.append(low)
pos += 2
for item in buffr:
buf.append(ord(item))
#buf.append(0)
pos += len(buffr)
print("This is buf after adding buffer: ")
print(buf)
print("This is buf")
packet2 = str(bytearray(buf))
print("".join("{:02x} ".format(ord(c)) for c in packet2))
print(buf)
print(len(buf))
pack = ""
for item in buf:
pack += str(item)
print(pack)
#packet = str(bytearray(buf))
#print("This is buf packet")
#print(packet)
#encrypted=[]
encrypted1 = ""
'''
for i in buf:
encrypted += i ^ skeys[encrypt_key_number]
'''
skey = []
for item in skeys[encrypt_key_number]:
skey.append(ord(item))
encrypted = str_xor(buf, skey)
#encrypted[pos] = 0
'''
for i in encrypted:
encrypted1 += str(i) ^ skeys[encrypt_key_number]
'''
#encrypted1+=str_xor(encrypted, skey)
print("This is encrypted buf:")
print(encrypted)
#print("This is decrypted buf:")
#print(encrypted1)
#print(len(encrypted))
low = (pos & 0x00ff)
high = ((pos & 0xff00) >> 8)
print("High and Low")
print(high)
print(low)
myArray = array('B', [high, low])
for x in myArray:
req_buf.append(x)
pos_req += 2
print("This is req_buf")
packet = str(bytearray(req_buf))
print("".join("{:02x} ".format(ord(c)) for c in packet))
req_buf = req_buf + encrypted
#print(x)
pos_req += pos
print("This is req_buf with encrypted buf")
print(req_buf)
packet = str(bytearray(req_buf))
print("This is req_buf packet: ")
print(packet)
print("This is req_buf hex packet: ")
print(" ".join("{:02x}".format(ord(c)) for c in list(packet)))
appendData = "\nGET / HTTP/1.1\r\nHost: www.datami.com\r\nUser-Agent: curl/7.51.0\r\nAccept: */*\r\n\r\n"
packet += appendData
print(packet)
x = 0
'''
socket.send(packet)
print(int(time.time()))
tym = str(int(time.time()))
timNum = []
for i in list(tym):
timNum.append(int(i))
p = array('B', timNum)
print(p)
'''
tot_bytes = 0
socket.send(packet)
while True:
#print(x)
if (len(socket.recv(1024)) == 0):
socket.close()
break
tot_bytes += len(socket.recv(1024))
print(socket.recv(1024))
x += 1
print(tot_bytes)
import socket, select
ef broadcast_chatroom (sock, message):
#do not send the message to master socket and the client who has send us the message
for socket in chatroom:
if socket != server_socket and socket != sock :
try :
socket.send(message)
except:
# broken socket connection may be, chat client pressed ctrl+c for example
socket.close()
chatroom.remove(socket)
if __name__ == "__main__":
#user_info = []
user_info = [[]*4 for x in range(9)]
user_info[0].append('qw')
user_info[0].append('as')
user_info[0].append('0')
user_info[1].append('er')
user_info[1].append('df')
user_info[1].append('0')
user_info[2].append('ty')
user_info[2].append('gh')
user_info[2].append('0')
user_info[3].append('ui')
user_info[3].append('jk')
user_info[3].append('0')
print (user_info)
def quit_smtp(socket):
send_data_to_server("QUIT\r\n", socket)
receive_data_from_server(socket)
socket.close()
quit()
def close_Proposer(self,socket):
socket.close()
def tearDown(self):
for socket in self.socket_list:
socket.close()
def methodV0(AUTH_REQUEST, VER_ZERO, token, sig, socket):
sig_len = 4
tokenLen = 24
bodyLen = 2 + tokenLen + sig_len + 2
buf = []
pos = 0
myArray = array('B', [(AUTH_REQUEST << 4) + VER_ZERO])
for x in myArray:
buf.append(x)
#print(' '.join('{:02x}'.format(x) for x in myArray))
pos += 1
low = (bodyLen & 0x00ff)
high = ((bodyLen & 0xff00) >> 8)
myArray = array('B', [high, low])
#print(' '.join('{:02x}'.format(x) for x in myArray))
for x in myArray:
buf.append(x)
pos += 2
low = (tokenLen & 0x00ff)
high = ((tokenLen & 0xff00) >> 8)
myArray = array('B', [high, low])
#print(' '.join('{:02x}'.format(x) for x in myArray))
for x in myArray:
buf.append(x)
pos += 2
#print(' '.join('{:02x}'.format(x) for x in myArray))
i = 0
for item in token:
buf.append(item)
pos += tokenLen
low = (sig_len & 0x00ff)
high = ((sig_len & 0xff00) >> 8)
myArray = array('B', [high, low])
#print(myArray)
#print(' '.join('{:02x}'.format(x) for x in myArray))
for x in myArray:
buf.append(x)
pos += 2
for item in sig:
buf.append(item)
pos += sig_len
print(token)
print(buf)
packet = str(bytearray(buf))
appendData = "\nGET / HTTP/1.1\r\nHost: www.datami.com\r\nUser-Agent: curl/7.51.0\r\nAccept: */*\r\n\r\n"
packet += appendData
print(packet)
x = 0
'''
socket.send(packet)
print(int(time.time()))
tym = str(int(time.time()))
timNum = []
for i in list(tym):
timNum.append(int(i))
p = array('B', timNum)
print(p)
'''
tot_bytes = 0
socket.send(packet)
while True:
#print(x)
if (len(socket.recv(1024)) == 0):
socket.close()
break
tot_bytes += len(socket.recv(1024))
print(socket.recv(1024))
x += 1
print(tot_bytes)
def methodV1(AUTH_REQUEST, VER_ONE, token, socket):
tokenLen = int(24)
signatureLen = int(40)
encodedToken = ""
encodedToken += str(
(base64.b64encode(bytes(token))).decode("utf-8")) #encoding in base64
encodedTokenLen = len(encodedToken) + 1
print('encodedTokenLen :', encodedTokenLen)
bodyLen = 0
pos = 0
written_len = 0
respond = 1
appId = "com.sanity.test"
print("signatureLen: ", sys.getsizeof(signatureLen))
bodyLen = 2 + encodedTokenLen + 2 + 8 + 40 + 1
buf = []
req_buf = []
pos_req = 0
myArray = array('B', [(AUTH_REQUEST << 4) + VER_ONE])
for x in myArray:
req_buf.append(x)
pos_req += 1
low = (respond & 0x00ff)
print("First low: ", low)
buf.append(low)
pos += 1
low = (encodedTokenLen & 0x00ff)
high = ((encodedTokenLen & 0xff00) >> 8)
buf.append(high)
buf.append(low)
pos += 2
print("Buf before adding token ", buf)
#encodedToken+="\0"
print("This is encodedToken")
print(encodedToken)
length = len(encodedToken)
print(length)
for item in encodedToken:
buf.append(ord(item))
pos += length
print("Buf after adding token ", buf)
buf.append(0)
#Adding current timestamp
tym = int(time.time() * 1000)
print("Time: ", tym)
p = int_to_bytes1(tym, 8)
for item in p:
buf.append(item)
pos += 8
print("Buf after adding timestamp: ", buf)
#Adding Signature len
low = (signatureLen & 0x00ff)
high = ((signatureLen & 0xff00) >> 8)
buf.append(high)
buf.append(low)
pos += 2
ts_str = str(tym)
buf2 = token + ts_str + appId
print("signatureLen: ", signatureLen)
print("This is buf2")
print(buf2)
#encrypting in SHA1
digest = []
digest = sha1.sha1(buf2)
print("This is digest")
print(digest)
result = ""
x = 0
result += "".join("{:08x}".format(c) for c in digest)
#result+="".join("{:08x} ".format(ord(c)) for c in digest)
print("This is result:")
print(result)
print("signatureLen :", len(result))
# Putting digest key in buffer
for item in result:
buf.append(ord(item))
pos += 40
print("This is buf after adding result")
print(buf)
print("This is buf")
packet2 = str(bytearray(buf))
print("".join("{:02x} ".format(ord(c)) for c in packet2))
print(buf)
print(len(buf))
pack = ""
for item in buf:
pack += str(item)
print(pack)
low = (pos & 0x00ff)
high = ((pos & 0xff00) >> 8)
print("High and Low")
print(high)
print(low)
myArray = array('B', [high, low])
for x in myArray:
req_buf.append(x)
pos_req += 2
print("This is req_buf")
packet = str(bytearray(req_buf))
print("".join("{:02x} ".format(ord(c)) for c in packet))
req_buf = req_buf + buf
#print(x)
pos_req += pos
print("This is req_buf with buf")
print(req_buf)
packet = str(bytearray(req_buf))
print("This is req_buf packet: ")
print(packet)
print("This is req_buf hex packet: ")
print(" ".join("{:02x}".format(ord(c)) for c in list(packet)))
appendData = "\nGET / HTTP/1.1\r\nHost: www.datami.com\r\nUser-Agent: curl/7.51.0\r\nAccept: */*\r\n\r\n"
packet += appendData
print(packet)
x = 0
tot_bytes = 0
socket.send(packet)
while True:
#print(x)
if (len(socket.recv(1024)) == 0):
socket.close()
break
tot_bytes += len(socket.recv(1024))
print(socket.recv(1024))
x += 1
print(tot_bytes)
def catch_ctrl_c(sig, frame):
global all_sockets
print('--> CTRL C pressed!\nIsabela server is closing')
for socket in all_sockets:
socket.close()
sys.exit()
class MagicBucket( object ):
'''Manages a connection (session) to the UMC server. Therefore it
ensures that without successful authentication no other command is
accepted. After the user has authenticated the commands are passed
on to the Processor.'''
def __init__( self ):
self.__states = {}
def __del__( self ):
self.exit()
def new( self, client, socket ):
"""Is called by the Server object to annouce a new incoming
connection.
:param str client: IP address + port
:param fd socket: a file descriptor or socket object
"""
CORE.info( 'Established connection: %s' % client )
state = State( client, socket )
state.signal_connect( 'authenticated', self._authenticated )
self.__states[ socket ] = state
notifier.socket_add( socket , self._receive )
statistics.connections.new()
def exit( self ):
'''Closes all open connections.'''
# remove all sockets
for sock, state in self.__states.items():
CORE.info( 'Shutting down connection %s' % sock )
if state.processor is not None:
state.processor.shutdown()
notifier.socket_remove( sock )
statistics.connections.inactive()
# delete states
for state in self.__states.values():
del state
self.__states = {}
def _authenticated( self, success, state ):
"""Signal callback: Invoked when a authentication has been
tried. This function generates the UMCP response.
:param bool success: True if the authentication was successful
:param State state: the state object for the connection (see also :class:`~univention.management.console.protocol.session.State`)
"""
if success:
statistics.users.add( state.username )
state.authResponse.status = SUCCESS
else:
state.authResponse.status = BAD_REQUEST_AUTH_FAILED
state.authenticated = success
self._response( state.authResponse, state )
state.authResponse = None
def _receive( self, socket ):
"""Signal callback: Handles incoming data. Processes SSL events
and parses the incoming data. If a vaild UMCP was found it is
passed to _handle.
:param fd socket: file descriptor or socket object that reported incoming data
"""
state = self.__states[ socket ]
data = ''
try:
data = socket.recv( RECV_BUFFER_SIZE )
except SSL.WantReadError:
# this error can be ignored (SSL need to do something)
return True
except ( SSL.SysCallError, SSL.Error ), error:
statistics.connections.inactive()
if self.__states[ socket ].username in statistics.users:
statistics.users.remove( self.__states[ socket ].username )
CRYPT.warn( 'SSL error: %s. Probably the socket was closed by the client.' % str( error ) )
if self.__states[ socket ].processor is not None:
self.__states[ socket ].processor.shutdown()
notifier.socket_remove( socket )
del self.__states[ socket ]
socket.close()
return False
if not len( data ):
notifier.socket_remove( socket )
del self.__states[ socket ]
socket.close()
return False
state.buffer += data
msg = None
try:
while state.buffer:
msg = Message()
state.buffer = msg.parse( state.buffer )
self._handle( state, msg )
except IncompleteMessageError, e:
CORE.info( 'MagicBucket: incomplete message: %s' % str( e ) )
def main(socket, address): # pragma: no cover
"""Main server loop. Logs data into log variable until it finds a certain character. Then returns response."""
while True:
try:
#socket, address = server.accept()
log = b""
flag = True
while flag is True:
more = socket.recv(8)
log += more
if log.decode('utf8').endswith('\r\n\r\n'):
flag = False
sys.stdout.write(log.decode('utf8'))
URI = parse_request(log.decode('utf8'))
content = resolve_uri(URI)
response = response_ok(content)
socket.sendall(response.encode('utf8'))
socket.close()
except KeyboardInterrupt:
server.shutdown(socket.SHUT_WR)
server.close()
sys.exit(0)
except TypeError:
response = response_error(404)
socket.sendall(response.encode('utf8'))
socket.close()
except LookupError:
response = response_error(501)
socket.sendall(response.encode('utf8'))
socket.close()
except ValueError:
response = response_error(400)
socket.sendall(response.encode('utf8'))
socket.close()
except IOError:
response = response_error(404)
socket.sendall(response.encode('utf8'))
socket.close()
except NameError:
response = response_error(505)
socket.sendall(response.encode('utf8'))
socket.close()
def cleanup(self, socket):
common.internal_print("Shutting down module: {0}".format(
self.get_module_name()))
socket.close()
return
def closeSocket(self, socket):
try:
socket.close()
except:
pass
socket = None
# socket objects ::::::::::::::::::::::::::::::::::::::::::::::::::::::: s = socket(..., ...) s.accept() # блокирует приложение до тех пор, пока не придет сообщение от клиента. # Функция возвращает кортеж из двух параметров – объект самого соединения # и адрес клиента. # Пассивно принимает клиентский запрос на установление соединения TCP, # находясь в состоянии ожидания до поступления запроса на установления # (блакирующий режим) s.bind(address) # устанавливает привязку адреса (пары состоящей из имени хоста и номера # порта) к сокету s.close() # обеспечивает закрытие сокета s.connect(address) # активно инициирует соединение сервера TCP s.connect_ex(address) # представляет собой расширенную версию метода connect(), которая # предусматривает возврат сообщений о возникших проблемах в виде кодов # ошибок, а не генерирование исключения s.detach() # обеспечивает закрытие сокета без закрытия дескриптора файла и # возвращает дескриптор s.dup()
def send_404(socket):
send_header(socket, "404 Not found")
socket.send("<html><h1>404</h1>Not found</html>")
socket.close()
def test_completion_sockets_and_messages(self):
t, socket = self.create_connections()
self.socket = socket
try:
#now that we have the connections all set up, check the code completion messages.
msg = quote_plus('math')
send(socket, '@@IMPORTS:%sEND@@' % msg) #math completions
completions = self.read_msg()
#print_ unquote_plus(completions)
#math is a builtin and because of that, it starts with None as a file
start = '@@COMPLETIONS(None,(__doc__,'
start_2 = '@@COMPLETIONS(None,(__name__,'
if ('/math.so,' in completions or
'/math.cpython-33m.so,' in completions or
'/math.cpython-34m.so,' in completions or
'math.cpython-35m' in completions or
'math.cpython-36m' in completions or
'math.cpython-37m' in completions
):
return
self.assertTrue(completions.startswith(start) or completions.startswith(start_2), '%s DOESNT START WITH %s' % (completions, (start, start_2)))
self.assertTrue('@@COMPLETIONS' in completions)
self.assertTrue('END@@' in completions)
#now, test i
msg = quote_plus('%s.list' % BUILTIN_MOD)
send(socket, "@@IMPORTS:%s\nEND@@" % msg)
found = self.read_msg()
self.assertTrue('sort' in found, 'Could not find sort in: %s' % (found,))
#now, test search
msg = quote_plus('inspect.ismodule')
send(socket, '@@SEARCH%sEND@@' % msg) #math completions
found = self.read_msg()
self.assertTrue('inspect.py' in found)
for i in range(33, 100):
if str(i) in found:
break
else:
self.fail('Could not find the ismodule line in %s' % (found,))
#now, test search
msg = quote_plus('inspect.CO_NEWLOCALS')
send(socket, '@@SEARCH%sEND@@' % msg) #math completions
found = self.read_msg()
self.assertTrue('inspect.py' in found)
self.assertTrue('CO_NEWLOCALS' in found)
#now, test search
msg = quote_plus('inspect.BlockFinder.tokeneater')
send(socket, '@@SEARCH%sEND@@' % msg)
found = self.read_msg()
self.assertTrue('inspect.py' in found)
# self.assertTrue('CO_NEWLOCALS' in found)
#reload modules test
# send(socket, '@@RELOAD_MODULES_END@@')
# ok = self.read_msg()
# self.assertEqual('@@MSG_OK_END@@' , ok)
# this test is not executed because it breaks our current enviroment.
finally:
try:
sys.stdout.write('succedded...sending kill msg\n')
self.send_kill_msg(socket)
# while not hasattr(t, 'ended'):
# pass #wait until it receives the message and quits.
socket.close()
self.socket.close()
except:
pass
def send(event=None): # event is passed by binders.
'''Handles sending of messages.'''
message = my_message.get()
my_message.set('') # Clears input field.
try:
socket.send(bytes(message, 'utf-8'))
except ConnectionResetError:
pass
if message == '/pwd':
message = 'Your current directory is ' + os.getcwd() + '\n'
lines = int(message_list.index('end-1c').split('.')[0])
print(lines)
fontsize = ('Courier', 10)
message_list.config(state='normal')
message_list.tag_config('hi', font=fontsize)
message_list.insert(tkinter.END, message)
message_list.tag_add('hi', str(lines + .0),
str(lines) + '.' + str(len(message)))
message_list.config(state='disabled')
message_list.see('end')
hello = message.split(' ')
if hello[0] == '/download':
a = False
data = bytearray()
while a is False:
data.extend(socket.recv(buffer))
print('hi' + str(data))
if data[-4:] == b'CC03':
print('data ends in CC03')
data = data[:-4]
a = True
print('escaped loop')
f = open(hello[1], 'wb')
print(data)
f.write(data)
f.close()
fontsize = ('Courier', 10)
messages('File downloaded', 'download', fontsize)
if hello[0] == '/upload':
print('hello')
try:
p = 0
print('len' + str(len(hello)))
for i in range(len(hello) - 1):
if hello[i] == '-n':
name = ' '.join(hello[i + 1:])
print('name ' + name)
p = i
if hello[i] == '-p':
filepath = ' '.join(hello[i + 1:p - 2])
print('filepath ' + filepath)
f = open(filepath, 'rb')
data = f.read()
f.close()
print('opened')
padding = 64 - len(name)
socket.send(bytes(name + padding * ' ', 'utf-8'))
print('sent filename')
socket.send(data)
print('sent file data')
socket.send(bytes('AA01', 'utf-8'))
except FileNotFoundError:
message = 'File Not Found\n'
messages(message, 'hi')
'''except:
message = 'Failed to upload\n'
lines = int(message_list.index('end-1c').split('.')[0])
print(lines)
fontsize = ('Courier', 10)
user = len(message[2:])
message_list.config(state='normal')
message_list.tag_config('hi', font=fontsize)
message_list.insert(tkinter.END, user)
message_list.tag_add('hi', str(lines+.0), str(lines)+'.'+str(user))
try:
message_list.insert(tkinter.END, message)
except: # Should check what kind of error i expect (to improve this)
pass
message_list.config(state='disabled')
message_list.see('end')'''
if message == '/colour list':
f = open('./data/colours.txt')
data = literal_eval(f.read())
f.close()
for i in data:
message = ': ' + data[i] + '\n'
user = i
font = colour(data[i])
fontsize = ('Courier', 10)
messages(message, i, fontsize, font, user)
lines = int(message_list.index('end-1c').split('.')[0])
print(lines)
message_list.config(state='normal')
message_list.tag_config(font, foreground=font)
message_list.insert(tkinter.END, user)
message_list.tag_add(font, str(lines + .0),
str(lines) + '.' + str(len(user)))
try:
message_list.insert(tkinter.END, message)
message_list.config(state='disabled')
except: # Should check what kind of error i expect (to improve this)
pass
message_list.see('end')
if message == '/quit':
socket.close()
canvas.destroy()
def kill_socket(socket):
socket.close()
print("socket closed")
def socketClose(socket):
print(" Socket closed: done")
socket.close()
def _close_socket(self, socket):
try:
if socket:
socket.close()
except socket.error, exp:
logging.error('Error while closing socket: ' + str(exp))
def logout(socket): #cleanup dictionaries and disconnect user del currently_online[socket] del user_login_time[socket] Connections.remove(socket) socket.close()
def close_terminal(socket: socket.socket):
coded_msg = EXIT.encode(ENCODING)
socket.send(coded_msg)
socket.close()
logger.debug("Terminal closed")
def NetClose(socket):
socket.close()
def start(self):
"""after init, listen for commands."""
from gfsocket import READY, ERROR, unpack_certified_data
import sys
verbose = self.verbose
socket = self.socket
connection = self.connection
policies = self.policies
admin_policy = self.admin_policy
from select import select
pending_connects = {}
while 1:
try:
# main loop
if self.check_loop<0: self.check_loop=5
for i in xrange(self.check_loop):
if verbose:
print "main loop on", socket, connection
# checkpoint loop
sockets = [socket]
if pending_connects:
sockets = sockets + pending_connects.keys()
# wait for availability
if verbose:
print "server: waiting for connection(s)"
(readables, dummy, errors) = select(\
sockets, [], sockets[:], self.select_timeout)
if socket in errors:
raise ServerError, \
"listening socket in error state: aborting"
# clean up error connection sockets
for s in errors:
del pending_connects[s]
s.close()
# get a new connection, if available
if socket in readables:
readables.remove(socket)
(conn, addr) = socket.accept()
if 1 or verbose:
print "connect %s" % (addr,)
reader = Packet_Reader(conn)
pending_connects[conn] = reader
# poll readable pending connections, if possible
for conn in readables:
reader = pending_connects[conn]
mode = reader.mode
if not mode==READY:
if mode == ERROR:
# shouldn't happen
try:
conn.close()
del pending_connects[conn]
except: pass
continue
else:
try:
reader.poll()
finally:
pass # AFTER DEBUG CHANGE THIS!
# in blocking mode, service ready request,
# commit on no error
for conn in pending_connects.keys():
reader = pending_connects[conn]
mode = reader.mode
if mode == ERROR:
try:
del pending_connects[conn]
conn.close()
except: pass
elif mode == READY:
try:
del pending_connects[conn]
data = reader.data
(actor_name, cert, md) = \
unpack_certified_data(data)
# find the policy for this actor
if not policies.has_key(actor_name):
if verbose:
print "no such policy: "+actor_name
reply_exception(NameError,
"no such policy: "+actor_name, conn)
policy = None
else:
if verbose:
print "executing for", actor_name
policy = policies[actor_name]
policy.action(cert, md, conn)
except SHUTDOWN:
if policy is admin_policy:
print \
"shutdown on admin policy: terminating"
connection.close()
socket.close()
# NORMAL TERMINATION:
return
except RESTART:
if policy is admin_policy:
print \
"restart from admin policy: restarting connection"
connection.restart()
except CHECKPOINT:
if policy is admin_policy:
print \
"checkpoint from admin policy: checkpointing now."
connection.checkpoint()
except:
tb = sys.exc_traceback
info = "%s %s" % (sys.exc_type,
str(sys.exc_value))
if verbose:
from traceback import print_tb
print_tb(tb)
print "error in executing action: "+info
reply_exception(
ServerError, "exception: "+info, conn)
#break # stop after first request serviced!
except:
# except of main while 1 try statement
tb = sys.exc_traceback
ty = sys.exc_type
va = sys.exc_value
print "UNEXPECTED EXCEPTION ON MAINLOOP"
from traceback import print_tb
print_tb(tb)
print "exception:", ty, va
if not pending_connects:
pending_connects = {}
print "server: checkpointing"
connection.checkpoint()
def funcion_servidor(socket, cliente):
direccion_actual = sys.argv[1]
IP = cliente[0]
while 1:
instruccion = socket.recv(1024) #read <a>,load <a>, ls
if instruccion[0:4] == "read":
if direccion_actual in instruccion[5:len(instruccion)]:
nombre_archivo = instruccion[5:len(instruccion)]
if read(nombre_archivo[1]) == "":
time.sleep(1)
socket.send(5)
time.sleep(3)
socket.send("vacio")
print getNow(
) + "enviado contenido (vacio) de " + nombre_archivo + " a " + IP
else:
nombre_archivo = instruccion[5:len(instruccion)]
socket.send(read(nombre_archivo)[0])
time.sleep(3)
socket.send(read(nombre_archivo)[1])
print getNow(
) + "!enviado contenido de " + nombre_archivo + " a " + IP
else:
nombre_archivo = direccion_actual + instruccion[
5:len(instruccion)]
if read(archivo)[1] == "":
socket.send(5)
time.sleep(1)
socket.send("vacio")
print getNow(
) + "enviado contenido (vacio) de " + nombre_archivo + " a " + IP
else:
time.sleep(1)
socket.send(read(nombre_archivo)[0])
time.sleep(1)
socket.send(read(nombre_archivo)[1])
print getNow(
) + "enviado contenido de " + nombre_archivo + " a " + IP
if instruccion[0:2] == "ls":
time.sleep(1)
socket.send(ls(direccion_actual))
print getNow(
) + "enviado listado de archivo de " + direccion_actual + " a " + IP
if instruccion[0:2] == "cd":
time.sleep(1)
try:
os.chdir(direccion_actual + instruccion[3:len(instruccion)])
direccion_actual += instruccion[
3:len(instruccion)] + "/" #Cambiar "/" por "\\" en WINDOWS
socket.send(os.getcwd())
print getNow() + IP + "accedio a" + os.getcwd()
except:
socket.send("ERROR")
print getNow() + IP + "No pudo acceder a" + os.getcwd()
if instruccion[0:4] == "load":
nombre = direccion_actual + instruccion[5:len(instruccion)]
contenido = socket.recv(2048)
load(nombre, contenido)
print getNow() + IP + "subio " + nombre
if instruccion[0:4] == "exit":
socket.close()
print getNow() + " " + IP + " salio"
return 0
if instruccion[0:4] == "walk":
time.sleep(1)
socket.send(walk())
print getNow() + " " + IP + " pidio un walk"
if instruccion[0:5] == "mkdir":
time.sleep(1)
nombre_carpeta = instruccion[6:len(instruccion)]
try:
os.mkdir(direccion_actual + nombre_carpeta)
socket.send("carpeta creada")
print getNow(
) + " " + IP + "creo la carpeta " + direccion_actual + nombre_carpeta
except:
socket.send("error al crear la carpeta")
print getNow(
) + " " + IP + "no puedo crear la carpeta" + direccion_actual + nombre_carpeta
direccion_actual = direccion_actual + "/" #Cambiar "/" por "\\" en windows
if instruccion[0:8] == "download":
time.sleep(1)
if os.path.isfile(instruccion[10:len(instruccion)]):
socket.send(read(nombre_archivo)[0])
time.sleep(1)
socket.send(read(instruccion[10:len(instruccion)])[1])
print getNow(
) + " " + "IP descargo " + instruccion[10:len(instruccion)]
else:
socket.send(20)
time.sleep(1)
socket.send("No hay archivo")
def recieve_from_client(socket):
global global_file_list
while True:
try:
command = socket.recv(1024).decode()
except ConnectionResetError:
command = ""
if len(command) < 1:
for clients in clients_connected:
if clients[2] == socket:
clients_connected.remove(clients)
socket.close()
# ---------------------------------------------------
elif command == "exit":
socket.close()
# ---------------------------------------------------
elif command[:4] == "list":
lock.acquire(True)
temp_list = global_file_list
lock.release()
list_str = ""
final_list = []
for item in temp_list:
if item[0] not in final_list:
final_list.append(item[0])
for item in final_list:
list_str += item + "\n"
list_str = list_str[:-1]
socket.sendall((list_str+"###").encode())
# ---------------------------------------------------
elif command[:4] == 'read':
if(check_extension(command[5:])):
temp_list = global_file_list
file_here = False
for item in temp_list:
if item[0] == command[5:]:
file_here = True
if item[1] == 'self':
socket.sendall(('sending file').encode())
send_file(socket, command[5:])
print("file sent " + command[5:])
break
else:
socket.sendall(
("connect to " + item[2][0]).encode())
break
if(not file_here):
socket.sendall(('No Such File Exists').encode())
else:
socket.sendall(('File not readable').encode())
# -------------------------------------------------------
elif command[:5] == "write":
temp_list = global_file_list
file_here = False
for item in temp_list:
if item[0] == command[6:]:
file_here = True
if item[1] == 'self':
socket.sendall(('sending file').encode())
send_file(socket, command[6:])
print("file sent " + command[6:])
recieve_file(socket, command[6:])
print("file recieved " + command[6:])
replicate_update(command[6:])
print("file sent to update replicated file")
break
else:
socket.sendall(("connect to " + item[2][0]).encode())
break
if(not file_here):
socket.sendall(("file doesnot exist").encode())
# -------------------------------------------------------
elif command[:6] == "create":
temp_list = global_file_list
file_here = False
for item in temp_list:
if item[0] == command[7:]:
file_here = True
socket.sendall(("File already exists").encode())
break
if(not file_here):
socket.sendall(("create possible").encode())
if((create_file(command[7:]))):
print("file created " + command[7:])
global_file_list.append([command[7:], 'self'])
for servers in servers_connected:
servers[2].sendall(('gfl add '+command[7:]).encode())
time.sleep(1)
replicate_create(command[7:])
print("file sent for replication")
else:
print("create file error")
# ------------------------------------------------------
elif command[:6] == 'delete':
temp_list = global_file_list
file_here = False
for item in temp_list:
if item[0] == command[7:]:
file_here = True
if item[1] == 'self':
if((delete_file(command[7:]))):
socket.sendall(('file deleted').encode())
global_file_list.remove([command[7:], 'self'])
print("deleting replicates of the file")
replicate_delete(command[7:])
break
else:
socket.sendall(("file delete error").encode())
else:
socket.sendall(("connect to " + item[2][0]).encode())
break
if(not file_here):
socket.sendall(('No Such File Exists').encode())
# -------------------------------------------------------
elif command[:6] == "append":
temp_list = global_file_list
file_here = False
for item in temp_list:
if item[0] == command[7:]:
file_here = True
if item[1] == 'self':
socket.sendall(('sending file').encode())
send_file(socket, command[7:])
print("file sent " + command[7:])
recieve_file(socket, command[7:])
print("file recieved " + command[7:])
replicate_update(command[7:])
print("file sent to update replicated file")
break
else:
socket.sendall(("connect to " + item[2][0]).encode())
break
if(not file_here):
socket.sendall(("file doesnot exist").encode())
# ---------------------------------------------------------
else:
socket.sendall(("error from server").encode())
def evaluate_request(self, socket):
request = socket.request
print(socket.addr, request)
close = False
write = True
action = request['action']
user = request['user']
if action == 'login':
print("agregar usuario")
player = Player(socket, user)
if user not in self.players.keys():
self.players[user] = player
print("usuario agregado")
content = {
"status": "login",
"rooms": self.get_rooms(),
"players": self.get_players()
}
else:
print("usuario ya existe")
content = {
"status": "error",
"message": f'User "{user}" exists'
}
close = True
elif user in self.players.keys():
if action == 'get_rooms':
print("mostrar rooms")
content = {"status": "get_rooms", "rooms": self.get_rooms()}
elif action == 'create_room':
print("agregar room")
room_name = request['room']
room = Room(room_name)
if room_name not in self.rooms.keys():
self.rooms[room_name] = room
print("room agregado")
content = {
"status": "room_created",
"rooms": self.get_rooms()
}
else:
print("room ya existe")
content = {
"status": "error",
"message": f'Room "{room_name}" exists'
}
elif action == 'join_room':
print("usuario unido a room")
room_name = request['room']
if room_name in self.rooms.keys():
connected = self.rooms[room_name].connect_player(
self.players[user])
if connected:
self.players[user].change_state('inroom')
content = {
"status":
"join_room",
"room":
room_name,
"players_in_room":
self.rooms[room_name].get_players_in_room()
}
socket.write(content)
write = False
self.rooms[room_name].try_start()
else:
content = {
"status": "error",
"message": f'Room "{room_name}"is full'
}
else:
content = {
"status": "error",
"message": f'Room "{room_name}"doesnt exists'
}
elif action == 'get_players':
print("mostrar jugadores")
content = {
"status": "get_players",
"players": self.get_players()
}
elif action == 'message_to_room':
print("enviar mensaje a room")
room = request['room']
message = request['message']
content = {
"status": "message_to_room",
"from": user,
"room": room,
"message": message
}
if (self.message_to_room(content, room)):
content = {
"status": "message_to_room_sent",
"from": user,
"room": room,
"message": message
}
else:
content = {
"status": "error",
"message": 'couldnt send message to room'
}
elif action == 'message_to_player':
print("enviar mensaje a jugador")
to = request['to']
message = request['message']
content = {
"status": "message_to_player",
"from": user,
"to": to,
"message": message
}
if (self.message_to_player(content, to)):
content = {
"status": "message_to_player_sent",
"from": user,
"to": to,
"message": message
}
else:
content = {
"status": "error",
"message": 'couldnt send message to player'
}
elif action == 'card_pick':
print('seleccion del jugador')
room = request['room']
pick = request['card']
player_name = user
if room in self.rooms.keys():
self.rooms[room].card_pick(pick, player_name)
write = False
else:
content = {
"status": "error",
"message": 'room doesnt exists'
}
elif action == 'disconnect':
print("bye player")
self.players.pop(user)
content = {"status": "disconnect"}
close = True
# TODO: enviar y recibir mensajes (chat)
# TODO: logica del juego
else:
content = {
"status": "error",
"message": f'Command "{action}" doesnt exists'
}
else:
content = {"status": "error", "message": 'login first'}
if write:
socket.write(content)
if close:
socket.close()
def handleConn(socket, addr):
data = socket.recv(64)
string = data.decode("utf-8")
print("Message from " + str(addr[0]) + ": " + str(string))
socket.close()
