src/services/LogServer.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import bcrypt from "bcrypt";
import chalk from "chalk";
import { Server, Socket } from "socket.io";
import Client from "../core/Client";
import Service from "../core/Service";
import { logInfo, logWarn } from "../utils/Logger";

export const name = "logServer";

export default class LogServer extends Service {
    public readonly MAX_CONNECTIONS = 5;
    protected connections = 0;
    private _io?: Server;
    public readonly sockets: Array<Socket> = [];

    constructor(client: Client) {
        super(client);

        if (!client.configManager.systemConfig.log_server?.auto_start) {
            return;
        }

        this.initialize();
    }

    get io() {
        return this._io;
    }

    initialize() {
        this._io = new Server();
        this.setupListeners();
    }

    start() {
        this.initialize();
        this.listen();
    }

    close() {
        this.io?.close();
        this._io = undefined;
    }

    isAuthorized(socket: Socket) {
        const { authorization } = socket.request.headers;
        const [type, password] = authorization?.split(/\s+/) ?? ["", ""];

        if (type !== "Bearer") {
            socket.send("[error] Only bearer tokens are supported!");
            socket.disconnect(true);
            return false;
        }

        if (!bcrypt.compareSync(password, process.env.LOG_SERVER_PASSWORD ?? Math.random().toString())) {
            socket.send("[error] Authentication failed");
            socket.disconnect(true);
            return false;
        }

        return true;
    }

    setupListeners() {
        this.io?.on("connection", socket => {
            if (this.connections >= this.MAX_CONNECTIONS) {
                socket.disconnect();
                return;
            }

            this.connections++;
            logInfo("New client connected to the log server", socket.id);

            socket.on("disconnect", reason => {
                this.connections--;
                logInfo("Client Disconnected from log server: ", socket.id, reason);
                const index = this.sockets.findIndex(s => s.id === socket.id);

                if (index !== -1) {
                    this.sockets.splice(index, 1);
                }
            });

            if (!this.isAuthorized(socket)) {
                logWarn("Unauthorized client attempted to connect to the log server", socket.id);
                return;
            }

            socket.write(`${chalk.cyan("[info]")} Connection Accepted`);

            this.sockets.push(socket);
        });
    }

    send(message: string) {
        for (const socket of this.sockets) {
            socket.send(message);
        }
    }

    log(message: string) {
        this.sockets.forEach(socket => {
            socket.send(`${message}`);
        });
    }

    listen() {
        let port = process.env.LOG_SERVER_PORT ? parseInt(process.env.LOG_SERVER_PORT) : 3500;
        port = isNaN(port) ? 3500 : port;

        this.io?.listen(port);
        logInfo("The log server is running at port", port);
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
5	*
6	* SudoBot is free software; you can redistribute it and/or modify it
7	* under the terms of the GNU Affero General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* SudoBot is distributed in the hope that it will be useful, but
12	* WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public License
17	* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18	*/
19
20	import bcrypt from "bcrypt";
21	import chalk from "chalk";
22	import { Server, Socket } from "socket.io";
23	import Client from "../core/Client";
24	import Service from "../core/Service";
25	import { logInfo, logWarn } from "../utils/Logger";
26
27	export const name = "logServer";
28
29	export default class LogServer extends Service {
30	public readonly MAX_CONNECTIONS = 5;
31	protected connections = 0;
32	private _io?: Server;
33	public readonly sockets: Array<Socket> = [];
34
35	constructor(client: Client) {
36	super(client);
37
38	if (!client.configManager.systemConfig.log_server?.auto_start) {
39	return;
40	}
41
42	this.initialize();
43	}
44
45	get io() {
46	return this._io;
47	}
48
49	initialize() {
50	this._io = new Server();
51	this.setupListeners();
52	}
53
54	start() {
55	this.initialize();
56	this.listen();
57	}
58
59	close() {
60	this.io?.close();
61	this._io = undefined;
62	}
63
64	isAuthorized(socket: Socket) {
65	const { authorization } = socket.request.headers;
66	const [type, password] = authorization?.split(/\s+/) ?? ["", ""];
67
68	if (type !== "Bearer") {
69	socket.send("[error] Only bearer tokens are supported!");
70	socket.disconnect(true);
71	return false;
72	}
73
74	if (!bcrypt.compareSync(password, process.env.LOG_SERVER_PASSWORD ?? Math.random().toString())) {
75	socket.send("[error] Authentication failed");
76	socket.disconnect(true);
77	return false;
78	}
79
80	return true;
81	}
82
83	setupListeners() {
84	this.io?.on("connection", socket => {
85	if (this.connections >= this.MAX_CONNECTIONS) {
86	socket.disconnect();
87	return;
88	}
89
90	this.connections++;
91	logInfo("New client connected to the log server", socket.id);
92
93	socket.on("disconnect", reason => {
94	this.connections--;
95	logInfo("Client Disconnected from log server: ", socket.id, reason);
96	const index = this.sockets.findIndex(s => s.id === socket.id);
97
98	if (index !== -1) {
99	this.sockets.splice(index, 1);
100	}
101	});
102
103	if (!this.isAuthorized(socket)) {
104	logWarn("Unauthorized client attempted to connect to the log server", socket.id);
105	return;
106	}
107
108	socket.write(`${chalk.cyan("[info]")} Connection Accepted`);
109
110	this.sockets.push(socket);
111	});
112	}
113
114	send(message: string) {
115	for (const socket of this.sockets) {
116	socket.send(message);
117	}
118	}
119
120	log(message: string) {
121	this.sockets.forEach(socket => {
122	socket.send(`${message}`);
123	});
124	}
125
126	listen() {
127	let port = process.env.LOG_SERVER_PORT ? parseInt(process.env.LOG_SERVER_PORT) : 3500;
128	port = isNaN(port) ? 3500 : port;
129
130	this.io?.listen(port);
131	logInfo("The log server is running at port", port);
132	}
133	}