489 lines
16 KiB
Kotlin
489 lines
16 KiB
Kotlin
package xyz.maxwellj.chookchat
|
|
|
|
import io.javalin.Javalin
|
|
import io.javalin.websocket.WsContext
|
|
import io.javalin.http.UploadedFile
|
|
|
|
import java.util.concurrent.ConcurrentHashMap
|
|
import java.util.UUID
|
|
|
|
import kotlin.concurrent.fixedRateTimer
|
|
|
|
import org.json.JSONObject
|
|
import org.json.JSONArray
|
|
import org.json.JSONException
|
|
|
|
import java.io.File
|
|
import java.io.BufferedReader
|
|
|
|
import java.math.BigInteger
|
|
import java.security.MessageDigest
|
|
|
|
import java.nio.file.Paths
|
|
import java.nio.file.Files
|
|
|
|
fun md5(input:String): String {
|
|
val md = MessageDigest.getInstance("MD5")
|
|
return BigInteger(1, md.digest(input.toByteArray())).toString(16).padStart(32, '0')
|
|
}
|
|
|
|
object config {
|
|
var address = ""
|
|
var port = ""
|
|
var security = ""
|
|
var serviceName = ""
|
|
|
|
fun getConfig() {
|
|
val configFile = File("chookchat.config")
|
|
try {
|
|
val config = configFile.readLines()
|
|
var type = ""
|
|
var isEditing = 0
|
|
for (line in config) {
|
|
for (char in line) {
|
|
if (char == ':') {
|
|
isEditing = 1
|
|
} else if (char == ';') {
|
|
isEditing = 0
|
|
type = ""
|
|
} else {
|
|
if (isEditing == 0) {
|
|
type += char
|
|
} else if (isEditing == 1)
|
|
if (type == "address") {
|
|
address += char
|
|
} else if (type == "port") {
|
|
port += char
|
|
} else if (type == "security") {
|
|
security += char
|
|
} else if (type == "serviceName") {
|
|
serviceName += char
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (e: Exception) {
|
|
println("Something went wrong :/ Here's the error: $e")
|
|
}
|
|
}
|
|
}
|
|
|
|
object WsSessionManager {
|
|
val peopleOnline = mutableListOf("")
|
|
val sessionsList = mutableListOf("")
|
|
val sessions = ConcurrentHashMap<WsContext, String>()
|
|
val sessionIds = ConcurrentHashMap<String, WsContext>()
|
|
val userSessions = ConcurrentHashMap<String, String>()
|
|
|
|
init {
|
|
fixedRateTimer("websocket-ping", period = 5000) {
|
|
sendPing()
|
|
}
|
|
}
|
|
private fun sendPing() {
|
|
val deadSessions = mutableListOf<WsContext>()
|
|
|
|
sessions.keys.forEach { ctx ->
|
|
try {
|
|
if (ctx.session.isOpen) {
|
|
ctx.send("ping")
|
|
} else {
|
|
deadSessions.add(ctx)
|
|
}
|
|
} catch (e: Exception) {
|
|
println("Error sending ping: ${e.message}")
|
|
deadSessions.add(ctx)
|
|
}
|
|
}
|
|
|
|
// Clean up any dead sessions
|
|
deadSessions.forEach { removeSession(it) }
|
|
}
|
|
|
|
fun broadcastOnlineUsers() {
|
|
val processedData = JSONObject().apply {
|
|
put("type", "users")
|
|
put("username", "system")
|
|
put("content", peopleOnline.joinToString(", "))
|
|
}
|
|
broadcast(processedData.toString())
|
|
}
|
|
|
|
fun handleUserLogin(username: String) {
|
|
if (!peopleOnline.contains(username)) {
|
|
peopleOnline.add(username)
|
|
broadcastOnlineUsers()
|
|
}
|
|
}
|
|
|
|
fun addSession(ctx: WsContext) {
|
|
try {
|
|
val sessionId = UUID.randomUUID().toString()
|
|
sessionsList.add(sessionId) // Changed from += to add()
|
|
sessions[ctx] = sessionId
|
|
sessionIds[sessionId] = ctx
|
|
} catch (e: Exception) {
|
|
println("Error adding session: ${e.message}")
|
|
}
|
|
}
|
|
|
|
fun removeSession(ctx: WsContext) {
|
|
try {
|
|
val sessionId = sessions[ctx]
|
|
if (sessionId != null) {
|
|
// Find and remove the username associated with this session
|
|
userSessions.entries.find { it.value == sessionId }?.let { entry ->
|
|
peopleOnline.remove(entry.key)
|
|
userSessions.remove(entry.key)
|
|
}
|
|
|
|
sessionsList.remove(sessionId)
|
|
sessions.remove(ctx)
|
|
sessionIds.remove(sessionId)
|
|
broadcastOnlineUsers()
|
|
}
|
|
} catch (e: Exception) {
|
|
println("Error removing session: ${e.message}")
|
|
}
|
|
}
|
|
|
|
fun associateUserWithSession(username: String, ctx: WsContext) {
|
|
val sessionId = sessions[ctx]
|
|
if (sessionId != null) {
|
|
userSessions[username] = sessionId
|
|
}
|
|
}
|
|
|
|
fun broadcast(message: String) {
|
|
val deadSessions = mutableListOf<WsContext>()
|
|
|
|
sessions.keys.forEach { ctx ->
|
|
try {
|
|
if (ctx.session.isOpen) {
|
|
ctx.send(message)
|
|
} else {
|
|
deadSessions.add(ctx)
|
|
}
|
|
} catch (e: Exception) {
|
|
println("Error broadcasting to session: ${e.message}")
|
|
deadSessions.add(ctx)
|
|
}
|
|
}
|
|
|
|
// Clean up any dead sessions
|
|
deadSessions.forEach { removeSession(it) }
|
|
}
|
|
|
|
fun getSessionCount(): Int = sessions.size
|
|
}
|
|
|
|
fun extractMessageContent(inputData: String, ctx: WsContext): String {
|
|
val jsonInputData = JSONObject(inputData)
|
|
if (jsonInputData.getString("type") == "connect") {
|
|
val username = jsonInputData.getString("username")
|
|
WsSessionManager.associateUserWithSession(username, ctx)
|
|
WsSessionManager.handleUserLogin(username)
|
|
val processedData = JSONObject().apply {
|
|
put("type", "connect")
|
|
put("username", "system")
|
|
put("content", "${jsonInputData.getString("username")} just joined the room!")
|
|
}
|
|
return(processedData.toString())
|
|
}
|
|
val processedData = JSONObject().apply {
|
|
put("type", jsonInputData.getString("type"))
|
|
put("username", jsonInputData.getString("username"))
|
|
put("content", jsonInputData.getString("content"))
|
|
}
|
|
return(processedData.toString())
|
|
}
|
|
|
|
fun handleSentMessage(inputData: String): String {
|
|
println("API request recieved: $inputData")
|
|
var jsonInputData: JSONObject
|
|
try {jsonInputData = JSONObject(inputData)} catch (error: JSONException){return(error.toString())}
|
|
|
|
val username = jsonInputData.getString("username")
|
|
val token = jsonInputData.getString("token")
|
|
val content = jsonInputData.getString("content")
|
|
|
|
val userDatabaseParser = BufferedReader(File("userDatabase").reader())
|
|
var lineNumber = 1
|
|
var userLine = ""
|
|
|
|
// Search the user database to find required information about the user
|
|
userDatabaseParser.forEachLine { line ->
|
|
if (line.contains(username)) {
|
|
userLine = line
|
|
}
|
|
lineNumber++
|
|
}
|
|
userDatabaseParser.close()
|
|
|
|
if (userLine == "") {
|
|
val processedData = JSONObject().apply {
|
|
put("type", "error")
|
|
put("username", "system")
|
|
put("content", "unknown-account")
|
|
}
|
|
return(processedData.toString())
|
|
}
|
|
|
|
var usernameInDatabase = ""
|
|
var tokenInDatabase = ""
|
|
var saltInDatabase = ""
|
|
var banStatus = ""
|
|
var currentStage = 0
|
|
for (char in userLine) {
|
|
if (char == ':') {
|
|
currentStage ++
|
|
}
|
|
if (currentStage == 0) {
|
|
usernameInDatabase += char
|
|
} else if (currentStage == 1) {
|
|
tokenInDatabase += char
|
|
} else if (currentStage == 2) {
|
|
saltInDatabase += char
|
|
} else if (currentStage == 3) {
|
|
banStatus += char
|
|
}
|
|
}
|
|
tokenInDatabase = tokenInDatabase.replace(":", "")
|
|
saltInDatabase = saltInDatabase.replace(":", "")
|
|
banStatus = banStatus.replace(":", "")
|
|
if (banStatus == "1") {
|
|
val processedData = JSONObject().apply {
|
|
put("type", "error")
|
|
put("username", "system")
|
|
put("content", "banned")
|
|
}
|
|
return(processedData.toString())
|
|
}
|
|
val tokenWithSalt = (md5(token + saltInDatabase))
|
|
/*println(saltInDatabase)
|
|
println(tokenWithSalt)
|
|
if (tokenWithSalt != tokenInDatabase) {*/
|
|
if (token != tokenInDatabase) {
|
|
val processedData = JSONObject().apply {
|
|
put("type", "error")
|
|
put("username", "system")
|
|
put("content", "invalid-token")
|
|
}
|
|
return(processedData.toString())
|
|
}
|
|
// Make the message to respond to the client
|
|
val chatHistoryView = File("chatHistory")
|
|
var fullMessage = ""
|
|
if (content != "") {
|
|
fullMessage = "${chatHistoryView.readText()}$username: $content"
|
|
// Add the client's message to the chat history
|
|
val chatHistory = File("chatHistory")
|
|
chatHistory.appendText("$username: $content ${System.lineSeparator()}")
|
|
return("Success")
|
|
} else {
|
|
return("No data provided")
|
|
}
|
|
return("Chookchat")
|
|
}
|
|
|
|
fun createAccount(inputData: String): String {
|
|
println("Account creation request recieved: $inputData")
|
|
// Parse data sent to the server by client
|
|
var username = ""
|
|
var token = ""
|
|
var message = ""
|
|
var dataType = ""
|
|
var isParsingData = 0
|
|
for (char in inputData) {
|
|
val character = char
|
|
if (character == ':') {
|
|
isParsingData = 1
|
|
} else if (isParsingData == 1) {
|
|
if (character == '}') {
|
|
isParsingData = 0
|
|
dataType = ""
|
|
} else if (character != '{') {
|
|
if (dataType == "username") {
|
|
username += character
|
|
} else if (dataType == "token") {
|
|
token += character
|
|
} else if (dataType == "message") {
|
|
message += character
|
|
}
|
|
}
|
|
} else {
|
|
dataType += character
|
|
}
|
|
}
|
|
val userDatabaseParser = BufferedReader(File("userDatabase").reader())
|
|
var lineNumber = 1
|
|
var userExists = 0
|
|
|
|
// Search the user database to find required information about the user
|
|
var response = ""
|
|
userDatabaseParser.forEachLine { line ->
|
|
if (line.contains(username)) {
|
|
val processedData = JSONObject().apply {
|
|
put("type", "error")
|
|
put("username", "system")
|
|
put("content", "username-taken")
|
|
}
|
|
response = processedData.toString()
|
|
}
|
|
lineNumber++
|
|
}
|
|
if (response != "") {
|
|
return(response)
|
|
}
|
|
userDatabaseParser.close()
|
|
if (username == "") {
|
|
val processedData = JSONObject().apply {
|
|
put("type", "error")
|
|
put("username", "system")
|
|
put("content", "no-username")
|
|
}
|
|
return(processedData.toString())
|
|
}
|
|
|
|
if (token == "") {
|
|
val processedData = JSONObject().apply {
|
|
put("type", "error")
|
|
put("username", "system")
|
|
put("content", "no-token")
|
|
}
|
|
return(processedData.toString())
|
|
}
|
|
|
|
val userDatabaseFile = File("userDatabase")
|
|
userDatabaseFile.appendText("${System.lineSeparator()}$username:$token")
|
|
val processedData = JSONObject().apply {
|
|
put("type", "success")
|
|
put("username", "system")
|
|
put("content", "success")
|
|
}
|
|
return(processedData.toString())
|
|
}
|
|
|
|
fun handleServerCommand(command: String): String {
|
|
val commandArgs = mutableListOf("")
|
|
commandArgs.drop(1)
|
|
var currentStage = 0
|
|
|
|
for (char in command) {
|
|
if (char == ' ') {
|
|
currentStage ++
|
|
commandArgs += ""
|
|
} else {
|
|
commandArgs[currentStage] += char
|
|
}
|
|
}
|
|
return("I'm not sure how to ${commandArgs.toString()}")
|
|
}
|
|
|
|
fun buildHTML(): String {
|
|
try {
|
|
config.getConfig()
|
|
val htmlFile = File("resources/index.html")
|
|
val html = htmlFile.readLines()
|
|
var editedhtml = ""
|
|
for (line in html) {
|
|
if (line == """ <input type="text" id="serverUrl" value="bobcompass.online" placeholder="Server URL"><br>""") {
|
|
editedhtml += """ <input type="text" id="serverUrl" value="${config.address}" placeholder="Server URL"><br>"""
|
|
} else if (line == """ <input type="text" id="serverPort" value="443" placeholder="Server Port"><br>""") {
|
|
editedhtml += """ <input type="text" id="serverPort" value="${config.port}" placeholder="Server Port"><br>"""
|
|
} else if (line == """ <input type="checkbox" id="securityStatus" checked>""" && config.security == "false") {
|
|
editedhtml += """ <input type="checkbox" id="securityStatus">"""
|
|
} else if (line == """ <h3>Chookchat</h3>""") {
|
|
editedhtml += """ <h3>${config.serviceName}</h3>"""
|
|
} else {
|
|
editedhtml += line
|
|
}
|
|
}
|
|
return(editedhtml)
|
|
} catch (e: Exception) {
|
|
println(e)
|
|
return("There was an error! If you're the server's admin, here are the details: $e")
|
|
}
|
|
return("dingus")
|
|
}
|
|
|
|
fun main(args: Array<String>) {
|
|
WsSessionManager.peopleOnline.removeAt(0)
|
|
WsSessionManager.sessionsList.removeAt(0)
|
|
val app = Javalin.create { config ->
|
|
config.staticFiles.add("/public")
|
|
}.get("/") { ctx ->
|
|
ctx.html(buildHTML())
|
|
//ctx.redirect("/index.html")
|
|
}
|
|
.get("/api/createaccount/{content}") { ctx -> ctx.result(createAccount(ctx.pathParam("content")))}
|
|
.post("/api/upload") { ctx ->
|
|
val uploadedFiles = ctx.uploadedFiles()
|
|
if (uploadedFiles.isEmpty()) {
|
|
ctx.status(400).result("No files uploaded")
|
|
return@post
|
|
}
|
|
val uploadedFile = uploadedFiles[0]
|
|
val originalFilename = uploadedFile.filename()
|
|
val uuid = UUID.randomUUID().toString()
|
|
val fileExtension = originalFilename.substringAfterLast(".", "")
|
|
val baseFilename = originalFilename.substringBeforeLast(".")
|
|
val newFilename = "${baseFilename}_${uuid}${if (fileExtension.isNotEmpty()) ".$fileExtension" else ""}"
|
|
val filePath = Paths.get("uploads", newFilename)
|
|
Files.copy(uploadedFile.content(), filePath)
|
|
val processedData = JSONObject().apply {
|
|
put("type", "fileStatus")
|
|
put("username", "system")
|
|
put("content", "success")
|
|
}
|
|
ctx.result(processedData.toString())
|
|
val processedData2 = JSONObject().apply {
|
|
put("type", "file")
|
|
put("username", "system")
|
|
put("content", "https://maxwellj.xyz/chookchat/uploads/$newFilename")
|
|
}
|
|
WsSessionManager.broadcast(processedData2.toString())
|
|
}
|
|
.ws("/api/websocket") { ws ->
|
|
ws.onConnect { ctx ->
|
|
WsSessionManager.addSession(ctx)
|
|
}
|
|
ws.onClose { ctx ->
|
|
WsSessionManager.removeSession(ctx)
|
|
}
|
|
ws.onMessage { ctx ->
|
|
when (ctx.message()) {
|
|
"pong" -> {}
|
|
else -> {
|
|
println(ctx.message())
|
|
val successState = handleSentMessage(ctx.message())
|
|
if (successState != "Success") {
|
|
try {
|
|
ctx.send(successState)
|
|
} catch (e: Exception) {
|
|
println("Error sending error message: ${e.message}")
|
|
}
|
|
} else {
|
|
val messageContent = extractMessageContent(ctx.message(), ctx)
|
|
WsSessionManager.broadcast(messageContent)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.start(7070)
|
|
try {
|
|
if (args[0] == "-i") {
|
|
println("Type a command for the server")
|
|
while (1 == 1) {
|
|
println(handleServerCommand(readln()))
|
|
}
|
|
} else {
|
|
println("Interactive mode disabled, add -i to enable")
|
|
}
|
|
} catch (error: Exception) {
|
|
println("Interactive mode disabled, add -i to enable")
|
|
}
|
|
}
|
|
|