def importScripts(self): self.decEncHelper = DecodingEncodingHelper() self.channelManager = ChannelManager() self.clientManager = ClientManager() self.inputHandler = InputHandler(self.upTime) self.fileHelper = FileHelper() self.logHelper = LogHelper()
def importScripts(self):
self.decEncHelper = DecodingEncodingHelper()
self.channelManager = ChannelManager()
self.clientManager = ClientManager()
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
self.mysqlHelper = MysqlHelper()
def __init__(self):
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
config = self.fileHelper.getConfig("Mysql Server Config")
try:
self.connection = mysql.connector.connect(user=config.username,
password=config.password,
host=config.ip,
database=config.database)
except:
print("Couldn't establish connection to mysql database(" +
config.database + ") with ip: " +
config.ip) #TODO: find a way to handle with this
def __init__(self, announce):
self.mysqlMode = 0 # 0 = Mysql; 1 = MysqlLite
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
config = self.fileHelper.getConfig("Mysql Server Config")
try:
self.connection = mysql.connector.connect(user=config.username,
password=config.password,
host=config.ip,
database=config.database)
except:
self.mysqlMode = 1
if (announce):
print(
"[" + datetime.datetime.now().strftime("%H:%M:%S") +
" ERROR]: Couldn't establish connection to mysql database("
+ config.database + ") with ip: " + config.ip)
print("[" + datetime.datetime.now().strftime("%H:%M:%S") +
" INFO]: Falling back to MysqlLite.")
#sqllite
self.conn = self.create_connection("data/database.db")
checkForAccountsTable = "SELECT * FROM accounts"
result = self.executeCommandOnLite(self.conn,
checkForAccountsTable)
try:
for row in result:
if row[0] == 1:
result = True
else:
result = False
except:
result = False
if result == False:
createTableStatement = "CREATE TABLE accounts (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, username TEXT NOT NULL, password TEXT NOT NULL, email TEXT NOT NULL, rank TEXT NOT NULL, loggedIn TINYINT NOT NULL DEFAULT '0');"
print("[" + datetime.datetime.now().strftime("%H:%M:%S") +
" INFO]: Created accounts table in MysqlLite database.")
self.executeCommandOnLite(self.conn, createTableStatement)
class InputHandler:
commandList = list()
def importScripts(self):
self.decEncHelper = DecodingEncodingHelper()
self.channelManager = ChannelManager()
self.clientManager = ClientManager()
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
self.mysqlHelper = MysqlHelper()
def createCommand(self, name, syntax, arguments, description):
command = Command(name, syntax, arguments, description)
self.commandList.append(command)
return command
def initializeCommands(self):
self.cmdListClients = self.createCommand(
"listClients", "/listClients", "NONE",
"Lists all connected clients with their name, ip and channel their in."
)
self.cmdClear = self.createCommand("Clear", "/clear", "NONE",
"Clears your interpreter console.")
self.cmdHelp = self.createCommand(
"Help", "/help", "NONE", "Shows a list of available commands.")
self.cmdKick = self.createCommand(
"Kick", "/kick <name/ip>", "<NAME/IP>",
"Kicks the given IP from the server.")
self.cmdBan = self.createCommand(
"Ban", "/ban <name/ip> <time>", "<NAME/IP> <TIME>",
"Bans the specified client for the given amount of time in minutes."
)
self.cmdMonitorMode = self.createCommand("monitorMode", "/monitorMode",
"NONE",
"Switches to monitor mode.")
self.cmdChangeRank = self.createCommand(
"changeRank", "/changeRank <name/ip> <rank>", "<NAME/IP> <RANK>",
"Changes the rank of the given client.")
self.cmdListChannel = self.createCommand(
"listChannel", "/listChannel", "NONE",
"Lists all channels with their belonging clients.")
self.cmdCreateChannel = self.createCommand(
"createChannel",
"/createChannel <name> <description> <password> <accessLevel>",
"<NAME/DESCRIPTION/PASSWORD/ACCESSLEVEL>",
"Creates a temporary Channel.")
self.cmdRemoveChannel = self.createCommand(
"removeChannel", "/removeChannel <name>", "<NAME>",
"Removes the give Channel.")
def __init__(self, upTime):
self.upTime = upTime
#Imports
self.importScripts()
#Create Commands
self.initializeCommands()
def handleInput(self, command):
command = command.split()
if command[0] == self.cmdClear.name:
os.system('cls' if os.name == 'nt' else 'clear')
elif command[0] == self.cmdListClients.name:
if len(self.clientManager.clientList) < 1:
self.logHelper.log("error", "No clients connected")
else:
self.logHelper.log("error", "Connected clients:")
for clientObject in self.clientManager.clientList:
self.logHelper.log(
"info", clientObject.ip + " with name " +
clientObject.username + " in " +
clientObject.channelObject.name)
elif command[0] == self.cmdHelp.name:
self.logHelper.log("info", "Commands:")
self.logHelper.log(
"info",
"----------------------------------------------------------")
for command in self.commandList:
self.logHelper.log(
"info", command.syntax + " : " + command.description)
self.logHelper.log(
"info",
"----------------------------------------------------------")
elif command[0] == self.cmdKick.name:
if len(self.clientManager.clientList) < 1:
self.logHelper.log("error", "No clients connected")
else:
client = None
try:
client = command[1]
except IndexError:
self.logHelper.log("error",
"Syntax: " + self.cmdKick.syntax)
if client != None:
if self.clientManager.ipExists(client):
for clientObject in self.clientManager.clientList:
if clientObject.ip == client:
self.logHelper.log(
"info", clientObject.ip + " : " +
clientObject.username + " got kicked")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes("402"))
clientObject.socketObject.close()
elif self.clientManager.usernameExists(client):
for clientObject in self.clientManager.clientList:
if clientObject.username.lower() == client:
self.logHelper.log(
"info", clientObject.ip + " : " +
clientObject.username + " got kicked")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes("402"))
clientObject.socketObject.close()
else:
self.logHelper.log(
"error", "Your given Ip/Name doesn't exist.")
elif command[0] == self.cmdBan.name:
if len(self.clientManager.clientList) < 1:
self.logHelper.log("error", "No clients connected")
else:
client = None
banTime = None
try:
client = command[1]
banTime = int(command[2])
except IndexError:
if client or banTime == None:
self.logHelper.log("error",
"Syntax: " + self.cmdBan.syntax)
if client != None:
if self.clientManager.ipExists(client):
for clientObject in self.clientManager.clientList:
if clientObject.ip == client:
if banTime != None:
if banTime == 0:
self.fileHelper.addClientToBanList(
clientObject.ip)
self.logHelper.log(
"info", clientObject.ip + " : " +
clientObject.username +
" got permanantly banned")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405" +
"You got permanantly banned by the console"
))
clientObject.socketObject.close()
else:
currentTimeStamp = datetime.datetime.now(
).timestamp()
self.fileHelper.addClientToBanList(
clientObject.ip + ":" +
str(currentTimeStamp +
int(banTime) * 60))
self.logHelper.log(
"info", clientObject.ip + " : " +
clientObject.username +
" got banned for " + str(banTime) +
"minutes")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405" + "You got banned for " +
str(banTime) +
" minutes by the console"))
clientObject.socketObject.close()
else:
self.fileHelper.addClientToBanList(
clientObject.ip)
self.logHelper.log(
"info", clientObject.ip + " : " +
clientObject.username +
" got permanantly banned")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405" +
"You got permanantly banned by the console"
))
clientObject.socketObject.close()
elif self.clientManager.usernameExists(client):
for clientObject in self.clientManager.clientList:
if clientObject.username.lower() == client:
if banTime != None:
if banTime == 0:
self.fileHelper.addClientToBanList(
clientObject.ip)
self.logHelper.log(
"info", clientObject.ip + " : " +
clientObject.username +
" got permanantly banned")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405" +
"You got permanantly banned by the console"
))
clientObject.socketObject.close()
else:
currentTimeStamp = datetime.datetime.now(
).timestamp()
self.fileHelper.addClientToBanList(
clientObject.ip + ":" +
str(currentTimeStamp +
int(banTime) * 60))
self.logHelper.log(
"info", clientObject.ip + " : " +
clientObject.username +
" got banned for " + str(banTime) +
"minutes")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405" + "You got banned for " +
str(banTime) +
" minutes by the console"))
clientObject.socketObject.close()
else:
self.fileHelper.addClientToBanList(
clientObject.ip)
self.logHelper.log(
"info", clientObject.ip + " : " +
clientObject.username +
" got permanantly banned")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405" +
"You got permanantly banned by the console"
))
clientObject.socketObject.close()
else:
print(
"[Server/Error] Your given Ip/Name doesn't exist.")
elif command[0] == self.cmdListChannel.name:
self.logHelper.log("info", "Channels:")
self.logHelper.log(
"info",
"----------------------------------------------------------")
for channel in self.channelManager.channelList:
self.logHelper.log(
"info", "-" + channel.name + " : Description:" +
channel.description)
self.logHelper.log("info", " Clients:")
if len(channel.clientList) < 1:
self.logHelper.log("info", " -channel is empty")
else:
for client in channel.clientList:
self.logHelper.log(
"info", " -" + client.ip + " : " + client.username)
self.logHelper.log(
"info",
"----------------------------------------------------------")
elif command[
0] == self.cmdCreateChannel.name: #TODO: add things to remove user error when acces level isnst int and description contains spaces
name = None
description = None
password = None
accessLevel = None
try:
name = command[1]
description = command[2]
password = command[3]
accessLevel = int(command[4])
self.channelManager.addChannel(
Channel(name, description, password, accessLevel, list()))
self.logHelper.log("info", "Channel " + name + " created.")
except:
if name or description or password or accessLevel == None:
self.logHelper.log(
"error", "Syntax: " + self.cmdCreateChannel.syntax)
elif command[0] == self.cmdRemoveChannel.name:
name = None
try:
name = command[1]
for channel in self.channelManager.channelList:
if channel.name == name:
self.channelManager.removeChannel(channel)
self.logHelper.log("info", "Channel " + name + " was removed.")
except:
if name == None:
self.logHelper.log(
"error", "Syntax: " + self.cmdRemoveChannel.syntax)
elif command[
0] == self.cmdChangeRank.name: #TODO: add things to remove user error for rank and check if rank isnt even a rank
if len(self.clientManager.clientList) < 1:
self.logHelper.log("error", "No clients connected")
else:
client = None
rank = None
try:
client = command[1]
rank = command[2]
except IndexError:
self.logHelper.log("error",
"Syntax: " + self.cmdChangeRank.syntax)
if client != None:
if rank != None:
if self.clientManager.ipExists(client):
for clientObject in self.clientManager.clientList:
if clientObject.ip == client:
prevRank = clientObject.rank
clientObject.rank = rank
self.mysqlHelper.updateAccountRank(
clientObject)
self.logHelper.log(
"info", "Changed " + clientObject.ip +
":" + str(clientObject.port) + " " +
clientObject.username +
" 's rank from " + prevRank + " to " +
rank)
elif self.clientManager.usernameExists(client):
for clientObject in self.clientManager.clientList:
if clientObject.username.lower() == client:
prevRank = clientObject.rank
clientObject.rank = rank
self.mysqlHelper.updateAccountRank(
clientObject)
#clientObject.sendall(self.decEncHelper.stringToBytes("904" + rank))TODO:
self.logHelper.log(
"info", "Changed " + clientObject.ip +
":" + str(clientObject.port) + " " +
clientObject.username +
" 's rank from " + prevRank + " to " +
rank)
else:
self.logHelper.log(
"error", "Your given Ip/Name doesn't exist.")
elif command[0] == self.cmdMonitorMode.name:
monitor = True
config = self.fileHelper.getConfig("Server Config")
ip = config.ip + ":" + str(config.port)
if len(ip) != 20:
ip = " " * (20 - len(ip)) + ip
while monitor:
clearCount = 0
connectedClients = str(len(self.clientManager.clientList))
connectedAdmins = str(len(self.clientManager.getAdmins()))
if len(connectedClients) != 3:
connectedClients = "0" * (
3 - len(connectedClients)) + connectedClients
if len(connectedAdmins) != 3:
connectedAdmins = "0" * (
3 - len(connectedAdmins)) + connectedAdmins
os.system('cls' if os.name == 'nt' else 'clear')
try:
print(
"##############Monitoring##############\n#Server Ip/Port: "
+ ip + "#\n#Uptime: " +
time.strftime(
'%H:%M:%S',
time.gmtime(int(time.time() - self.upTime))) +
"#\n#Connected Clients: " +
connectedClients +
"#\n#Connected Admins: " +
connectedAdmins +
"#\n##############Monitoring##############")
while clearCount != 5:
sys.stdout.write("\x1b[1A")
sys.stdout.write("\x1b[2K")
clearCount = clearCount + 1
time.sleep(0.5)
except KeyboardInterrupt:
monitor = False
os.system('cls' if os.name == 'nt' else 'clear')
self.logHelper.log("info", "Exited monitor mode.")
else:
self.logHelper.log("error", "Unknown command: " + command[0])
self.logHelper.log("error", "type /help for a list of commands")
def handle(
self
): #overwrite TODO: find a way to import script only once not once per handle call
self.decEncHelper = DecodingEncodingHelper()
self.channelManager = ChannelManager()
self.clientManager = ClientManager()
self.mysqlHelper = MysqlHelper()
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
if self.appendClient:
self.clientObject = Client(self.request, "*NOT_ASSIGNED*",
"*NOT_ASSIGNED*", "*NOT_ASSIGNED*")
if len(self.fileHelper.readTXTFile("data/", "banList")) > 1:
for client in self.fileHelper.readTXTFile("data/", "banList"):
try:
banTime = client.split(":")[1]
except IndexError:
pass
if self.clientObject.ip + "\n" == client:
self.logHelper.log(
"info", self.clientObject.ip + ":" +
str(self.clientObject.port) +
" is permanantly banned on the server")
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405[Client/Info] You are permanantly banned on this server"
))
self.clientObject.socketObject.close()
self.appendClient = False
elif self.clientObject.ip + ":" + banTime == client:
currentTimeStamp = datetime.datetime.now().timestamp()
banTime = banTime[:-1]
if (currentTimeStamp > float(banTime)):
self.fileHelper.removeClientFromBanList(
self.clientObject.ip)
self.clientManager.addClient(self.clientObject)
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" +
str(self.clientObject.port) +
" connected to the server")
print(
self.mysqlHelper.getAccountRank(
self.clientObject))
if len(
self.mysqlHelper.getAccountRank(
self.clientObject)) < 3:
self.clientObject.rank = "user"
self.mysqlHelper.updateAccountRank(
self.clientObject)
self.appendClient = False
self.tryRecv = True
else:
self.logHelper.log(
"info", self.clientObject.ip + ":" +
str(self.clientObject.port) +
" is temporary banned on the server. Remaining Time: "
+ str(
int((float(banTime) - currentTimeStamp) /
60)) + "Minutes")
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405[Client/Info] You are temporary banned on this server. Remaining Time: "
+ str(
int((float(banTime) -
currentTimeStamp) / 60)) +
" Minutes"))
self.channelManager.removeChannelMember(
self.clientObject.channelObject,
self.clientObject)
self.clientObject.socketObject.close()
self.appendClient = False
break
elif "BanList:\n" == client:
pass
else:
self.clientManager.addClient(self.clientObject)
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" +
str(self.clientObject.port) +
" connected to the server.")
self.appendClient = False
self.tryRecv = True
else:
self.clientManager.addClient(self.clientObject)
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" +
str(self.clientObject.port) + " connected to the server.")
self.appendClient = False
self.tryRecv = True
if self.tryRecv:
try:
self.data = self.decEncHelper.bytesToString(
self.clientObject.socketObject.recv(1024))
self.handleRequest(self.data, self.clientObject)
except:
for clientObjectInList in self.clientManager.clientList:
if clientObjectInList != self.clientObject:
if self.loggedIn:
if self.channelManager.channelContains(
clientObjectInList,
self.clientObject.channelObject.name):
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"811[Client/Info] " +
self.clientObject.username + " quit."))
self.logHelper.log(
"info", self.clientObject.ip + ":" +
str(self.clientObject.port) + " Disconnected")
self.mysqlHelper.logoutAccount(self.clientObject)
self.clientManager.removeClient(self.clientObject)
if self.loggedIn:
self.channelManager.removeChannelMember(
self.clientObject.channelObject, self.clientObject)
class ClientHandler(socketserver.BaseRequestHandler):
appendClient = True
tryRecv = False
loggedIn = False
def handle(
self
): #overwrite TODO: find a way to import script only once not once per handle call
self.decEncHelper = DecodingEncodingHelper()
self.channelManager = ChannelManager()
self.clientManager = ClientManager()
self.mysqlHelper = MysqlHelper()
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
if self.appendClient:
self.clientObject = Client(self.request, "*NOT_ASSIGNED*",
"*NOT_ASSIGNED*", "*NOT_ASSIGNED*")
if len(self.fileHelper.readTXTFile("data/", "banList")) > 1:
for client in self.fileHelper.readTXTFile("data/", "banList"):
try:
banTime = client.split(":")[1]
except IndexError:
pass
if self.clientObject.ip + "\n" == client:
self.logHelper.log(
"info", self.clientObject.ip + ":" +
str(self.clientObject.port) +
" is permanantly banned on the server")
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405[Client/Info] You are permanantly banned on this server"
))
self.clientObject.socketObject.close()
self.appendClient = False
elif self.clientObject.ip + ":" + banTime == client:
currentTimeStamp = datetime.datetime.now().timestamp()
banTime = banTime[:-1]
if (currentTimeStamp > float(banTime)):
self.fileHelper.removeClientFromBanList(
self.clientObject.ip)
self.clientManager.addClient(self.clientObject)
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" +
str(self.clientObject.port) +
" connected to the server")
print(
self.mysqlHelper.getAccountRank(
self.clientObject))
if len(
self.mysqlHelper.getAccountRank(
self.clientObject)) < 3:
self.clientObject.rank = "user"
self.mysqlHelper.updateAccountRank(
self.clientObject)
self.appendClient = False
self.tryRecv = True
else:
self.logHelper.log(
"info", self.clientObject.ip + ":" +
str(self.clientObject.port) +
" is temporary banned on the server. Remaining Time: "
+ str(
int((float(banTime) - currentTimeStamp) /
60)) + "Minutes")
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"405[Client/Info] You are temporary banned on this server. Remaining Time: "
+ str(
int((float(banTime) -
currentTimeStamp) / 60)) +
" Minutes"))
self.channelManager.removeChannelMember(
self.clientObject.channelObject,
self.clientObject)
self.clientObject.socketObject.close()
self.appendClient = False
break
elif "BanList:\n" == client:
pass
else:
self.clientManager.addClient(self.clientObject)
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" +
str(self.clientObject.port) +
" connected to the server.")
self.appendClient = False
self.tryRecv = True
else:
self.clientManager.addClient(self.clientObject)
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" +
str(self.clientObject.port) + " connected to the server.")
self.appendClient = False
self.tryRecv = True
if self.tryRecv:
try:
self.data = self.decEncHelper.bytesToString(
self.clientObject.socketObject.recv(1024))
self.handleRequest(self.data, self.clientObject)
except:
for clientObjectInList in self.clientManager.clientList:
if clientObjectInList != self.clientObject:
if self.loggedIn:
if self.channelManager.channelContains(
clientObjectInList,
self.clientObject.channelObject.name):
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"811[Client/Info] " +
self.clientObject.username + " quit."))
self.logHelper.log(
"info", self.clientObject.ip + ":" +
str(self.clientObject.port) + " Disconnected")
self.mysqlHelper.logoutAccount(self.clientObject)
self.clientManager.removeClient(self.clientObject)
if self.loggedIn:
self.channelManager.removeChannelMember(
self.clientObject.channelObject, self.clientObject)
def handleRequest(self, request, clientObject):
requestId = request[:3]
requestdata = request[3:]
if requestId == "001": #chatting
self.logHelper.channelLog(
"info", clientObject.channelObject.name, clientObject.ip +
":" + str(clientObject.port) + " [" + clientObject.rank + "]" +
clientObject.username + " : " + requestdata)
for clientObjectFromList in self.clientManager.clientList:
if clientObjectFromList.channelObject.name == clientObject.channelObject.name:
if clientObjectFromList != clientObject:
clientObjectFromList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"001[" + clientObject.rank + "]" +
clientObject.username + " : " + requestdata))
elif requestId == "011": #try logging in
requestdata = requestdata.split(":")
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" + str(self.clientObject.port) +
" tried logging in.")
self.clientManager.updateClientUsername(clientObject,
requestdata[0])
if self.mysqlHelper.tryLogin(clientObject, requestdata[1]):
self.loggedIn = True
self.clientObject.channelObject = self.channelManager.channelList[
0]
self.clientObject.channelObject.clientList.append(
self.clientObject)
self.clientManager.updateClientRank(
clientObject,
self.mysqlHelper.getAccountRank(clientObject))
for clientObjectInList in self.clientManager.clientList:
if clientObjectInList != clientObject:
if self.channelManager.channelContains(
clientObjectInList, "Welcome_Channel"):
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"811[" + clientObject.rank + "]" +
clientObject.username + " joined."))
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" +
str(self.clientObject.port) + " logged in as " +
clientObject.username + " succesfully.")
if len(self.mysqlHelper.getAccountRank(self.clientObject)) < 3:
self.clientObject.rank = "user"
self.mysqlHelper.updateAccountRank(self.clientObject)
for clientObjectInList in self.clientManager.clientList:
if clientObjectInList != clientObject:
if self.channelManager.channelContains(
clientObjectInList, "Welcome_Channel"):
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"811[" + clientObject.rank + "]" +
clientObject.username + " joined."))
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes("903"))
else:
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" +
str(self.clientObject.port) + " couldn't log in.")
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes("902"))
self.clientObject.socketObject.close()
elif requestId == "611": #sent current clients in given channel
self.logHelper.log(
"info",
str(self.clientObject.ip) + ":" + str(self.clientObject.port) +
" " + clientObject.username +
" requested the clients from channel " + requestdata + ".")
for channel in self.channelManager.channelList:
if channel.name == requestdata:
if len(channel.clientList) < 1:
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes("611Empty"))
else:
clientsInChannel = list()
for client in channel.clientList:
clientsInChannel.append(client.username)
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"611" + requestdata + ";" +
str(clientsInChannel)))
break
elif requestId == "541": #sent client rank
self.logHelper.log(
"info", clientObject.ip + " " + clientObject.username +
" requested rank.")
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes("541" +
str(self.clientObject.rank)))
elif requestId == "022": #channel request
self.logHelper.log(
"info", clientObject.ip + " " + clientObject.username +
" requested channel.")
channelNames = list()
channelDescriptions = list()
channelPasswords = list()
channelAccessLevels = list()
for channelObject in self.channelManager.channelList:
channelNames.append(channelObject.name)
channelDescriptions.append(channelObject.description)
channelPasswords.append(channelObject.password)
channelAccessLevels.append(channelObject.accessLevel)
self.clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes("022" + str(channelNames) +
":" +
str(channelDescriptions) +
":" + str(channelPasswords) +
":" +
str(channelAccessLevels)))
elif requestId == "023": #changing channels
if self.channelManager.channelExists(requestdata):
if self.channelManager.channelContains(self.clientObject,
requestdata):
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"023[Client/Info] you are already in this channel."
))
self.logHelper.log(
"info", clientObject.ip + ":" +
str(clientObject.port) + " " + clientObject.username +
" tried to join a channel which he is already part of."
)
else:
for channelObject in self.channelManager.channelList:
if channelObject.name == requestdata:
oldChannel = clientObject.channelObject.name
self.channelManager.removeChannelMember(
clientObject.channelObject, clientObject)
clientObject.channelObject = channelObject
self.channelManager.addChannelMember(
channelObject, clientObject)
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"023[Client/Info] You succesfully changed to "
+ requestdata + "."))
self.logHelper.log(
"info", clientObject.ip + ":" +
str(clientObject.port) + " " +
clientObject.username + " changed from " +
oldChannel + " to " + requestdata + ".")
for clientInList in self.clientManager.clientList:
clientInList.socketObject.sendall(
self.decEncHelper.stringToBytes("811"))
else:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"023[Client/Info] This Channel doesn't exists."))
self.logHelper.log(
"info", clientObject.ip + " : " + clientObject.username +
" tried to join a channel that doesn't exists.")
elif requestId == "031": #changing namesFIXME: doesnt work with rank not tested witohut
if self.clientManager.hasRank(clientObject, "admin"):
self.fileHelper.removeClientRank(clientObject)
clientObject.username = requestdata
self.fileHelper.addClientRank(clientObject, "admin")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"031[Client/Info] you succesfully changed your name."))
self.logHelper.log(
"info", clientObject.ip + ":" + str(clientObject.port) +
" " + clientObject.username + " changed name.")
else:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"031[Client/Info] You don't have access to that command."
))
self.logHelper.log(
"info", clientObject.ip + ":" + str(clientObject.port) +
" " + clientObject.username +
" had no access to that command. Rank:(" +
clientObject.rank.strip("\n") + ")")
elif requestId == "411": #kicking clients
if self.clientManager.hasRank(clientObject, "admin"):
if self.clientManager.usernameExists(requestdata):
if requestdata == self.clientObject.username:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"411[Client/Info] You can't kick yourself."))
else:
for clientObjectInList in self.clientManager.clientList:
if clientObjectInList.username == requestdata:
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"402[Client/Info] You got kicked by: "
+ self.clientObject.username))
clientObjectInList.socketObject.close()
time.sleep(0.1)
self.logHelper.log(
"info", clientObject.ip + ":" +
str(clientObject.port) + " " +
clientObject.username + " kicked : " +
requestdata)
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"411[Client/Info] You sucessfully kicked: "
+ requestdata))
break
elif self.clientManager.ipExists(requestdata):
if requestdata == self.clientObject.ip:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"411[Client/Info] You can't kick yourself."))
else:
for clientObjectInList in self.clientManager.clientList:
if clientObjectInList.ip == requestdata:
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"402[Client/Info] You got kicked by: "
+ self.clientObject.username))
clientObjectInList.socketObject.close()
self.logHelper.log(
"info", clientObject.ip + ":" +
str(clientObject.port) + " " +
clientObject.username + " kicked : " +
requestdata)
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"411[Client/Info] You sucessfully kicked: "
+ requestdata))
break
else:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"411[Client/Info] Username or ip doesnt exists on the server."
))
else:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"031[Client/Info] You don't have access to that command."
))
self.logHelper.log(
"info", clientObject.ip + ":" + str(clientObject.port) +
" " + clientObject.username +
" had no access to that command. Rank:(" +
clientObject.rank.strip("\n") + ")")
elif requestId == "711": #banning clients
if self.clientManager.hasRank(clientObject, "admin"):
requestdata = requestdata.split()
client = requestdata[0]
banTime = requestdata[1]
if self.clientManager.usernameExists(client):
if client == self.clientObject.username:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711[Client/Info] You can't ban yourself."))
else:
for clientObjectInList in self.clientManager.clientList:
if clientObjectInList.username == client:
if banTime == 0:
self.fileHelper.addClientToBanList(
clientObjectInList.ip)
self.logHelper.log(
"info", clientObjectInList.ip + ":" +
str(clientObjectInList.port) + " " +
clientObjectInList.username +
" got permanantly banned by " +
clientObject.username)
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711" +
"[Client/Info] You got permanantly banned by "
+ clientObject.username))
clientObjectInList.socketObject.close()
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711[Client/Info] You sucessfully banned: "
+ clientObjectInList.username))
else:
currentTimeStamp = datetime.datetime.now(
).timestamp()
self.fileHelper.addClientToBanList(
clientObjectInList.ip + ":" +
str(currentTimeStamp +
int(banTime) * 60))
self.logHelper.log(
"info", clientObjectInList.ip + ":" +
str(clientObjectInList.port) + " " +
clientObjectInList.username +
" got banned for " + str(banTime) +
"minutes by " + clientObject.username)
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711" +
"[Client/Info] You got banned for "
+ str(banTime) + "Minutes by " +
clientObject.username))
clientObjectInList.socketObject.close()
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711[Client/Info] You sucessfully banned: "
+ clientObjectInList.username +
" for " + str(banTime)))
elif self.clientManager.ipExists(client):
if client == self.clientObject.ip:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711[Client/Info] You can't ban yourself."))
else:
for clientObjectInList in self.clientManager.clientList:
if clientObjectInList.ip == client:
if banTime == 0:
self.fileHelper.addClientToBanList(
clientObjectInList.ip)
self.logHelper.log(
"info", clientObjectInList.ip + ":" +
str(clientObjectInList.port) + " " +
clientObjectInList.username +
" got permanantly banned by " +
clientObject.username)
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711" +
"[Client/Info] You got permanantly banned by "
+ clientObject.username))
clientObjectInList.socketObject.close()
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711[Client/Info] You sucessfully banned: "
+ clientObjectInList.username))
else:
currentTimeStamp = datetime.datetime.now(
).timestamp()
self.fileHelper.addClientToBanList(
clientObjectInList.ip + ":" +
str(currentTimeStamp +
int(banTime) * 60))
self.logHelper.log(
"info", clientObjectInList.ip + ":" +
str(clientObjectInList.port) + " " +
clientObjectInList.username +
" got banned for " + str(banTime) +
"minutes by " + clientObject.username)
clientObjectInList.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711" +
"[Client/Info] You got banned for "
+ str(banTime) + "Minutes by " +
clientObject.username))
clientObjectInList.socketObject.close()
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711[Client/Info] You sucessfully banned: "
+ clientObjectInList.username +
" for " + str(banTime)))
else:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"711[Client/Info] Username or ip doesnt exists on the server."
))
else:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"031[Client/Info] You don't have access to that command."
))
self.logHelper.log(
"info", clientObject.ip + ":" + str(clientObject.port) +
" " + clientObject.username +
" had no access to that command. Rank:(" +
clientObject.rank.strip("\n") + ")")
elif requestId == "901": #GUI get all channel with clients
channelList = list()
for channel in self.channelManager.channelList:
memberList = list()
for client in channel.clientList:
if client.username == clientObject.username:
memberList.append(client.username + "(you)")
else:
memberList.append(client.username)
channelList.append(channel.name + ":" + str(memberList) + ";")
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes("901" + str(channelList)))
else: #any other requestId
if len(requestId) == 0:
raise SystemExit()
else:
clientObject.socketObject.sendall(
self.decEncHelper.stringToBytes(
"401[Client/Error] Unknown request ID"))
self.logHelper.log(
"error", clientObject.ip + ":" + str(clientObject.port) +
" sent unknown request ID")
self.handle()
class Server:
def importScripts(self):
self.decEncHelper = DecodingEncodingHelper()
self.channelManager = ChannelManager()
self.clientManager = ClientManager()
self.inputHandler = InputHandler(self.upTime)
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
def setConfig(self):
config = self.fileHelper.getConfig("Server Config")
self.port = config.port
self.ipV4 = config.ip
def inizializeChannel(self):
self.welcomeChannel = Channel("Welcome_Channel", "welcome to the server", "No", 0, list())
self.channel1 = Channel("Channel_1", "Description of channel 1", "No", 0, list())
self.channel2 = Channel("Channel_2", "Description of channel 1", "No", 0, list())
self.channel3 = Channel("Channel_3", "Description of channel 1", "No", 0, list())
self.channelManager.addChannel(self.welcomeChannel)
self.channelManager.addChannel(self.channel1)
self.channelManager.addChannel(self.channel2)
self.channelManager.addChannel(self.channel3)
def inizializeServer(self):
self.server = ServerThread((self.ipV4, self.port), ClientHandler)
serverThread = threading.Thread(target=self.server.serve_forever)
serverThread.daemon = True
serverThread.start()
self.logHelper.log("info" ,"Started server (version: " + self.fileHelper.getConfig("Version") + ") on ip: " + self.ipV4 + " port: " + str(self.port))
def askForInput(self):
while True:
try:
command = input()
except KeyboardInterrupt:
self.logHelper.log("info", "Gracefully stopping server...")
if len(self.clientManager.clientList) < 1:
self.logHelper.log("info", "Gracefully stopped server")
break
else:
for clientObject in self.clientManager.clientList:
clientObject.socketObject.sendall(self.decEncHelper.stringToBytes("403"))
self.logHelper.log("info", "Gracefully stopped server")
break
if str(command).startswith("/"):
try:
self.inputHandler.handleInput(str(command[1:]).lower())
except IndexError:
self.logHelper.log("info", "type /help for a list of commands.")
else:
self.logHelper.log("info", "Commands always start with (/)")
def __init__(self):
self.upTime = time.time()
#Imports
self.importScripts()
#Config
self.setConfig()
#Channel initialization
self.inizializeChannel()
#Server initializations
self.inizializeServer()
#Console Input
self.askForInput()
type=int,
default=5000,
help='Tx batch size')
parser.add_argument('-v',
'--verbose',
type=int,
default=2,
help='verbose level')
return parser.parse_args()
args = parse_args()
sql_handler = SQLHandler(DATABASE_PATH, debugging=(args.verbose == 3))
for n in args.n:
logger = LogHelper(log_level=args.verbose,
log_file=LOG_PATH.format(N=n))
logger.log('info', f'processing {n} gram file...')
f = open(DATA_PATH.format(N=n), 'r', encoding='utf-8')
# create tables
query = CREATE_NGRAM_TABLE.format(N=n)
logger.log('debug', f'SQL QUERY: {query}')
sql_handler.execute(query)
sql_count = 0
sql_queries = []
for line in f:
line = line.strip()
count, lexicalbundle, pos = line.split('\t')
# extract query and recommand word
class MysqlHelper:
def __init__(self):
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
config = self.fileHelper.getConfig("Mysql Server Config")
try:
self.connection = mysql.connector.connect(user=config.username,
password=config.password,
host=config.ip,
database=config.database)
except:
print("Couldn't establish connection to mysql database(" +
config.database + ") with ip: " +
config.ip) #TODO: find a way to handle with this
def ExecuteCommand(self, command):
result = None
try:
result = MysqlStatement(
command, self.connection).execute().escape().fetchall().result
except AttributeError:
self.logHelper.log("info", "Created mysql table.")
self.ExecuteCommandWithoutFetchAndResult(
"CREATE TABLE accounts ( id INT NOT NULL AUTO_INCREMENT, username TEXT NOT NULL, password TEXT NOT NULL, email TEXT NOT NULL, rank TEXT NOT NULL, loggedIn TINYINT NOT NULL DEFAULT '0', PRIMARY KEY (id))"
)
return result
def ExecuteCommandWithoutFetchAndResult(self, command):
return MysqlStatement(command,
self.connection).execute().escape().commit()
def tryLogin(self, clientObject,
password): #TODO: give better fedback for layer 8
result = False
lenght = None
try:
lenght = len(
self.ExecuteCommand(
"SELECT * FROM accounts WHERE username = '******'"))
except:
lenght = len(
self.ExecuteCommand(
"SELECT * FROM accounts WHERE username = '******'"))
if lenght > 0:
if self.ExecuteCommand(
"select loggedIn,(case when loggedIn = 0 then 'loggedOut' when loggedIn = 1 then 'loggedIn' end) as loggedIn_status FROM accounts WHERE username = '******'")[0][1] != "loggedIn":
if len(
self.ExecuteCommand(
"SELECT * FROM accounts WHERE username = '******' and password = '******'")) > 0:
self.ExecuteCommandWithoutFetchAndResult(
"UPDATE accounts SET loggedIn = 1 WHERE username = '******'")
result = True
return result
def logoutAccount(self, clientObject):
self.ExecuteCommandWithoutFetchAndResult(
"UPDATE accounts SET loggedIn = 0 WHERE username = '******'")
def getAccountRank(self, clientObject):
return self.ExecuteCommand(
"SELECT rank FROM accounts WHERE username = '******'")[0][0]
def updateAccountRank(self, clientObject):
self.ExecuteCommandWithoutFetchAndResult(
"UPDATE accounts SET rank = '" + clientObject.rank +
"' WHERE username = '******'")
class MysqlHelper:
def __init__(self, announce):
self.mysqlMode = 0 # 0 = Mysql; 1 = MysqlLite
self.fileHelper = FileHelper()
self.logHelper = LogHelper()
config = self.fileHelper.getConfig("Mysql Server Config")
try:
self.connection = mysql.connector.connect(user=config.username,
password=config.password,
host=config.ip,
database=config.database)
except:
self.mysqlMode = 1
if (announce):
print(
"[" + datetime.datetime.now().strftime("%H:%M:%S") +
" ERROR]: Couldn't establish connection to mysql database("
+ config.database + ") with ip: " + config.ip)
print("[" + datetime.datetime.now().strftime("%H:%M:%S") +
" INFO]: Falling back to MysqlLite.")
#sqllite
self.conn = self.create_connection("data/database.db")
checkForAccountsTable = "SELECT * FROM accounts"
result = self.executeCommandOnLite(self.conn,
checkForAccountsTable)
try:
for row in result:
if row[0] == 1:
result = True
else:
result = False
except:
result = False
if result == False:
createTableStatement = "CREATE TABLE accounts (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, username TEXT NOT NULL, password TEXT NOT NULL, email TEXT NOT NULL, rank TEXT NOT NULL, loggedIn TINYINT NOT NULL DEFAULT '0');"
print("[" + datetime.datetime.now().strftime("%H:%M:%S") +
" INFO]: Created accounts table in MysqlLite database.")
self.executeCommandOnLite(self.conn, createTableStatement)
def create_connection(self, db_file):
try:
conn = sqlite3.connect(db_file)
return conn
except Error as e:
print(e)
return e
def executeCommandOnLite(self, connection, command):
try:
cursor = connection.cursor()
result = cursor.execute(command)
return result
except Error as e:
return e
def ExecuteCommand(self, command):
result = None
try:
result = MysqlStatement(
command, self.connection).execute().escape().fetchall().result
except AttributeError:
self.logHelper.log("info", "Created mysql table.")
self.ExecuteCommandWithoutFetchAndResult(
"CREATE TABLE accounts ( id INT NOT NULL AUTO_INCREMENT, username TEXT NOT NULL, password TEXT NOT NULL, email TEXT NOT NULL, rank TEXT NOT NULL, loggedIn TINYINT NOT NULL DEFAULT '0', PRIMARY KEY (id))"
)
return result
def ExecuteCommandWithoutFetchAndResult(self, command):
return MysqlStatement(command,
self.connection).execute().escape().commit()
def tryLogin(self, clientObject,
password): #TODO: give better fedback for layer 8
if self.mysqlMode == 0:
result = False
lenght = None
try:
lenght = len(
self.ExecuteCommand(
"SELECT * FROM accounts WHERE username = '******'"))
except:
lenght = len(
self.ExecuteCommand(
"SELECT * FROM accounts WHERE username = '******'"))
if lenght > 0:
if self.ExecuteCommand(
"select loggedIn,(case when loggedIn = 0 then 'loggedOut' when loggedIn = 1 then 'loggedIn' end) as loggedIn_status FROM accounts WHERE username = '******'")[0][1] != "loggedIn":
if len(
self.ExecuteCommand(
"SELECT * FROM accounts WHERE username = '******' and password = '******'")) > 0:
self.ExecuteCommandWithoutFetchAndResult(
"UPDATE accounts SET loggedIn = 1 WHERE username = '******'")
result = True
return result
else:
checkLoggedIn = "select loggedIn,(case when loggedIn = 0 then 'loggedOut' when loggedIn = 1 then 'loggedIn' end) as loggedIn_status FROM accounts WHERE username = '******'"
result = self.executeCommandOnLite(self.conn, checkLoggedIn)
try:
for row in result:
if row[0] == 1:
result = True
else:
result = False
except:
result = False
if result == False:
checkPW = "SELECT * FROM accounts WHERE username = '******' and password = '******'"
result1 = self.executeCommandOnLite(self.conn, checkPW)
result5 = False
try:
for row in result1:
if (row[1] == clientObject.username):
result5 = True
else:
result5 = False
except:
result5 = False
if result5:
updateStatus = "UPDATE accounts SET loggedIn = 1 WHERE username = '******'"
self.executeCommandOnLite(self.conn, updateStatus)
return result5
def logoutAccount(self, clientObject):
if self.mysqlMode == 0:
self.ExecuteCommandWithoutFetchAndResult(
"UPDATE accounts SET loggedIn = 0 WHERE username = '******'")
else:
logoutAccount = "UPDATE accounts SET loggedIn = 0 WHERE username = '******'"
self.executeCommandOnLite(self.conn, logoutAccount)
def getAccountRank(self, clientObject):
if self.mysqlMode == 0:
result = self.ExecuteCommand(
"SELECT rank FROM accounts WHERE username = '******'")[0][0]
else:
getRank = "SELECT rank FROM accounts WHERE username = '******'"
result = self.executeCommandOnLite(self.conn, getRank)
for row in result:
print(row[0])
result = row[0]
return result
def updateAccountRank(self, clientObject):
if self.mysqlMode == 0:
self.ExecuteCommandWithoutFetchAndResult(
"UPDATE accounts SET rank = '" + clientObject.rank +
"' WHERE username = '******'")
else:
updateRank = "UPDATE accounts SET rank = '" + clientObject.rank + "' WHERE username = '******'"
self.executeCommandOnLite(self.conn, updateRank)
