Ladebeze66/ft_irc
1
0
Fork 0
mirror of https://github.com/Ladebeze66/ft_irc.git synced 2025-12-17 06:28:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

3105

Browse Source
This commit is contained in:
Ladebeze66 2024-05-31 12:34:41 +02:00
parent 4f8d1f3d1f
commit 49537a7282
6 changed files with 83 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ft_irc3/includes/Client.hpp
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/15 12:15:42 by fgras-ca #+# #+# */
/* Updated: 2024/05/28 14:17:16 by fgras-ca ### ########.fr */
/* Updated: 2024/05/31 11:31:54 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -41,6 +41,8 @@ public:
const std::string &getAwayMessage() const;
void setAwayMessage(const std::string &message);
void setAway(bool away);
const std::string &getkey() const;
void setkey(const std::string &key);
private:
int _fd;
@ -53,6 +55,7 @@ private:
bool _operator;
bool _away;
std::string _awayMessage;
std::string _key;
};
#endif // CLIENT_HPP

4
ft_irc3/includes/ModeHandler.hpp
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/30 11:12:57 by fgras-ca #+# #+# */
/* Updated: 2024/05/30 18:40:48 by fgras-ca ### ########.fr */
/* Updated: 2024/05/31 11:21:04 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -45,7 +45,7 @@ private:
//void applyModeB(Channel* channel, bool adding, const std::string& argument);
void applyModeL(Channel* channel, bool adding, const std::string& argument);
void applyModeI(Channel* channel, bool adding);
void applyModeK(Channel* channel, bool adding, const std::string& argument);
void applyModeK(Client *client, Channel* channel, bool adding, const std::string& argument);
void applyModeT(Channel* channel, bool adding);
void applyModeO(Client *client, Channel* channel, bool adding, const std::string& argument);
};

20
ft_irc3/includes/RPL.hpp
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/19 15:12:47 by fgras-ca #+# #+# */
/* Updated: 2024/05/30 17:49:15 by fgras-ca ### ########.fr */
/* Updated: 2024/05/31 11:18:49 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -20,9 +20,9 @@
#define SERVER_NAME "IRC_Server"
#define SERVER_VERSION "1.0"
#define USER_MODES "+o/-o"
#define CHANNEL_MODES "none"
#define CHANNEL_MODES_WITH_PARAMS "None"
#define USER_MODES "None"
#define CHANNEL_MODES "l"
#define CHANNEL_MODES_WITH_PARAMS "l"
@ -378,6 +378,12 @@ inline std::string ERR_PASSWDMISMATCH(Client* client)
return oss.str();
}
inline std::string ERR_INVALIDKEY(Client* client, const std::string& channel) {
std::ostringstream oss;
oss << ":" << SERVER_NAME << " 467 " << CLIENT_NICK(client) << " " << channel << " :Invalid key\r\n";
return oss.str();
}
inline std::string ERR_CHANNELISFULL(Client* client, const std::string& channel) {
std::ostringstream oss;
oss << ":" << SERVER_NAME << " 471 " << CLIENT_NICK(client) << " " << channel << " :Cannot join channel (channel is full)\r\n";
@ -440,6 +446,12 @@ inline std::string ERR_USERSDONTMATCH(Client *client) {
return oss.str();
}
inline std::string ERR_INVALIDMODEPARAM(Client* client, const std::string& param) {
std::ostringstream oss;
oss << ":" << SERVER_NAME << " 696 " << CLIENT_NICK(client) << " " << param << " :Invalid mode parameter\r\n";
return oss.str();
}
// PONG Reply
inline std::string RPL_PONG(const std::string& token)
{

12
ft_irc3/src/Client.cpp
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/15 12:17:42 by fgras-ca #+# #+# */
/* Updated: 2024/05/28 14:32:11 by fgras-ca ### ########.fr */
/* Updated: 2024/05/31 11:27:52 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -109,3 +109,13 @@ void Client::setAway(bool away)
{
_away = away;
}
const std::string &Client::getkey() const
{
return _key;
}
void Client::setkey(const std::string &key)
{
_key = key;
}

84
ft_irc3/src/Join.cpp
View File

@ -11,83 +11,6 @@
/* ************************************************************************** */
#include "Join.hpp"
/*void JoinHandler::handleJoinCommand(Client *client, const std::string &channelNames, Server *server)
{
if (channelNames.empty()) {
server->sendToClient(client->getFd(), ERR_NEEDMOREPARAMS(client, "JOIN"));
return;
}
std::vector<std::string> channelList = split(channelNames, ",");
for (std::vector<std::string>::iterator it = channelList.begin(); it != channelList.end(); ++it)
{
const std::string &channelName = *it;
if (channelName.empty()) continue;
std::map<std::string, Channel *> &channels = server->getChannels();
Channel *channel;
if (channels.find(channelName) == channels.end()) {
channel = new Channel(channelName);
channels[channelName] = channel;
channel->addOperator(client); // Set client as operator for new channel
} else {
channel = channels[channelName];
}
if (channel->isBanned(client)) {
server->sendToClient(client->getFd(), ERR_BANNEDFROMCHAN(client, channelName));
continue;
}
if (channel->isFull()) {
server->sendToClient(client->getFd(), ERR_CHANNELISFULL(client, channelName));
continue;
}
if (channel->isInviteOnly() && !channel->isInvited(client)) {
server->sendToClient(client->getFd(), ERR_INVITEONLYCHAN(client, channelName));
continue;
}
channel->addClient(client);
sendJoinSuccess(client, channel, server);
}
}
void JoinHandler::sendJoinSuccess(Client *client, Channel *channel, Server *server)
{
std::string joinMessage = ":" + client->getNickname() + " JOIN " + channel->getName() + "\r\n";
channel->broadcast(joinMessage, client, server);
if (!channel->getTopic().empty()) {
server->sendToClient(client->getFd(), RPL_TOPIC(client, channel->getName(), channel->getTopic()));
server->sendToClient(client->getFd(), RPL_TOPICWHOTIME(client, channel->getName(), channel->getTopicSetter(), channel->getTopicTime()));
} else {
server->sendToClient(client->getFd(), RPL_NOTOPIC(client, channel->getName()));
}
std::string usersList = getUsersList(channel);
server->sendToClient(client->getFd(), usersList);
}
std::string JoinHandler::getUsersList(Channel *channel)
{
std::vector<Client *> clients = channel->getClients();
std::string users;
for (std::vector<Client *>::iterator it = clients.begin(); it != clients.end(); ++it) {
if (channel->isOperator(*it))
users += "@";
users += (*it)->getNickname() + " ";
}
std::ostringstream oss;
oss << RPL_NAMREPLY(clients[0], channel->getName(), users);
oss << RPL_ENDOFNAMES(clients[0], channel->getName());
return oss.str();
}*/
void JoinHandler::handleJoinCommand(Client* client, const std::string& channelNames, Server* server)
{
std::map<std::string, Channel*>& channels = server->getChannels();
@ -146,11 +69,18 @@ void JoinHandler::handleJoinCommand(Client *client, const std::string &channelNa
return;
}
if (!channel->checkKey(client->getkey()))
{
server->sendToClient(client->getFd(), ERR_BADCHANNELKEY(client, channelName));
return;
}
channel->addClient(client);
sendJoinSuccess(client, channel, server);
}
}
void JoinHandler::sendJoinSuccess(Client *client, Channel *channel, Server *server)
{
std::vector<Client *> clients = channel->getClients();

68
ft_irc3/src/ModeHandler.cpp
View File

@ -6,7 +6,7 @@
/* By: fgras-ca <fgras-ca@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/30 11:13:08 by fgras-ca #+# #+# */
/* Updated: 2024/05/30 18:46:37 by fgras-ca ### ########.fr */
/* Updated: 2024/05/31 11:20:45 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,55 +16,55 @@ ModeHandler::ModeHandler(Server* server) : _server(server) {}
void ModeHandler::handleModeCommand(Client* client, const std::string& command)
{
_server->log("Received MODE command: " + command, "\033[1;34m");
_server->log("Received MODE command: " + command, BLUE);
std::vector<std::string> tokens = split(command, " \n\r\t");
if (tokens.size() < 2) {
_server->sendToClient(client->getFd(), ERR_NEEDMOREPARAMS(client, "MODE"));
_server->log("MODE command error: Need more parameters", "\033[1;31m");
_server->log("MODE command error: Need more parameters", RED);
return;
}
std::string target = tokens[1];
if (target[0] == '#' || target[0] == '&') {
_server->log("Handling channel mode for target: " + target, "\033[1;34m");
_server->log("Handling channel mode for target: " + target, GREEN);
handleChannelMode(client, tokens);
} else {
_server->log("Handling user mode for target: " + target, "\033[1;34m");
_server->log("Handling user mode for target: " + target, GREEN);
handleUserMode(client, tokens);
}
}
void ModeHandler::handleUserMode(Client* client, const std::vector<std::string>& tokens)
{
_server->log("Entered handleUserMode", "\033[1;34m");
_server->log("Entered handleUserMode", MAGENTA);
std::string target = tokens[1];
_server->log("User mode target: " + target, "\033[1;34m");
_server->log("User mode target: " + target, CYAN);
if (target != client->getNickname()) {
_server->sendToClient(client->getFd(), ERR_USERSDONTMATCH(client));
_server->log("User mode error: Users don't match", "\033[1;31m");
_server->log("User mode error: Users don't match", RED);
return;
}
if (tokens.size() == 2) {
_server->sendToClient(client->getFd(), RPL_UMODEIS(client, ""));
_server->log("Sent user modes to client", "\033[1;32m");
_server->log("Sent user modes to client", GREEN);
} else {
std::string modeString = tokens[2];
_server->log("Updating user modes: " + modeString, "\033[1;34m");
_server->log("Updating user modes: " + modeString, BLUE);
// Additional logging or mode handling logic can be added here
}
}
void ModeHandler::handleChannelMode(Client* client, const std::vector<std::string>& tokens)
{
_server->log("Entered handleChannelMode", "\033[1;34m");
_server->log("Entered handleChannelMode", MAGENTA);
std::string channelName = tokens[1];
_server->log("Channel mode target: " + channelName, "\033[1;34m");
_server->log("Channel mode target: " + channelName, CYAN);
Channel* channel = _server->getChannelByName(channelName);
if (!channel) {
_server->sendToClient(client->getFd(), ERR_NOSUCHCHANNEL(client, channelName));
_server->log("Channel mode error: No such channel " + channelName, "\033[1;31m");
_server->log("Channel mode error: No such channel " + channelName, RED);
return;
}
@ -73,13 +73,13 @@ void ModeHandler::handleChannelMode(Client* client, const std::vector<std::strin
oss << RPL_CHANNELMODEIS(client, channel->getName(), channel->getModes());
oss << RPL_CREATIONTIME(client, channel->getName(), channel->getTopicTime());
_server->sendToClient(client->getFd(), oss.str());
_server->log("Sent channel modes to client", "\033[1;32m");
_server->log("Sent channel modes to client", GREEN);
return;
}
if (!channel->isOperator(client)) {
_server->sendToClient(client->getFd(), ERR_CHANOPRIVSNEEDED(client, channelName));
_server->log("Channel mode error: Channel operator privileges needed for " + channelName, "\033[1;31m");
_server->log("Channel mode error: Channel operator privileges needed for " + channelName, RED);
return;
}
@ -91,10 +91,10 @@ void ModeHandler::handleChannelMode(Client* client, const std::vector<std::strin
char mode = modeString[i];
if (mode == '+') {
adding = true;
_server->log("Adding mode: " + std::string(1, mode), "\033[1;34m");
_server->log("Adding mode: " + std::string(1, mode), GREEN);
} else if (mode == '-') {
adding = false;
_server->log("Removing mode: " + std::string(1, mode), "\033[1;34m");
_server->log("Removing mode: " + std::string(1, mode), RED);
} else if (mode == 'b' || mode == 'l' || mode == 'i' || mode == 'k' || mode == 't') {
std::string argument;
if (argIndex < tokens.size()) {
@ -103,14 +103,14 @@ void ModeHandler::handleChannelMode(Client* client, const std::vector<std::strin
setChannelMode(client, channel, std::string(1, mode), adding, argument);
} else {
_server->sendToClient(client->getFd(), ERR_UNKNOWNMODE(client, mode, channelName));
_server->log("Unknown mode: " + std::string(1, mode), "\033[1;31m");
_server->log("Unknown mode: " + std::string(1, mode), RED);
}
}
}
void ModeHandler::setChannelMode(Client *client, Channel* channel, const std::string& mode, bool adding, const std::string& argument)
{
_server->log("Setting channel mode: " + mode + " Adding: " + (adding ? "true" : "false") + " Argument: " + argument, "\033[1;32m");
_server->log("Setting channel mode: " + mode + " Adding: " + (adding ? "true" : "false") + " Argument: " + argument, GREEN);
if (mode == "l")
{
applyModeL(channel, adding, argument);
@ -121,7 +121,7 @@ void ModeHandler::setChannelMode(Client *client, Channel* channel, const std::st
}
else if (mode == "k")
{
applyModeK(channel, adding, argument);
applyModeK(client, channel, adding, argument);
}
else if (mode == "t")
{
@ -137,34 +137,40 @@ void ModeHandler::applyModeL(Channel* channel, bool adding, const std::string& a
int limit = std::atoi(argument.c_str());
std::ostringstream oss;
oss << limit;
_server->log("Applying mode L: Setting limit to " + oss.str(), "\033[1;32m");
_server->log("Applying mode L: Setting limit to " + oss.str(), GREEN);
channel->setClientLimit(limit);
} else {
_server->log("Applying mode L: Removing limit", "\033[1;31m");
_server->log("Applying mode L: Removing limit", RED);
channel->setClientLimit(0);
}
}
void ModeHandler::applyModeI(Channel* channel, bool adding)
{
_server->log("Applying mode I: " + std::string(adding ? "Setting invite-only" : "Removing invite-only"), "\033[1;32m");
_server->log("Applying mode I: " + std::string(adding ? "Setting invite-only" : "Removing invite-only"), GREEN);
channel->setInviteOnly(adding);
}
void ModeHandler::applyModeK(Channel* channel, bool adding, const std::string& argument)
void ModeHandler::applyModeK(Client *client, Channel* channel, bool adding, const std::string& argument)
{
if (adding) {
_server->log("Applying mode K: Setting key to " + argument, "\033[1;32m");
if (argument.find(' ') != std::string::npos) {
_server->sendToClient(client->getFd(), ERR_INVALIDMODEPARAM(client, argument));
_server->log("Invalid key for mode +k: contains spaces", RED);
return;
}
// You can add more validation checks here if needed
_server->log("Applying mode K: Setting key to " + argument, GREEN);
channel->setKey(argument);
} else {
_server->log("Applying mode K: Removing key", "\033[1;31m");
_server->log("Applying mode K: Removing key", RED);
channel->setKey("");
}
}
void ModeHandler::applyModeT(Channel* channel, bool adding)
{
_server->log("Applying mode T: " + std::string(adding ? "Setting topic protection" : "Removing topic protection"), "\033[1;32m");
_server->log("Applying mode T: " + std::string(adding ? "Setting topic protection" : "Removing topic protection"), GREEN);
channel->setTopicProtection(adding);
}
@ -173,23 +179,23 @@ void ModeHandler::applyModeO(Client* client, Channel* channel, bool adding, cons
Client* targetClient = _server->getClientByName(argument);
if (!targetClient) {
_server->sendToClient(client->getFd(), ERR_NOSUCHNICK(client, argument));
_server->log("Mode o error: No such client " + argument, "\033[1;31m");
_server->log("Mode o error: No such client " + argument, RED);
return;
}
if (!channel->hasClient(targetClient)) {
_server->sendToClient(client->getFd(), ERR_USERNOTINCHANNEL(client, argument, channel->getName()));
_server->log("Mode o error: Client " + argument + " not in channel " + channel->getName(), "\033[1;31m");
_server->log("Mode o error: Client " + argument + " not in channel " + channel->getName(), RED);
return;
}
if (adding) {
_server->log("Applying mode o: Adding operator " + argument, "\033[1;32m");
_server->log("Applying mode o: Adding operator " + argument, GREEN);
channel->addOperator(targetClient);
std::string message = ":" + client->getNickname() + " MODE " + channel->getName() + " +o " + targetClient->getNickname() + "\r\n";
channel->broadcast(message, NULL, _server);
} else {
_server->log("Applying mode o: Removing operator " + argument, "\033[1;31m");
_server->log("Applying mode o: Removing operator " + argument, RED);
channel->removeOperator(targetClient);
std::string message = ":" + client->getNickname() + " MODE " + channel->getName() + " -o " + targetClient->getNickname() + "\r\n";
channel->broadcast(message, NULL, _server);