def cmd_chat(serv, args):
# print "cmd_chat"
user_id = args[0]
client_socket = args[1]
if len(args) < 3:
return pt.MSG_ERROR
chatWithUserId = 0
try:
chatWithUserId = int(args[2].strip())
except:
return pt.MSG_ERROR
fdName = serv.get_user_name(chatWithUserId)
text = ''
if chatWithUserId not in serv.get_users().keys():
text = '%s is not regist !' % chatWithUserId
chatWithUserId = pt.SERV_USER
elif chatWithUserId not in serv.get_usersonline():
text = '%s is not online !' % fdName
chatWithUserId = pt.SERV_USER
elif chatWithUserId not in serv.get_user_friends(user_id):
text = '[{0}:{1}] is not your friend ! Please add he/she first !'.format(
chatWithUserId, fdName)
chatWithUserId = pt.SERV_USER
else:
text = 'You are chating with: [{0}:{1}]'.format(
chatWithUserId, fdName)
if client_socket == serv.get_server_socket():
print text
else:
pt.send(client_socket, chatWithUserId, pt.SERV_USER, pt.MSG_CMD, text)
def process_cmd(self, user_id, msg):
client_socket = self.get_user_socket(user_id)
if client_socket is None:
return pt.MSG_ERROR
if not msg:
return pt.MSG_ERROR
res = pt.getcmd(msg)
if res is None:
return pt.MSG_ERROR
cmdno = res[0]
args = res[1]
argss = [user_id, client_socket]
text = pt.MAP_CMD_NO.keys()[pt.MAP_CMD_NO.values().index(cmdno)]
for ag in args:
argss.append(ag)
text = text + " " + ag
text = '{0}:{1} | {2}'.format(user_id, self.get_user_name(user_id),
text)
print text
if self.issupportcmd(user_id, cmdno) is not True:
text = text + " | no authority or no this command !"
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_ERROR, text)
return pt.MSG_ERROR
return scmap.MAP_CMD_FUN[cmdno](self, argss)
def process_cmd(self, user_id, msg):
client_socket = self.get_user_socket(user_id)
if client_socket is None:
return pt.MSG_ERROR
if not msg:
return pt.MSG_ERROR
res = pt.getcmd(msg)
if res is None:
return pt.MSG_ERROR
cmdno = res[0]
args = res[1]
argss = [user_id, client_socket]
text = pt.MAP_CMD_NO.keys()[pt.MAP_CMD_NO.values().index(cmdno)]
for ag in args:
argss.append(ag)
text = text + " " + ag
text = '{0}:{1} | {2}'.format(user_id,
self.get_user_name(user_id),
text)
print text
if self.issupportcmd(user_id, cmdno) is not True:
text = text + " | no authority or no this command !"
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_ERROR, text)
return pt.MSG_ERROR
return scmap.MAP_CMD_FUN[cmdno](self, argss)
def send_data(self, data): try: protocol.send(self.sending_socket, data) address = self.socketaddresses[self.sending_socket] self.output_func(self.sending_socket,self.host,self.port,address) except: self.remove_socket(self.sending_socket)
def run(self):
print("running...")
self.running = True
while self.running and self.ins:
rds, wts, ers = select.select(self.ins, self.outs, self.ins, 0)
for s in rds:
if s is self._s:
if len(self.clients) < 2:
cl, addr = s.accept()
print("New client %s" % str(addr))
self.ins.append(cl)
self.clients[cl] = b''
player_no = len(self.players)
pname = player_name(player_no)
send(cl, 'info', "welcome %s" % pname)
send(cl, 'player_id', player_no)
self.players[cl] = player_no
if len(self.players) == 2:
self.broadcast('info', "Ready to play")
self.send_game()
else:
print("Maximum clients reached")
cl, addr = s.accept()
cl.close()
else:
data = s.recv(5)
if data:
self.clients[s] += data
else:
print("Client disconnected")
self.ins.remove(s)
self.clients.pop(s)
if len(self.players) == 2:
self.broadcast(
'info',
"%s left. Exiting..." % \
player_name(self.players[s])
)
self.running = False
s.close()
for s in ers:
print("Error, closing socket.")
self.ins.remove(s)
s.close()
# manage data
for s in self.clients:
data = self.clients[s]
msg, remain = extract_msg(data)
if msg:
self.process_msg(s, msg)
self.clients[s] = remain
print("closing sockets")
for s in self.clients:
s.close()
self._s.close()
def send_data(self, data):
try:
protocol.send(self.sending_socket, data)
address = self.socketaddresses[self.sending_socket]
self.output_func(self.sending_socket, self.host, self.port,
address)
except:
self.remove_socket(self.sending_socket)
def process_chat(self, from_user, to_user, msg):
toSocket = self.get_user_socket(to_user)
if toSocket is None:
return pt.MSG_ERROR
text = '[{0}:{1}] {2}'.format(from_user, self.get_user_name(from_user),
msg)
print text
pt.send(toSocket, to_user, from_user, pt.MSG_TEXT, text)
def send_data_to_all(self, data):
for socket in self.connected_sockets:
try:
protocol.send(socket, data)
address = self.socketaddresses[socket]
self.output_func(socket, self.host, self.port, address)
except:
self.remove_socket(socket)
def send_data_to_all(self, data): for socket in self.connected_sockets: try: protocol.send(socket, data) address = self.socketaddresses[socket] self.output_func(socket,self.host,self.port,address) except: self.remove_socket(socket)
def send_to_hardware(message=p.rx_string):
try:
string = p.beautify(p.create(message))
for i in string:
raw_go_hw = p.RX(data=i).raw()
p.send(raw_go_hw)
except:
raw_go_hw = p.RX().raw()
p.send(raw_go_hw)
def process_chat(self, from_user, to_user, msg):
toSocket = self.get_user_socket(to_user)
if toSocket is None:
return pt.MSG_ERROR
text = '[{0}:{1}] {2}'.format(from_user,
self.get_user_name(from_user),
msg)
print text
pt.send(toSocket, to_user, from_user, pt.MSG_TEXT, text)
def run(self):
client = self.client
while not self.done:
data = raw_input()
data_type = pt.MSG_TEXT
if len(data) > 0 and data[0] == '/':
data_type = pt.MSG_CMD
client.curchatuser = pt.SERV_USER
pt.send(self.client_socket, client.curchatuser, client.user_id,
data_type, data)
def __init__(self, message, subject, serializer, port, host):
try:
send_socket = socket.socket()
send_socket.connect((host, port))
protocol.send(send_socket, serializer(message), subject)
send_socket.close()
except socket.error, msg:
logger.warn(
str(msg[1]) + "Did you Initialize() to start the core?")
def send_game(self, client=None):
state = {
'scores': self.game.scores,
'game': self.game.game,
'to_play': self.game.current_player,
}
if client:
send(client, 'game_state', state)
else:
self.broadcast('game_state', state)
def run(self):
client = self.client
while not self.done:
data = raw_input()
data_type = pt.MSG_TEXT
if len(data) > 0 and data[0] == '/':
data_type = pt.MSG_CMD
client.curchatuser = pt.SERV_USER
pt.send(self.client_socket, client.curchatuser,
client.user_id, data_type, data)
def client_process(self, sock, active_clients):
while 1:
data = protocol.recv(sock)
if not data:
return sock.close()
encryption = TripleDESCipher(data["key"])
if data["encryption"] == 1:
protocol.send(sock, (active_clients, encryption.encrypt(data["message"])))
else:
protocol.send(sock, (active_clients, encryption.decrypt(data["message"])))
def __init__(self, subject, callback, deserializer, port, host):
try:
receive_socket = socket.socket()
receive_socket.connect((host, port))
protocol.send(receive_socket, "", subject)
message, _ = protocol.receive(receive_socket)
except socket.error, msg:
logger.warn(
str(msg[1]) + " Did you Initialize() to start the core?")
return
def logon(self, user_id, user_pwd, client_socket, client_addr):
if user_id not in self.get_users():
return None
if user_pwd != self.get_user_pwd(user_id):
text = 'PassWord is Wrong !'
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_ERROR, text)
return False
else:
self.set_useronline_flag(user_id, pt.FLAG_ONLINE)
self.set_user_socket(user_id, client_socket)
self.set_user_addr(user_id, client_addr)
return True
def logon(self, user_id, user_pwd, client_socket, client_addr):
if user_id not in self.get_users():
return None
if user_pwd != self.get_user_pwd(user_id):
text = 'PassWord is Wrong !'
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_ERROR, text)
return False
else:
self.set_useronline_flag(user_id, pt.FLAG_ONLINE)
self.set_user_socket(user_id, client_socket)
self.set_user_addr(user_id, client_addr)
return True
def client_process(sock, server_sock, nclients, timeout=60):
server_sock.close()
sock.settimeout(timeout)
while 1:
data = protocol.recv(sock)
if not data:
return sock.close()
encryption = TripleDESCipher(data["key"])
if data["encryption"] == 1:
protocol.send(sock, (nclients.value, encryption.encrypt(data["message"])))
else:
protocol.send(sock, (nclients.value, encryption.decrypt(data["message"])))
def cmd_online(serv, args):
# print " cmd_online"
user_id = args[0]
client_socket = args[1]
users = serv.get_usersonline()
names = ''
for uid in users.keys():
names = names + str(uid) + ':' + serv.get_user_name(uid) + '\n'
if client_socket == serv.get_server_socket():
print names
else:
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_TEXT, names)
def cmd_get_cmds(serv, args):
user_id = args[0]
client_socket = args[1]
text = ''
if client_socket == serv.get_server_socket():
cmds = pt.CMD_SET
else:
cmds = serv.get_user_cmds(user_id)
for no in cmds:
text = text + pt.get_cmd_name(no) + " : " + str(no) + "\n"
if client_socket == serv.get_server_socket():
print text
else:
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_TEXT, text)
def cmd_name(serv, args):
# print " cmd _ name()"
user_id = args[0]
client_socket = args[1]
names = serv.get_users()
text = ''
for id, info in names.items():
text = text + str(id) + ':' + serv.get_user_name(id) + '\n'
if client_socket == serv.get_server_socket():
print text
else:
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_TEXT, text)
def run(self):
try:
thread_serv = threading.Thread(target=self.server_cmd)
thread_serv.start()
while True and not self.__done:
client_socket, client_addr = self.__server_socket.accept()
thread = threading.Thread(target=self.clientLink, args=(client_socket, client_addr))
thread.start()
except KeyboardInterrupt:
return
finally:
for uid, info in self.get_usersonline().items():
client_socket = self.get_user_socket(uid)
pt.send(client_socket, uid, pt.SERV_USER, pt.CMD_QUIT, "Server is Sign Out !")
self.save_users(self.__file_name)
def main():
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
server_socket.bind((IP, PORT))
server_socket.listen(QUEUE_SIZE)
# endless loop to receive client after client
while True:
comm_socket, client_address = server_socket.accept()
while True:
try:
request = protocol.recv(comm_socket)
if request[0] == "Exit":
comm_socket.close()
break
# add request to answer function call
is_work = protocol.send(comm_socket, request)
if not is_work:
comm_socket.close()
break
except socket.error as msg:
print 'client socket disconnected- ' + str(msg)
comm_socket.close()
break
except socket.error as msg:
print 'failed to open server socket - ' + str(msg)
finally:
server_socket.close()
def run(self):
try:
thread_serv = threading.Thread(target=self.server_cmd)
thread_serv.start()
while True and not self.__done:
client_socket, client_addr = self.__server_socket.accept()
thread = threading.Thread(target=self.clientLink,
args=(client_socket, client_addr))
thread.start()
except KeyboardInterrupt:
return
finally:
for uid, info in self.get_usersonline().items():
client_socket = self.get_user_socket(uid)
pt.send(client_socket, uid, pt.SERV_USER, pt.CMD_QUIT,
"Server is Sign Out !")
self.save_users(self.__file_name)
def cmd_friends(serv, args):
# print "cmd_friends"
user_id = args[0]
client_socket = args[1]
if client_socket == serv.get_server_socket():
return
friends = serv.get_user_friends(user_id)
text = ''
for uid in friends:
ol = ' '
uid = int(uid)
if serv.isuseronline(uid) == pt.FLAG_ONLINE:
ol = '* '
text = text + ol + str(uid) + ':' + serv.get_user_name(uid) + '\n'
if client_socket == serv.get_server_socket():
print text
else:
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_TEXT, text)
def _relay(self, receive_socket):
"""
Relays a signal, initiated by a notification, to the
appropriate observers.
"""
message, notifier_subject = protocol.receive(receive_socket)
for observer_subject in self.observers:
if observer_subject == notifier_subject:
for observer_sock in self.observers[observer_subject]:
try:
protocol.send(observer_sock, message, notifier_subject)
# Remove observer socket since it's only created
# for one-time use.
self.observers[observer_subject].remove(observer_sock)
except socket.error, msg:
# Unprepared observer
logger.warn("Socket error (core): " + msg[1])
def run(tcp_ip, tcp_port, gui, ai=None):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("connecting to", tcp_ip)
sock.connect((tcp_ip, tcp_port))
running = True
inputs = [
sock,
]
# If no AI, this thread will manage keyboard inputs
# TODO : remove for a more advanced GUI
if ai is None:
inputs.append(sys.stdin)
data = b''
while running:
rds, wts, ers = select.select(inputs, [], [], 0)
for s in rds:
if s is sys.stdin:
# Managing keyboard input
cmd = s.readline()
send(sock, 'play', cmd.strip())
if s is sock:
d = s.recv(2048)
if d:
data += d
else:
print("lost connection")
running = False
# manage data
msg, remain = extract_msg(data)
if msg:
mtype, mval = decode_message(msg)
gui.process_message(mtype, mval)
# if an AI is attached, ask for a play
if ai is not None:
play = ai.process_message(mtype, mval)
if play is not None:
send(sock, 'play', play)
data = remain
sock.close()
def logon(self, user_id, user_pwd):
pt.send(self.client_socket, pt.SERV_USER,
user_id, pt.MSG_LOGON, user_pwd)
to_user, from_user, msg_type, msg = pt.recv(self.client_socket)
print msg
if msg_type == pt.MSG_LOGON:
return True
elif msg_type == pt.MSG_ERROR:
return False
elif msg_type == pt.MSG_REGISTER:
while msg_type == pt.MSG_REGISTER:
msg = sys.stdin.readline().strip()
pt.send(self.client_socket, pt.SERV_USER,
user_id, pt.MSG_REGISTER, msg)
to_user, from_user, msg_type, msg = pt.recv(self.client_socket)
print msg
if msg_type == pt.MSG_LOGON:
return None
return False
def main():
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
client_socket.connect((SERVER_IP, SERVER_PORT))
# send the message
while True:
massage = []
massage.append(raw_input("enter action"))
massage.append(raw_input("enter action"))
protocol.send(client_socket, massage)
if massage[0] == "Exit":
break
packet = []
packet = protocol.recv(client_socket)
print packet[0] + " " + packet[1]
except socket.error as msg:
print 'error in communication with server - ' + str(msg)
finally:
client_socket.close()
def cmd_mdpwd(serv, args):
# print " cmd_mdpwd"
user_id = args[0]
client_socket = args[1]
if len(args) < 4:
return pt.MSG_ERROR
input_oldpwd = args[2]
input_newpwd = args[3]
old_pwd = serv.get_user_pwd(user_id)
if serv.modify_pwd(user_id, input_oldpwd, input_newpwd) == True:
text = '[{0}:{1}] old PassWord is : {2}, Now is {3}'.format(
user_id, serv.get_user_name(user_id), old_pwd, input_newpwd)
if client_socket == serv.get_server_socket():
print text
else:
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_TEXT, text)
else:
return pt.MSG_ERROR
def logon(self, user_id, user_pwd):
pt.send(self.client_socket, pt.SERV_USER, user_id, pt.MSG_LOGON,
user_pwd)
to_user, from_user, msg_type, msg = pt.recv(self.client_socket)
print msg
if msg_type == pt.MSG_LOGON:
return True
elif msg_type == pt.MSG_ERROR:
return False
elif msg_type == pt.MSG_REGISTER:
while msg_type == pt.MSG_REGISTER:
msg = sys.stdin.readline().strip()
pt.send(self.client_socket, pt.SERV_USER, user_id,
pt.MSG_REGISTER, msg)
to_user, from_user, msg_type, msg = pt.recv(self.client_socket)
print msg
if msg_type == pt.MSG_LOGON:
return None
return False
def cmd_quit(serv, args):
# print "cmd_quit"
user_id = args[0]
client_socket = args[1]
if client_socket == serv.get_server_socket():
return pt.MSG_QUIT
serv.set_useronline_flag(user_id, not pt.FLAG_ONLINE)
user_sever = '0:Server'
fuser = '******'.format(user_id, serv.get_user_name(user_id))
quitString = '[from {0} to {1}] {1} Quit !'.format(user_sever, fuser)
for id in serv.get_usersonline().keys():
if id != user_id:
onLineSocket = serv.get_user_socket(id)
pt.send(onLineSocket, id, pt.SERV_USER, pt.MSG_FRIEND_QUIT,
quitString)
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_QUIT, quitString)
print quitString
return pt.MSG_QUIT
def cmd_del_friend(serv, args):
# print "cmd_del_friend"
user_id = args[0]
client_socket = args[1]
if len(args) < 3:
return pt.MSG_ERROR
try:
fdId = int(args[2].strip())
if fdId not in serv.get_user_friends(user_id):
text = '[{0}:{1}] is not your friend ! Can\'t delete !'.format(
fdId, serv.get_user_name(fdId))
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_ERROR, text)
else:
text = '[{0}:{1}] delete friend: [{2}:{3}] !'.format(
user_id, serv.get_user_name(user_id), fdId,
serv.get_user_name(fdId))
text = text + ' Now he/she is not your friend !'
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_TEXT, text)
except:
return pt.MSG_ERROR
def clientLink(self, client_socket, client_addr):
print 'Accept new connection from %s:%s....' % client_addr
time.sleep(1)
to_user, from_user, data_type, data = pt.recv(client_socket)
user_id = from_user
user_pwd = data
user_sever = '0:server'
if to_user != pt.SERV_USER or data_type != pt.MSG_LOGON or data is None or not data:
text = 'Logon Error !'
print text
else:
sg = self.logon(user_id, user_pwd, client_socket, client_addr)
if sg is None:
user_id = self.register(client_socket, client_addr, user_id)
if user_id is not None:
self.set_useronline_flag(user_id, not pt.FLAG_ONLINE)
client_socket.close()
print 'Close connection from %s:%s....' % client_addr
return
elif sg is False:
client_socket.close()
print 'Close connection from %s:%s....' % client_addr
return
user = '******'.format(user_id, self.get_user_name(
user_id)) # %user_id self.get_user_name(user_id)
send_text = '[{0}] Welcome {1}'.format(user_sever, user)
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_LOGON,
send_text)
print send_text
while True:
to_user, from_user, msg_type, msg = pt.recv(client_socket)
fuser = '******'.format(from_user,
self.get_user_name(from_user))
# no the to_user
if to_user != pt.SERV_USER and to_user not in self.get_users():
erro_string = '[from {0} to {1} ] {2} not regist !'.format(
user_sever, fuser, to_user)
pt.send(client_socket, from_user, pt.SERV_USER,
pt.MSG_TEXT, erro_string)
print erro_string
# to the server ,should cmd
elif to_user == pt.SERV_USER:
sg = self.process_cmd(from_user, msg)
if sg == pt.MSG_QUIT:
break
elif sg == pt.MSG_ERROR:
erro_string = '[from {0} to {1}] {2} : {3}'.format(
user_sever, fuser, msg, 'Wrong Cmd to Server !')
pt.send(client_socket, from_user, pt.SERV_USER,
pt.MSG_ERROR, erro_string)
print erro_string
# to other client
else:
sg = self.process_chat(from_user, to_user, msg)
if sg == pt.MSG_ERROR:
erro_string = '[from {0} to {1}] {2} not online !'.format(
user_sever, fuser, to_user)
client_socket.close()
print 'Close connection from %s:%s....' % client_addr
def process_msg(self, client, msg):
if len(self.players) != 2:
send(client, 'info', "Waiting for opponent")
return
msg_type, msg = decode_message(msg)
if msg_type == 'play':
try:
self.game.play(self.players[client], msg)
p = player_name(self.players[client])
self.broadcast('info', "%s played %s" % (p, msg))
self.send_game()
except AwaleException as e:
send(client, 'error', str(e))
if self.game.over():
win_player = winner(self.game.game, self.game.scores)
if win_player is not None:
self.broadcast('info',
"%s wins !" % player_name(win_player))
else:
self.broadcast('info', "Draw !")
self.running = False
def cmd_rename(serv, args):
# print "cmd_rename()"
if len(args) < 2:
return pt.MSG_ERROR
user_id = args[0]
client_socket = args[1]
if len(args) > 2:
new_name = args[2]
else:
return pt.MSG_ERROR
old_name = serv.set_user_name(user_id, new_name)
msg = '[{0}] now call :[{1}]'.format(old_name, new_name)
if old_name is None:
return pt.MSG_ERROR
else:
for uid, info in serv.get_usersonline().items():
client_socket = serv.get_user_socket(uid)
pt.send(client_socket, uid, pt.SERV_USER, pt.MSG_TEXT, msg)
if client_socket == serv.get_server_socket():
print msg
def cmd_add_friend(serv, args):
# print "cmd_add_friend"
user_id = args[0]
client_socket = args[1]
if len(args) < 3:
return pt.MSG_ERROR
try:
fdId = int(args[2].strip())
msg_type = pt.MSG_TEXT
if fdId not in serv.get_users():
text = '%s is not regist !' % fdId
msg_type = pt.MSG_ERROR
if serv.add_friend(user_id, fdId):
text = '[{2}:{3}] have a new friend :[{0}:{1}]'.format(
fdId, serv.get_user_name(fdId), user_id,
serv.get_user_name(user_id))
if client_socket == serv.get_server_socket():
print text
else:
pt.send(client_socket, user_id, pt.SERV_USER, msg_type, text)
except:
return pt.MSG_ERROR
def clientLink(self, client_socket, client_addr):
print 'Accept new connection from %s:%s....' % client_addr
time.sleep(1)
to_user, from_user, data_type, data = pt.recv(client_socket)
user_id = from_user
user_pwd = data
user_sever = '0:server'
if to_user != pt.SERV_USER or data_type != pt.MSG_LOGON or data is None or not data:
text = 'Logon Error !'
print text
else:
sg = self.logon(user_id, user_pwd, client_socket, client_addr)
if sg is None:
user_id = self.register(client_socket, client_addr, user_id)
if user_id is not None:
self.set_useronline_flag(user_id, not pt.FLAG_ONLINE)
client_socket.close()
print 'Close connection from %s:%s....' % client_addr
return
elif sg is False:
client_socket.close()
print 'Close connection from %s:%s....' % client_addr
return
user = '******'.format(user_id, self.get_user_name(user_id)) # %user_id self.get_user_name(user_id)
send_text = '[{0}] Welcome {1}'.format(user_sever, user)
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_LOGON, send_text)
print send_text
while True:
to_user, from_user, msg_type, msg = pt.recv(client_socket)
fuser = '******'.format(from_user, self.get_user_name(from_user))
# no the to_user
if to_user != pt.SERV_USER and to_user not in self.get_users():
erro_string = '[from {0} to {1} ] {2} not regist !'.format(user_sever, fuser, to_user)
pt.send(client_socket, from_user, pt.SERV_USER, pt.MSG_TEXT, erro_string)
print erro_string
# to the server ,should cmd
elif to_user == pt.SERV_USER:
sg = self.process_cmd(from_user, msg)
if sg == pt.MSG_QUIT:
break
elif sg == pt.MSG_ERROR:
erro_string = '[from {0} to {1}] {2} : {3}'.format(user_sever,
fuser,
msg,
'Wrong Cmd to Server !')
pt.send(client_socket, from_user, pt.SERV_USER, pt.MSG_ERROR, erro_string)
print erro_string
# to other client
else:
sg = self.process_chat(from_user, to_user, msg)
if sg == pt.MSG_ERROR:
erro_string = '[from {0} to {1}] {2} not online !'.format(user_sever,
fuser,
to_user)
client_socket.close()
print 'Close connection from %s:%s....' % client_addr
def handle_commands(connection, command, params):
if command == "dl":
if params[1] == '0':
params[1] = False
else:
params[1] = True
if not params[1] and len(params) == 2:
params.append(None)
htt_thread = threading.Thread(target=httrack.download,
args=(params[0], params[1], params[2]))
htt_thread.start()
dl_status = threading.Timer(2.0,
dl_status_checker,
args=(htt_thread, connection))
dl_status.start()
elif command == "list":
file_list = listdir(config.sites_directory)
folder_list = []
archive_list = []
for file in file_list:
if path.isdir(config.sites_directory + '/' +
file) and file != "hts-cache":
folder_list.append(file)
if path.isfile(config.sites_directory + '/' + file) and \
(file[-7:] == ".tar.gz" or file[-8:] == ".tar.bz2" or file[-5:] == ".tar"):
archive_list.append(file)
site_string = ""
folder_found = False
if folder_list:
site_string += "List of folders:\n" + "\n".join(folder_list)
folder_found = True
if archive_list:
if folder_found:
site_string += "\n================================================================================\n"
site_string += "List of archives:\n" + "\n".join(archive_list)
if site_string == "":
site_string = "Sites not found!"
protocol.send(connection, site_string)
elif command == "load":
load = ""
for i in range(1, 100000):
load += str(i) + ' '
if i % 1000 == 0:
load += '\n'
protocol.send(connection, load)
else:
protocol.send(connection, "Invalid request")
def handle_commands(connection, command, params):
if command == "dl":
if params[1] == '0':
params[1] = False
else:
params[1] = True
if not params[1] and len(params) == 2:
params.append(None)
htt_thread = threading.Thread(target=httrack.download, args=(params[0], params[1], params[2]))
htt_thread.start()
dl_status = threading.Timer(2.0, dl_status_checker, args=(htt_thread, connection))
dl_status.start()
elif command == "list":
file_list = listdir(config.sites_directory)
folder_list = []
archive_list = []
for file in file_list:
if path.isdir(config.sites_directory + '/' + file) and file != "hts-cache":
folder_list.append(file)
if path.isfile(config.sites_directory + '/' + file) and \
(file[-7:] == ".tar.gz" or file[-8:] == ".tar.bz2" or file[-5:] == ".tar"):
archive_list.append(file)
site_string = ""
folder_found = False
if folder_list:
site_string += "List of folders:\n" + "\n".join(folder_list)
folder_found = True
if archive_list:
if folder_found:
site_string += "\n================================================================================\n"
site_string += "List of archives:\n" + "\n".join(archive_list)
if site_string == "":
site_string = "Sites not found!"
protocol.send(connection, site_string)
elif command == "load":
load = ""
for i in range (1, 100000):
load += str(i) + ' '
if i % 1000 == 0:
load += '\n'
protocol.send(connection, load)
else:
protocol.send(connection, "Invalid request")
def register(self, client_socket, client_addr, user_id):
text = 'You have to register first ! Are you Register ?(y/n):'
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_REGISTER, text)
while True:
to_user, from_user, data_type, data = pt.recv(client_socket)
if data.strip() != '':
break
if data_type != pt.MSG_REGISTER:
return None
elif data != 'y' and data != 'yes':
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_ERROR, "")
return None
else:
text = 'Please input your : user_id(must Integer) user_name user_pwd \n'
print text
pt.send(client_socket, from_user, pt.SERV_USER, pt.MSG_REGISTER, text)
to_user, from_user, data_type, data = pt.recv(client_socket)
dtlist = data.strip().split(' ')
text = 'Input is Wrong !'
if len(dtlist) != 3:
pt.send(client_socket, from_user, pt.SERV_USER, pt.MSG_ERROR, text)
return None
else:
user_id = 0
try:
user_id = int(dtlist[0])
user_name = dtlist[1]
user_pwd = dtlist[2]
except:
text = 'UserId is Wrong !'
pt.send(client_socket, from_user, pt.SERV_USER, pt.MSG_ERROR, text)
return None
if user_id in self.get_users():
text = 'UserId exist !'
pt.send(client_socket, from_user, pt.SERV_USER, pt.MSG_ERROR, text)
return None
if self.get_user_id(user_name)is not None:
text = 'UserName exist !'
pt.send(client_socket, from_user, pt.SERV_USER, pt.MSG_ERROR, text)
return None
if self.register_user(user_id, user_name, user_pwd, client_socket, client_addr) == True:
text = '[from server] {0}:{1} Register OK ! PassWord : {2}'.format(user_id,
user_name,
user_pwd)
pt.send(client_socket, user_id, pt.SERV_USER, pt.MSG_LOGON, text)
self.save_users(self.__file_name)
return user_id
else:
text = 'Register Wrong!'
pt.send(client_socket, from_user, pt.SERV_USER, pt.MSG_ERROR, text)
self.done = False
def run(self):
client = self.client
while not self.done:
data = raw_input()
data_type = pt.MSG_TEXT
if len(data) > 0 and data[0] == '/':
data_type = pt.MSG_CMD
client.curchatuser = pt.SERV_USER
pt.send(self.client_socket, client.curchatuser,
client.user_id, data_type, data)
if __name__ == '__main__':
if len(sys.argv) != 3:
print u'Wrong Argvs : user_id(integer), user_pwd '
else:
hostname = '127.0.0.1'
port = 18889
qq_client = qqclient(hostname, port)
user_id = 0
try:
user_id = int(sys.argv[1])
user_pwd = sys.argv[2]
qq_client.run(user_id, user_pwd)
except ValueError, e:
pt.send(qq_client.client_socket, pt.SERV_USER,
qq_client.user_id, pt.MSG_QUIT, '')
print u'Wrong user_id(integer)!\nValueError: ', e
# -*- coding: utf-8 -*- # !/usr/bin/env python3 import socket import config import protocol sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((config.host, config.port)) protocol.send(sock, input()) data = protocol.recv(sock) sock.close() print(data)
def dl_status_checker(thread, connection):
if thread.isAlive:
protocol.send(connection, "Downloading has started")
else:
protocol.send(connection, "Downloading has FAILED")
def send(self, data):
protocol.send(self.sock, data)
def quit(self):
protocol.send(self.sock, b"client quit")
self.sock.close()
