def handle(conn, addr, currentUser, server, data):
server.cursor.execute("SELECT COUNT(*) FROM chatHistory WHERE channel=?",
[currentUser.channel])
numInChannel = (server.cursor.fetchall())[0][0]
currentLoaded = currentUser.timesRequestedHistory * 50
if currentLoaded >= numInChannel:
pass
else: # More to load
currentUser.timesRequestedHistory += 1
leftToLoad = numInChannel - currentLoaded
if leftToLoad < 50:
descLimit = currentUser.timesRequestedHistory * 50
ascLimit = (currentUser.timesRequestedHistory - 1) * 50
server.cursor.execute(
"SELECT * FROM (SELECT * FROM (SELECT * FROM chatHistory WHERE channel=? ORDER BY realtime DESC limit ?) ORDER BY realtime ASC limit ?) ORDER BY realtime DESC",
[currentUser.channel, descLimit, leftToLoad])
remainingMessages = server.cursor.fetchall()
else:
descLimit = currentUser.timesRequestedHistory * 50
ascLimit = (currentUser.timesRequestedHistory - 1) * 50
server.cursor.execute(
"SELECT * FROM (SELECT * FROM (SELECT * FROM chatHistory WHERE channel=? ORDER BY realtime DESC limit ?) ORDER BY realtime ASC limit ?) ORDER BY realtime DESC",
[currentUser.channel, descLimit, ascLimit])
remainingMessages = server.cursor.fetchall()
sendMessage(currentUser.conn, currentUser.secret, "additionalHistory",
json.dumps(remainingMessages))
def handle(conn, addr, currentUser, server, data):
query = text("SELECT COUNT(*) FROM chatHistory WHERE channel=:a")
numInChannel = ((server.dbconn.execute(
query, a=currentUser.channel)).fetchone())[0]
currentLoaded = currentUser.timesRequestedHistory * 50
if currentLoaded >= numInChannel:
pass
else: # More to load
currentUser.timesRequestedHistory += 1
leftToLoad = numInChannel - currentLoaded
descLimit = currentUser.timesRequestedHistory * 50
ascLimit = (currentUser.timesRequestedHistory - 1) * 50
if leftToLoad < 50:
ascLimit = leftToLoad
query = text(
"SELECT * FROM (SELECT * FROM (SELECT * FROM chatHistory WHERE channel=:a ORDER BY realtime DESC limit :b) suba ORDER BY realtime ASC limit :c) subb ORDER BY realtime DESC"
)
remainingMessages = (server.dbconn.execute(query,
a=currentUser.channel,
b=descLimit,
c=ascLimit)).fetchall()
sendMessage(currentUser.conn, currentUser.secret, "additionalHistory",
json.dumps(encoding.reformatData(remainingMessages)))
def handle(conn, addr, currentUser, server, command):
try:
roleList = {}
with open(r"configs/roles.json", "r") as roleFile:
roleList = json.load(roleFile)
commandsConfig = {}
with open(r"configs/commands.json", "r") as commandsFile:
commandsConfig = json.load(commandsFile)
helpData = []
for command in commandsConfig.keys():
exec("import modules.commands.{0}".format(command))
exec("helpData.append( modules.commands.{0}.gethelp() )".format(
command))
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(currentUser.conn,
currentUser.secret,
"commandData",
json.dumps(helpData),
subtype="multiLine",
metadata=metadata)
return True
except IndexError:
return False
def handle(conn, addr, currentUser, server, command):
try:
userData = []
userData.append("Username: "******"eID: " + currentUser.eID)
userAddr = str("IP: " + currentUser.addr[0]) + ":" + str(currentUser.addr[1])
userData.append(userAddr)
if currentUser.channel == None:
userData.append("No channel")
else:
userData.append("Channel: " + currentUser.channel)
query = userRoles.select().where(userRoles.c.eID == currentUser.eID)
roleData = (server.dbconn.execute(query)).fetchone()
if roleData == None:
pass
else:
roleData = ast.literal_eval(roleData[1])
for role in roleData:
userData.append("Role: " + role)
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(currentUser.conn, currentUser.secret, "commandData", json.dumps(userData), subtype="multiLine", metadata=metadata)
return True
except IndexError:
return False
def handle(conn, addr, currentUser, server, command):
try:
target = command[1]
pmData = command[2:]
for k, v in server.users.items():
if target == v.username:
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = [
"[PM] " + currentUser.username,
ColorHash(currentUser.username).hex, dt
]
sendMessage(currentUser.conn,
currentUser.secret,
"outboundMessage",
" ".join(pmData),
metadata=metadata)
sendMessage(v.conn,
v.secret,
"outboundMessage",
" ".join(pmData),
metadata=metadata)
if config.GetSetting("storePmlogs", "Logging") == "True":
dbLogger.logPM(server, currentUser, v, " ".join(pmData))
return True
return False
except IndexError:
return False
def StopServer(self):
self.recvControl = False
for k, v in self.users.items():
sendMessage(v.conn,
v.secret,
"connectionTerminated",
"Server is shutting down",
subtype="shutdown")
logger.info("Server Stopped")
def ServerMessage(self, user, content):
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(user.conn,
user.secret,
"outboundMessage",
content,
metadata=metadata)
def handle(conn, addr, currentUser, server, data):
del server.users[currentUser.eID]
if currentUser.channel != None:
server.channels[currentUser.channel].remove(currentUser.eID)
channelUsers = json.dumps(server.GetChannelUsers(currentUser.channel))
for eID in server.channels[currentUser.channel]:
sendMessage(server.users[eID].conn, server.users[eID].secret,
"channelUpdate", channelUsers)
currentUser.connectionValid = False
conn.close()
def handle(conn, addr, currentUser, server, command):
try:
target = command[1]
if target == currentUser.username:
return False
else:
banReason = " ".join(command[2:])
if banReason == "":
banReason = "No reason given"
for k, v in server.users.items():
if target == v.username:
if server.IsNotBanned(v):
if server.IsValidCommandTarget(currentUser, v):
sendMessage(v.conn, v.secret, "connectionTerminated", banReason, subtype="kick")
logger.info("Client " + str(v.addr) + " was banned from the server")
del server.users[v.eID]
if v.channel != None:
server.channels[v.channel].remove(v.eID)
channelUsers = json.dumps(server.GetChannelUsers(v.channel))
for eID in server.channels[v.channel]:
sendMessage(server.users[eID].conn, server.users[eID].secret, "channelUpdate", channelUsers);
v.connectionValid = False
v.conn.close()
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(currentUser.conn, currentUser.secret, "outboundMessage", "User " + v.username + " was banned", metadata=metadata)
server.cursor.execute("INSERT INTO bannedUsers (eID, IP, dateBanned, reason) values (?,?,?,?)",[v.eID, v.addr[0], dt, banReason])
server.dbconn.commit()
return True
else:
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(currentUser.conn, currentUser.secret, "outboundMessage", "You cannot execute this command on that user", metadata=metadata)
return False
else:
sendMessage(currentUser.conn, currentUser.secret, "outboundMessage", "User " + v.username + " is already banned", metadata=metadata)
return False
return False
except IndexError:
return False
def handle(conn, addr, currentUser, server, data): if currentUser.channel != None: currentUser.timesRequestedHistory = 1 oldChannel = currentUser.channel currentUser.channel = None # Update users in old channel (if exists) server.channels[oldChannel].remove(currentUser.eID) channelUsers = json.dumps(server.GetChannelUsers(oldChannel)) for eID in server.channels[oldChannel]: sendMessage(server.users[eID].conn, server.users[eID].secret, "channelUpdate", channelUsers) else: sendMessage(conn, currentUser.secret, "errorOccured", "notInChannel")
def handle(conn, addr, currentUser, server, command):
try:
target = command[1]
for k, v in server.users.items():
if target == v.username:
userData = []
userData.append("Username: "******"eID: " + v.eID)
userAddr = str("IP: " + v.addr[0]) + ":" + str(v.addr[1])
userData.append(userAddr)
if v.channel == None:
userData.append("No channel")
else:
userData.append("Channel: " + v.channel)
server.cursor.execute(
"SELECT roles FROM userRoles WHERE eID=?", [v.eID])
try:
userRoles = (list(server.cursor.fetchall()))[0][0]
userRoles = ast.literal_eval(userRoles)
except IndexError:
return False
for role in userRoles:
userData.append("Role: " + role)
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(currentUser.conn,
currentUser.secret,
"commandData",
json.dumps(userData),
subtype="multiLine",
metadata=metadata)
return True
return False
except IndexError:
return False
def parse(conn, addr, currentUser, server, data):
splitCommand = data["data"].split()
if server.IsValidCommand(splitCommand[0][1:]):
if server.CanUseCommand(currentUser, splitCommand[0][1:]):
logger.info("Client " + str(currentUser.addr) + " ran command " +
splitCommand[0][1:])
#exec("from modules.commands.{0} import handle as {1}Handle".format(splitCommand[0][1:],splitCommand[0][1:]))
#exec("{0}Handle(conn, addr, currentUser, server, splitCommand)".format(splitCommand[0][1:]))
result = importedCommands[splitCommand[0][1:]](conn, addr,
currentUser, server,
splitCommand)
if result == None:
result = True
if config.GetSetting("storeCommandlogs", "Logging") == "True":
if config.GetSetting("logFailedCommands",
"Logging") == "False" and result == False:
pass
else:
try:
userObj = server.GetUserFromName(splitCommand[1])
except IndexError:
userObj = None
if splitCommand[0][1:] == "pm":
dbLogger.logCommand(server, currentUser, userObj,
" ".join(splitCommand[:2]), result)
else:
dbLogger.logCommand(server, currentUser, userObj,
data["data"], result)
else:
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(currentUser.conn,
currentUser.secret,
"outboundMessage",
"You do not have permission to perform this command",
metadata=metadata)
else:
pass
def handle(conn, addr, currentUser, server, command):
try:
roleList = {}
with open(r"configs/roles.json", "r") as roleFile:
roleList = json.load(roleFile)
userData = []
for k, v in roleList.items():
userData.append(k + ": " + str(v))
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(currentUser.conn,
currentUser.secret,
"commandData",
json.dumps(userData),
subtype="multiLine",
metadata=metadata)
return True
except IndexError:
return False
def handle(conn, addr, currentUser, server, data):
if data["data"] in server.channels:
currentUser.timesRequestedHistory = 1
if currentUser.channel == None:
firstJoin = True
else:
firstJoin = False
oldChannel = currentUser.channel
currentUser.channel = data["data"]
server.channels[data["data"]].append(currentUser.eID)
# Update users in old channel (if exists)
if firstJoin == False:
server.channels[oldChannel].remove(currentUser.eID)
channelUsers = json.dumps(server.GetChannelUsers(oldChannel))
for eID in server.channels[oldChannel]:
sendMessage(server.users[eID].conn, server.users[eID].secret,
"channelUpdate", channelUsers)
# Update users in the new channel
channelUsers = json.dumps(server.GetChannelUsers(data["data"]))
for eID in server.channels[data["data"]]:
sendMessage(server.users[eID].conn, server.users[eID].secret,
"channelUpdate", channelUsers)
# Send message history
channelHistory = server.GetBasicChannelHistory(currentUser.channel, 50)
sendMessage(currentUser.conn, currentUser.secret, "channelHistory",
json.dumps(channelHistory))
else:
sendMessage(conn, currentUser.secret, "errorOccured", "invalidChannel")
def handle(conn, addr, currentUser, server, command):
try:
target = command[1]
if target == currentUser.username:
return False
else:
unmuteReason = " ".join(command[2:])
for k, v in server.users.items():
if target == v.username:
if server.IsValidCommandTarget(currentUser, v):
v.isMuted = False
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(v.conn,
v.secret,
"outboundMessage",
"You have been unmuted",
metadata=metadata)
sendMessage(currentUser.conn,
currentUser.secret,
"outboundMessage",
"User " + v.username + " was unmuted",
metadata=metadata)
logger.info("Client " + str(v.addr) + " was muted")
return True
else:
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(
currentUser.conn,
currentUser.secret,
"outboundMessage",
"You cannot execute this command on that user",
metadata=metadata)
return False
return False
except IndexError:
return False
def handle(conn, addr, currentUser, server, data):
if data["data"][0] == "/": # Command
commandParser.parse(conn, addr, currentUser, server, data)
elif currentUser.channel == None:
pass
elif currentUser.isMuted == True:
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = ["Server", "#0000FF", dt]
sendMessage(currentUser.conn,
currentUser.secret,
"outboundMessage",
"You are muted",
metadata=metadata)
else: # Message
if server.CheckBlacklist(data["data"]):
mChannel = currentUser.channel
channelUsers = server.channels[mChannel]
colour = ColorHash(currentUser.username)
currentDT = datetime.datetime.now()
dt = str(currentDT.strftime("%d-%m-%Y %H:%M:%S"))
metadata = [currentUser.username, colour.hex, dt]
for eID in channelUsers:
sendMessage(server.users[eID].conn,
server.users[eID].secret,
"outboundMessage",
data["data"],
metadata=metadata)
dbLogger.logChatHistory(server, currentUser, data["data"],
colour.hex)
if config.GetSetting("storeChatlogs", "Logging") == "True":
dbLogger.logMessage(server, currentUser, data["data"])
else:
if config.GetSetting("kickOnUse", "Blacklist") == "True":
sendMessage(currentUser.conn,
currentUser.secret,
"connectionTerminated",
config.GetSetting("kickReason", "Blacklist"),
subtype="kick")
del server.users[currentUser.eID]
if currentUser.channel != None:
server.channels[currentUser.channel].remove(
currentUser.eID)
channelUsers = json.dumps(
server.GetChannelUsers(currentUser.channel))
for eID in server.channels[currentUser.channel]:
sendMessage(server.users[eID].conn,
server.users[eID].secret, "channelUpdate",
channelUsers)
currentUser.connectionValid = False
currentUser.conn.close()
logger.info("Client " + str(v.addr) +
" was kicked from the server")
else:
server.ServerMessage(
currentUser,
"You used a word on the blacklist and your message was not sent."
)
def ClientConnectionThread(conn, addr):
try:
logger.info("Client connected from " + str(addr))
byteData = conn.recv(1024) # Receive serverInfoRequest
data = encoding.DecodePlain(byteData)
sendMessage(conn, "", "serverInfo", server.RSAPublicToSend, enc=False)
byteData = conn.recv(1024) # Receive clientSecret
data = encoding.DecodePlain(byteData)
userSecret = server.RSAPrivate.decrypt(base64.b64decode(data["data"]))
sendMessage(conn, userSecret, "gotSecret", "")
byteData = conn.recv(1024) # Receive connectionRequest
data = encoding.DecodeEncrypted(byteData, userSecret)
connectionRequest = json.loads(data["data"])
currentUser = user.User(data["userid"], connectionRequest[0], userSecret, addr, conn)
currentUser.connectionValid = True
isServerFull = server.IsServerFull()
if isServerFull:
connInvalidReason = "Server is full"
currentUser.connectionValid = False
logger.warning("Client " + str(addr) + " tried to join but the server was full")
validPassword = server.Authenticate(connectionRequest[1]);
if validPassword == False:
connInvalidReason = "Incorrect Password"
currentUser.connectionValid = False
logger.warning("Client " + str(addr) + " used incorrect password")
isNotBanned = server.IsNotBanned(currentUser)
if isNotBanned == False:
connInvalidReason = "You are banned from this server"
currentUser.connectionValid = False
logger.warning("Client " + str(addr) + " tried to join but was banned")
validID = server.ValidID(currentUser)
if validID == False:
connInvalidReason = "Invalid eID"
currentUser.connectionValid = False
logger.warning("Client " + str(addr) + " tried to join but was already connected from the same device")
if connectionRequest[2] not in server.compatibleClientVers:
connInvalidReason = "Incompatible Client version"
currentUser.connectionValid = False
logger.warning("Client " + str(addr) + " tried to join but was has an incompatible client version")
validUsername = server.ValidUsername(currentUser)
currentUser.username = validUsername
except ConnectionResetError:
logger.error("Client " + str(addr) + " disconnected during handshake")
if currentUser.connectionValid == True:
try:
sendMessage(conn, userSecret, "CRAccepted", "")
server.AddUser(currentUser)
sendMessage(conn, userSecret, "serverData", server.packagedData)
logger.info("Client " + str(addr) + " completed handshake")
while currentUser.connectionValid:
byteData = conn.recv(1024)
data = encoding.DecodeEncrypted(byteData, currentUser.secret)
logger.info("Received messagetype " + data["messagetype"] + " from client " + str(addr))
if data["messagetype"] == "disconnect":
disconnect.handle(conn, addr, currentUser, server, data)
break
elif data["messagetype"] == "userMessage":
userMessage.handle(conn, addr, currentUser, server, data)
elif data["messagetype"] == "changeChannel":
changeChannel.handle(conn, addr, currentUser, server, data)
elif data["messagetype"] == "historyRequest":
historyRequest.handle(conn, addr, currentUser, server, data)
elif data["messagetype"] == "leaveChannel":
leaveChannel.handle(conn, addr, currentUser, server, data)
except json.decoder.JSONDecodeError:
logger.error("Received illegal disconnect from client " + str(addr))
disconnect.handle(conn, addr, currentUser, server, data)
currentUser.connectionValid = False
except ConnectionResetError:
logger.error("Received illegal disconnect from client " + str(addr))
disconnect.handle(conn, addr, currentUser, server, data)
currentUser.connectionValid = False
except ConnectionAbortedError as e:
if currentUser.connectionValid == False:
pass
else:
logger.error(e)
else:
logger.warning("Client " + str(addr) + " failed handshake");
sendMessage(conn, userSecret, "CRDenied", connInvalidReason)
conn.close()
conn.close()