Merge pull request 'Topic cmd' (#39) from topic-cmd into main

Reviewed-on: #39

Channel/Channel.cpp

@@ -0,0 +1,117 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   Channel.cpp                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com>    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/08 16:41:40 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/08 16:41:40 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "Channel.hpp"
+
+//////////////////
+// Constructors //
+//////////////////
+
+Channel::Channel() { /* std::cout << "Channel default constructor called" << std::endl; */}
+
+Channel::~Channel() { /* std::cout << "Channel destructor called" << std::endl; */}
+
+Channel::Channel(const Channel &other)
+{
+    *this = other;
+    // std::cout << "Channel copy constructor called" << std::endl;
+}
+
+Channel& Channel::operator=(const Channel &other)
+{
+    if (this != &other)
+    {
+        name_ = other.name_;
+		members_ = other.members_;
+		operators_ = other.operators_;
+        topic_ = other.topic_;
+        isInviteOnly_ = other.isInviteOnly_;
+        invitedMembers_ = other.invitedMembers_;
+    }
+    // std::cout << "Channel copy assignment operator called" << std::endl;
+    return (*this);
+}
+
+
+// Constructor with name
+
+Channel::Channel(std::string &name) : name_(name), isInviteOnly_(false) { /* std::cout << "Channel with name constructor called" << std::endl; */ }
+
+
+// Getters
+std::string Channel::getName() const { return (this->name_); }
+
+const	std::set<int> &Channel::getMembers() const
+{
+    return (members_);
+}
+
+// Members
+void	Channel::addMember(int fd)
+{
+    invitedMembers_.erase(fd);
+    this->members_.insert(fd);
+}
+
+void	Channel::removeMember(int fd)			{ this->members_.erase(fd);					}
+bool	Channel::hasMember(int fd) const		{ return (this->members_.count(fd) > 0);	}
+
+// Operators
+void	Channel::addOperator(int fd)		{ this->operators_.insert(fd);				}
+void	Channel::removeOperator(int fd)		{ this->operators_.erase(fd);				}
+bool	Channel::hasOperator(int fd) const	{ return (this->operators_.count(fd) > 0);	}
+
+void	Channel::broadcast(const std::string &msg, const std::map<int, User> &clients, int excludedFd)
+{
+    for (std::set<int>::iterator member = members_.begin(); member != members_.end(); member++)
+    {
+        if ((*member) == excludedFd) continue;
+        std::map<int, User>::const_iterator user = clients.find(*member);
+        
+        if (user != clients.end())
+            user->second.send(msg);
+    }
+}
+
+// Topic
+
+void			Channel::setTopic(std::string content) { this->topic_ = content; }
+std::string		Channel::getTopic() { return (this->topic_); }
+
+
+// Mode
+
+void	Channel::setMode(std::string& mode, std::string& args)
+{
+	bool value;
+	if (mode[0] == '+')
+		value = true;
+	else
+		value = false;
+
+	// very simple to test
+	if (mode[1] == 'i')
+	{
+		isInviteOnly_ = value;
+		return ;
+	}
+
+	(void) args;
+}
+
+void	Channel::inviteMember(const User& client)
+{
+	invitedMembers_.insert(client.getFd());
+}
+
+bool	Channel::isInviteOnly() const { return isInviteOnly_; }
+bool	Channel::isInvited(int fd) const { return invitedMembers_.count(fd) > 0; }

Channel/Channel.hpp

@@ -0,0 +1,73 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   Channel.hpp                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com>    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/08 16:41:40 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/08 16:41:40 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef CHANNEL_HPP
+
+# define CHANNEL_HPP
+
+# include <iostream>
+# include <set>
+# include <map>
+
+# include "../User/User.hpp"
+
+class Channel
+{
+    private:
+        std::string				name_;
+
+		std::set<int>			members_;
+		std::set<int>			operators_;
+
+		std::string				topic_;
+
+		bool					isInviteOnly_;
+		std::set<int>			invitedMembers_;
+
+    public:
+        Channel();
+		Channel(std::string &name);
+        Channel(const Channel &other);
+        Channel& operator=(const Channel &other);
+        ~Channel();
+
+
+		// Getters
+		std::string		getName() const;
+		const	std::set<int> &getMembers() const;
+
+		// Topic
+		void			setTopic(std::string content);
+		std::string		getTopic();
+
+		// Users
+		void			addMember(int fd);
+		void			removeMember(int fd);
+		bool			hasMember(int fd) const;
+
+		// Operators
+		void			addOperator(int fd);
+		void			removeOperator(int fd);
+		bool			hasOperator(int fd) const;
+
+		void			broadcast(const std::string &msg, const std::map<int, User> &clients, int excludedFd);
+
+		// modes
+		void			setMode(std::string& mode, std::string& args);
+
+		void			inviteMember(const User& client);
+		bool			isInviteOnly() const;
+		bool			isInvited(int fd) const;
+
+};
+
+#endif

Makefile

@@ -1,8 +1,13 @@
 NAME = ircserv
 
-SRC = main.cpp Server/Server.cpp Client/Client.cpp
+SRC = main.cpp Server/Server.cpp User/User.cpp \
+		Channel/Channel.cpp \
+		cmds/pass.cpp cmds/nick.cpp cmds/user.cpp \
+		cmds/join.cpp cmds/privmsg.cpp cmds/quit.cpp \
+		cmds/mode.cpp cmds/invite.cpp cmds/kick.cpp \
+		cmds/topic.cpp
 
-HEADERS = Server/Server.hpp
+HEADERS = Server/Server.hpp User/User.hpp
 
 OBJ = $(SRC:.cpp=.o)
 

Server/Server.cpp

@@ -3,34 +3,42 @@
 /*                                                        :::      ::::::::   */
 /*   Server.cpp                                         :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
-/*   By: iherman- <iherman-@student.42malaga.com    +#+  +:+       +#+        */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/05/06 17:19:12 by iherman-          #+#    #+#             */
-/*   Updated: 2026/05/07 14:08:48 by iherman-         ###   ########.fr       */
+/*   Updated: 2026/05/25 10:15:18 by aortigos         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "Server.hpp"
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <signal.h>
+
+#include <poll.h>
+
+#include <cerrno>
+#include <sstream>
+
 const int	Server::kConnectionQueueLimit = 10;
 
 Server::Server() : 
 	port_(PORT_DEFAULT),
-	password_("")
+	password_("password")
 {
-	// std::cout << "Hello from server" << std::endl;
-}
-
-Server::Server(int port, const std::string& password) :
-	port_(port),
-	password_(password)
-{
-	if (port_ < 1 || port_ > 65535)
-		throw std::runtime_error("Invalid port");
-	
-	if (password_.empty())
-		throw std::runtime_error("Empty password");
-
 	serverSocket_ = socket(AF_INET, SOCK_STREAM, 0);
 	if (serverSocket_ < 0)
 		throw std::runtime_error("Failed to create socket");
@@ -48,6 +56,73 @@ Server::Server(int port, const std::string& password) :
 	if (listen(serverSocket_, kConnectionQueueLimit))
 		throw std::runtime_error("Failed to listen");
 
+
+		
+	std::cout << "Server port: " << port_
+		<< "\nServer Password: " << password_
+		<< std::endl;
+}
+
+Server::Server(const Server& other)
+{
+	port_ = other.port_;
+	serverSocket_ = other.serverSocket_;
+	password_ = other.password_;
+	sockets_ = other.sockets_;
+}
+
+Server::Server(int port, const std::string& password) :
+	port_(port),
+	password_(password)
+{
+	if (port_ < 1 || port_ > 65535)
+		throw std::runtime_error("Invalid port");
+	
+	if (password_.empty())
+		throw std::runtime_error("Empty password");
+
+	serverSocket_ = socket(AF_INET, SOCK_STREAM, 0);
+	if (serverSocket_ < 0)
+		throw std::runtime_error("Failed to create socket");
+
+	int	opt = 1;
+	if (setsockopt(serverSocket_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
+	{
+		close(serverSocket_);
+		throw std::runtime_error("setsockopt failed");
+	}
+
+	struct sockaddr_in addr;
+	std::memset(&addr, 0, sizeof(addr));
+
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons(port_);
+	addr.sin_addr.s_addr = INADDR_ANY;
+
+	if (bind(serverSocket_, (struct sockaddr*)&addr, sizeof(addr)))
+	{
+		close(serverSocket_);
+		throw std::runtime_error("Failed to bind");
+	}
+
+	if (listen(serverSocket_, kConnectionQueueLimit))
+	{
+		close(serverSocket_); // maybe make an fd class that cleans up automatically using the destructor
+		throw std::runtime_error("Failed to listen");
+	}
+
+	// Add all new commands to commands_ here
+	commands_["PASS"] = &Server::pass_cmd;
+	commands_["NICK"] = &Server::nick_cmd;
+	commands_["USER"] = &Server::user_cmd;
+	commands_["JOIN"] = &Server::join_cmd;
+	commands_["QUIT"] = &Server::quit_cmd;
+	commands_["PRIVMSG"] = &Server::privmsg_cmd;
+	commands_["MODE"] = & Server::mode_cmd;
+	commands_["INVITE"] = &Server::invite_cmd;
+	commands_["KICK"] = &Server::kick_cmd;
+	commands_["TOPIC"] = &Server::topic_cmd;
+	
 	std::cout << "Server port: " << port_
 		<< "\nServer Password: " << password_
 		<< std::endl;
@@ -55,6 +130,9 @@ Server::Server(int port, const std::string& password) :
 
 Server::~Server()
 {
+	for (std::map<int, User>::iterator it = clients_.begin(); it != clients_.end(); ++it)
+		close(it->first);
+
 	close(serverSocket_);
 }
 
@@ -65,35 +143,162 @@ Server	&Server::operator=(const Server& other)
 		port_ = other.port_;
 		serverSocket_ = other.serverSocket_;
 		password_ = other.password_;
+		sockets_ = other.sockets_;
 	}
 
 	return *this;
 }
 
-void	Server::run()
+void	Server::parseCommand(User& client)
+{
+	std::istringstream	args(client.getBuffer());
+	std::string			command;
+	
+	args >> command;
+
+	if (command.empty())
+	{
+		client.clearBuffer();
+		return ;
+	}
+
+	std::map<std::string, void (Server::*)(User&, std::istringstream&)>::iterator it = commands_.find(command);
+	if (it == commands_.end())
+	{
+		std::string	message = "Error: command not found!\n";
+		send(client.getFd(), message.c_str(), message.size(), 0);
+		client.clearBuffer();
+		return ;
+	}
+	(this->*(it->second))(client, args);
+	client.clearBuffer();
+}
+
+bool	Server::handleClient(User& client)
 {
 	const std::size_t	kBufferSize = 1024;
 	char				buffer[kBufferSize] = {0};
 
-	struct sockaddr_in	client_addr;
-	socklen_t			client_addr_size = sizeof(client_addr);
-	int					clientSocket = accept(serverSocket_, (struct sockaddr*)&client_addr, &client_addr_size);
+	int recv_amount = recv(client.getFd(), buffer, kBufferSize, 0);
+
+	if (recv_amount == 0)
+		return true;
+
+	if (recv_amount < 0)
+	{
+		if (errno == EAGAIN || errno == EWOULDBLOCK)
+			return false;
+		return true;
+	}
+
+	std::string	data(buffer, recv_amount);
+	size_t pos = data.find('\r');
+	if (pos != std::string::npos)
+		data.erase(pos, 1);
+
+	client.appendBuffer(data);
+	
+	if (client.getBuffer().find('\n') != std::string::npos)
+		parseCommand(client);
+
+	return false;
+}
+
+static struct pollfd	newPollfd(int fd)
+{
+	pollfd	pfd;
+
+	pfd.fd = fd;
+	pfd.events = POLLIN;
+	pfd.revents = 0;
+	return pfd;
+}
+
+void	Server::addClient()
+{
+	int	newClientSocket = accept(serverSocket_, NULL, NULL);
+
+	if (newClientSocket == -1)
+	{
+		// Not sure if program should terminate
+		std::cerr << "Problem occured accepting client" << std::endl;
+		return ;
+	}
+
+	fcntl(newClientSocket, F_SETFL, O_NONBLOCK);
+	sockets_.push_back(newPollfd(newClientSocket));
+	clients_[newClientSocket] = User(newClientSocket);
+	std::cout << "Client with fd: " << newClientSocket << " connected" << std::endl;
+}
+
+std::vector<struct pollfd>::iterator	Server::removeClient(std::vector<struct pollfd>::iterator& client)
+{
+	close(client->fd);
+
+	std::cout << "Client with fd: " << client->fd << " disconnected " << std::endl;
+
+	// should also remove client from all channels its in
+
+	clients_.erase(client->fd);
+	return (sockets_.erase(client));
+}
+
+void	Server::run()
+{
+	// add serverSocket_ to sockets_
+	sockets_.push_back(newPollfd(serverSocket_));
 
-	std::string	message;
 	while (true)
 	{
-		int recv_amount = recv(clientSocket, buffer, kBufferSize, 0);
+		int ret = poll(sockets_.data(), sockets_.size(), -1);
 
-		if (recv_amount <= 0)
-			break ;
+		if (ret <= 0)
+		{
+			// not sure if program should terminate
+			std::cerr << "Poll failed" << std::endl;
+			continue ;
+		}
 
-		message.append(buffer, recv_amount);
+		for (std::vector<struct pollfd>::iterator it = sockets_.begin(); it != sockets_.end(); )
+		{
+			if (it->revents & (POLLERR | POLLHUP | POLLNVAL))
+			{
+				it = removeClient(it);
+				continue ;
+			}
 
-		if (message.find('\n') != std::string::npos)
+			if (!(it->revents & POLLIN))
+			{
+				it++;
+				continue ;
+			}
+
+			std::cout << "Checking client with fd: " << it->fd << std::endl;
+
+			// check if listening port is open, if so add client
+			if (it->fd == serverSocket_)
+			{
+				addClient();
+				it++;
 				break ;
 			}
 
-	message = "Server received: " +  message;
-	send(clientSocket, message.c_str(), message.size(), 0);
-	close(clientSocket);
+			// call handleClient for each other socket
+			std::map<int, User>::iterator clientIt = clients_.find(it->fd);
+			if (clientIt == clients_.end())
+			{
+    			std::cerr << "Unknown fd in poll list: " << it->fd << std::endl;
+    			close(it->fd);
+    			it = sockets_.erase(it);
+			    continue;
+			}
+
+			bool disconnected = handleClient(clientIt->second);
+
+			if (disconnected)
+				it = removeClient(it);
+			else
+				it++;
+		}
+	}
 }

Server/Server.hpp

@@ -3,41 +3,35 @@
 /*                                                        :::      ::::::::   */
 /*   Server.hpp                                         :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
-/*   By: iherman- <iherman-@student.42malaga.com    +#+  +:+       +#+        */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/05/06 17:18:11 by iherman-          #+#    #+#             */
-/*   Updated: 2026/05/07 13:29:00 by iherman-         ###   ########.fr       */
+/*   Updated: 2026/05/25 10:15:08 by aortigos         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #ifndef SERVER_HPP
 # define SERVER_HPP
 
-// C lib functions
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-
-#include <signal.h>
-
-#include <poll.h>
-
 // C++ lib functions
 # include <iostream>
 
 # include <string>
 # include <cstring>
 
+# include <vector>
+# include <map>
+
+# include <cctype>
+# include <sstream>
+
+# include <unistd.h>
+
+# include "../User/User.hpp"
+# include "../Channel/Channel.hpp"
+
+
+# define SERVER_NAME "irc.server"
 # define PORT_DEFAULT 9898
 
 class Server
@@ -50,13 +44,39 @@ class Server
 
 		std::string	password_;
 
+		std::vector<struct pollfd>				sockets_;
+		std::map<int, User>						clients_;
+		std::map<std::string, Channel>			channels_;
+
+		std::map<std::string, void (Server::*)(User&, std::istringstream&)>	commands_;
+
+		bool	handleClient(User& client);
+
+		void									addClient();
+		std::vector<struct pollfd>::iterator	removeClient(std::vector<struct pollfd>::iterator& client);
+
+		void	parseCommand(User& client);
+
+		Server(const Server& other);
+		Server	&operator=(const Server& other);
+
+		// Commands
+		void	pass_cmd(User &client, std::istringstream &ss);
+		void	nick_cmd(User &client, std::istringstream &ss);
+		void	user_cmd(User &client, std::istringstream &ss);
+		void	join_cmd(User &client, std::istringstream &ss);
+		void	privmsg_cmd(User &client, std::istringstream &ss);
+		void	quit_cmd(User &client, std::istringstream &ss);
+		void	mode_cmd(User &client, std::istringstream &ss);
+		void	invite_cmd(User &client, std::istringstream &ss);
+		void	kick_cmd(User &client, std::istringstream &ss);
+		void	topic_cmd(User &client, std::istringstream &ss);
+
 	public:
 		Server();
 		Server(int port, const std::string& password);
 		~Server();
 
-		Server	&operator=(const Server& other);
-
 		void	run();
 };
 

User/User.cpp

@@ -16,11 +16,16 @@
 // Constructors //
 //////////////////
 
-User::User()
+User::User() : fd(-1), nick(""), username(""), realname(""), buffer(""), authenticated(false), registered(false)
 {
 	// std::cout << "User default constructor called" << std::endl;
 }
 
+User::User(int fd) : fd(fd), nick(""), username(""), realname(""), buffer(""), authenticated(false), registered(false)
+{
+    // std::cout << "User with fd constructor called" << std::endl;
+}
+
 User::User(const User &other)
 {
 	*this = other;
@@ -31,7 +36,14 @@ User& User::operator=(const User &other)
 {
     if (this != &other)
     {
-        // Copy attributes here
+        fd = other.fd;
+        nick = other.nick;
+        username = other.username;
+        realname = other.realname;
+        buffer = other.buffer;
+        authenticated = other.authenticated;
+        registered = other.registered;
+        channels_ = other.channels_;
     }
     // std::cout << "User copy assignment operator called" << std::endl;
     return (*this);
@@ -42,24 +54,52 @@ User::~User()
     // std::cout << "User destructor called" << std::endl;
 }
 
+
+void    User::send(const std::string &msg) const
+{
+    ::send(fd, msg.c_str(), msg.size(), 0);
+}
+
+// Channels
+void		User::joinChannel(const std::string &channel)
+{
+    channels_.insert(channel);
+}
+
+void		User::leaveChannel(const std::string &channel)
+{
+    channels_.erase(channel);
+}
+
+bool        User::isInChannel(const std::string &channel) const
+{
+    return (channels_.count(channel) > 0);
+}
+
+const		std::set<std::string> &User::getChannels() const
+{
+    return (channels_);
+}
+
 // Getters
 
-int         User::getFd() const             { return (this->fd) };
-std::string User::getNick() const           { return (this->nick) };
-std::string User::getUsername() const       { return (this->username) };
-std::string User::getRealname() const       { return (this->realname) };
-std::string &User::getBuffer()              { return (this->buffer) };
-bool        User::isAuthenticated() const   { return (this->authenticated) };
-bool        User::isRegistered() const      { return (this->registered) };
+int			User::getFd() const				{ return (this->fd); }
+std::string User::getNick() const			{ return (this->nick); }
+std::string User::getUsername() const		{ return (this->username); }
+std::string User::getRealname() const		{ return (this->realname); }
+std::string &User::getBuffer()				{ return (this->buffer); }
+bool		User::isAuthenticated() const	{ return (this->authenticated); }
+bool		User::isRegistered() const		{ return (this->registered); }
 
 
 // Setters
 
-void    setNick(std::string nick)           { this->nick = nick; }
-void    setUsername(std::string username)   { this->username = username; }
-void    setRealname(std::string realname)   { this->realname = realname; }
-void    appendBuffer(std::string buff)      { this->buffer = buff; }
-void    clearBuffer()                       { this->buffer.clear(); }
+void	User::appendBuffer(std::string buff)		{ this->buffer.append(buff); }
+void	User::clearBuffer()							{ this->buffer.clear(); }
 
-void    setAuthenticated(bool value)        { this->authenticated = value; }
-void    setRegistered(bool value)           { this->registered = value; }
+void	User::setNick(std::string nick)				{ this->nick = nick; }
+void	User::setUsername(std::string username)		{ this->username = username; }
+void	User::setRealname(std::string realname)		{ this->realname = realname; }
+
+void	User::setAuthenticated(bool value)		{ this->authenticated = value; }
+void	User::setRegistered(bool value)			{ this->registered = value; }

User/User.hpp

@@ -15,6 +15,8 @@
 # define USER_HPP
 
 # include <iostream>
+# include <sys/socket.h>
+# include <set>
 
 class User
 {
@@ -27,12 +29,22 @@ class User
         bool		authenticated;
         bool		registered;
 
+        std::set<std::string> channels_;
+
     public:
         User();
+        User(int fd);
         User(const User &other);
         User& operator=(const User &other);
         ~User();
 
+        void	send(const std::string &msg) const;
+
+        // Channels
+        void		joinChannel(const std::string &channel);
+		void		leaveChannel( const std::string &channel);
+		bool        isInChannel(const std::string &channel) const;
+		const		std::set<std::string> &getChannels() const;
 
         // Getters
 

cmds/invite.cpp

@@ -0,0 +1,72 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   invclient_ite.cpp                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: iherman- <iherman-@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/23 20:22:46 by iherman-          #+#    #+#             */
+/*   Updated: 2026/05/23 21:14:14 by iherman-         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../Server/Server.hpp"
+
+void	Server::invite_cmd(User &client, std::istringstream &ss)
+{
+	std::string	target;
+	std::string	channel;
+
+	ss >> target >> channel;
+
+	if (!client.isRegistered()) return (client.send(":" SERVER_NAME " 451 * :You have not registered\r\n"));
+
+	if (target.empty() || channel.empty())
+	{
+		return client.send(":" SERVER_NAME " 461 * INVITE :Not enough parameters\r\n");
+	}
+
+	// verify target exists
+	std::map<int, User>::iterator	client_it = clients_.begin();
+	for (; client_it != clients_.end(); ++client_it)
+	{
+		if (client_it->second.getNick() == target)
+			break;
+	}
+	if (client_it == clients_.end())
+	{
+		client.send(":" SERVER_NAME " 401 " + target + " :No such nick\r\n");
+		return ;
+	}
+	
+	// verify channel exist & user is on channel
+	std::map<std::string, Channel>::iterator	channel_it = channels_.find(channel);
+	if (channel_it == channels_.end())
+	{
+		client.send(":" SERVER_NAME " 401 " + target + " :No such channel\r\n");
+		return ;
+	}
+
+	if (!channel_it->second.hasMember(client.getFd()))
+	{
+		client.send(":" SERVER_NAME " 442 " + channel + " :You are not on that channel\r\n");
+		return ;
+	}
+
+	if (channel_it->second.hasMember(client_it->second.getFd()))
+	{
+		client.send(":" SERVER_NAME " 443 " + channel + " :is already on channel\r\n");
+		return ;
+	}
+
+	if (channel_it->second.isInviteOnly() && !channel_it->second.hasOperator(client.getFd()))
+	{
+		client.send(":" SERVER_NAME " 482 " + channel + ":You're not channel operator\r\n");
+		return ;
+	}
+
+	client_it->second.send(":" + client.getNick() + "!" + client.getUsername() + "@localhost INVITE " + client_it->second.getNick() + " :" + channel_it->second.getName());
+	client.send(std::string(":") + SERVER_NAME " 341 " + client.getNick() + " " + client_it->second.getNick() + " " + channel_it->second.getName());
+	channel_it->second.inviteMember(client_it->second);
+}
+

cmds/join.cpp

@@ -0,0 +1,88 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   join.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: iherman- <iherman-@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/15 15:35:16 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/23 18:32:37 by iherman-         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+
+#include "../Server/Server.hpp"
+
+void	Server::join_cmd(User &client, std::istringstream &ss)
+{
+	std::string	args;
+
+	ss >> args;
+	if (!client.isRegistered()) return (client.send(":" SERVER_NAME " 451 * :You have not registered\r\n"));
+	if (args.empty()) return (client.send(":" SERVER_NAME " 461 " + client.getNick() + " JOIN :Not enough parameters\r\n"));
+	
+	std::map<std::string, Channel>::iterator it = channels_.find(args);
+
+	// creates channel
+	if (it == channels_.end())
+	{
+		channels_[args] = Channel(args);
+		channels_[args].addMember(client.getFd());
+		channels_[args].addOperator(client.getFd());
+		client.joinChannel(args);
+		
+		std::string	joinMsg = ":" + client.getNick() + "!" + client.getUsername() + "@localhost JOIN " + args + "\r\n";
+			channels_[args].broadcast(joinMsg, clients_, -1);
+
+		std::string namesList = ":" SERVER_NAME " 353 " + client.getNick() + " = " + args + " :";
+		const std::set<int> &members = channels_[args].getMembers();
+		for (std::set<int>::const_iterator m = members.begin(); m != members.end(); m++)
+		{
+			std::map<int, User>::iterator u = clients_.find(*m);
+			if (u != clients_.end())
+			{
+				if (channels_[args].hasOperator(*m))
+					namesList += "@";
+				namesList += u->second.getNick() + " ";
+			}
+		}
+		client.send(namesList + "\r\n");
+		client.send(":" SERVER_NAME " 366 " + client.getNick() + " " + args + " :End of /NAMES list\r\n");
+	}
+	else
+	{
+		if (it->second.hasMember(client.getFd()))
+		{
+			client.send(":" SERVER_NAME " 443 " + client.getNick() + " " + args + " :is already on channel\r\n");
+			return ;			
+		}
+
+		if (it->second.isInviteOnly() && !it->second.isInvited(client.getFd()))
+		{
+			client.send(":" SERVER_NAME " 473 " + client.getNick() + " " + args + " :Cannot join channel (+i)\r\n");
+			return ;			
+		}
+
+		it->second.addMember(client.getFd());
+
+		client.joinChannel(it->first);
+
+		std::string	joinMsg = ":" + client.getNick() + "!" + client.getUsername() + "@localhost JOIN " + args + "\r\n";
+		channels_[args].broadcast(joinMsg, clients_, -1);
+
+		std::string namesList = ":" SERVER_NAME " 353 " + client.getNick() + " = " + args + " :";
+		const std::set<int> &members = channels_[args].getMembers();
+		for (std::set<int>::const_iterator m = members.begin(); m != members.end(); m++)
+		{
+			std::map<int, User>::iterator u = clients_.find(*m);
+			if (u != clients_.end())
+			{
+				if (channels_[args].hasOperator(*m))
+					namesList += "@";
+				namesList += u->second.getNick() + " ";
+			}
+		}
+		client.send(namesList + "\r\n");
+		client.send(":" SERVER_NAME " 366 " + client.getNick() + " " + args + " :End of /NAMES list\r\n");
+	}
+}

cmds/kick.cpp

@@ -0,0 +1,58 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   kick.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/25 09:27:35 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/25 09:52:27 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../Server/Server.hpp"
+
+void	Server::kick_cmd(User &client, std::istringstream &ss)
+{
+	std::string	channel;
+	std::string user;
+	std::string	reason;
+
+	ss >> channel >> user;
+	getline(ss, reason);
+
+	if (!client.isRegistered()) return (client.send(":" SERVER_NAME " 451 " + client.getNick() + " :You have not registered\r\n"));
+
+	if (channel.empty() || user.empty())
+		return (client.send(":" SERVER_NAME " 461 " + client.getNick() + " KICK :not enough parameters\r\n"));
+	if (!reason.empty() && reason[0] == ' ')
+		reason = reason.substr(1);
+	if (!reason.empty() && reason[0] == ':')
+		reason = reason.substr(1);
+	if (reason.empty()) reason = "Kicked";
+	
+	if (channel[0] != '#') return (client.send(""));
+
+	std::map<std::string, Channel>::iterator it_channels = channels_.find(channel);
+
+	if (it_channels == channels_.end())
+		return (client.send(":" SERVER_NAME " 403 " + client.getNick() + " " + channel + " :No such channel\r\n"));
+	if (!it_channels->second.hasOperator(client.getFd()))
+		return (client.send(":" SERVER_NAME " 482 " + client.getNick() + " " + channel + " :You're not channel operator\r\n"));
+
+	int userId = -1;
+	for (std::map<int, User>::iterator it_clients = clients_.begin(); it_clients != clients_.end(); it_clients++)
+	{
+		if (it_clients->second.getNick() == user)
+			userId = it_clients->second.getFd();
+	}
+	if (userId == -1)
+		return (client.send(":" SERVER_NAME " 401 " + client.getNick() + " " + user + " :No such nick\r\n"));
+	if (!it_channels->second.hasMember(userId))
+		return (client.send(":" SERVER_NAME " 441 " + client.getNick() + " " + user + " " + channel + " :They aren't on that channel\r\n"));
+	
+	it_channels->second.broadcast(":" + client.getNick() + "!" + client.getUsername() + "@localhost KICK " + channel + " " + user + " :" + reason + "\r\n", clients_, -1);
+	clients_[userId].leaveChannel(channel);
+	it_channels->second.removeMember(userId);
+
+}

cmds/mode.cpp

@@ -0,0 +1,41 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   mode.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: iherman- <iherman-@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/23 17:15:27 by iherman-          #+#    #+#             */
+/*   Updated: 2026/05/23 20:25:02 by iherman-         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../Server/Server.hpp"
+
+void	Server::mode_cmd(User &client, std::istringstream &ss)
+{
+	std::string	target;
+	std::string	mode;
+	std::string	args;
+
+	ss >> target >> mode;
+	std::getline(ss, args); // might include space in channel name, need to fix
+
+	if (!client.isRegistered()) return (client.send(":" SERVER_NAME " 451 * :You have not registered\r\n"));
+	if (target.empty() || mode.empty()) return (client.send(":" SERVER_NAME " 461 " + client.getNick() + " MODE :Not enough parameters\r\n"));
+
+	std::map<std::string, Channel>::iterator	channel = channels_.find(target);
+	if (channel == channels_.end())
+	{
+		client.send(":" SERVER_NAME " 403 " + client.getNick() + target + ":No such channel\r\n");
+		return ;
+	}
+
+	if (!channel->second.hasOperator(client.getFd()))
+	{
+		client.send(std::string(":") + SERVER_NAME + " 482 " + client.getNick() + " " + channel->second.getName() + " :You're not channel operator\r\n");
+		return ;
+	}
+
+	channel->second.setMode(mode, args); // args should prob be a stringstream :( 
+}

cmds/nick.cpp

@@ -0,0 +1,68 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   nick.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/10 22:06:22 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/16 11:12:12 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../Server/Server.hpp"
+
+
+static bool isValidNick(const std::string &nick)
+{
+	const std::string special = "[]\\`_^{|}";
+
+	if (!isalpha(nick[0]) && special.find(nick[0]) == std::string::npos)
+		return (false);
+	for (size_t i = 1; i < nick.size(); i++)
+	{
+		if (!isalnum(nick[i]) && special.find(nick[i]) == std::string::npos && nick[i] != '-')
+			return (false);
+	}
+	return (true);
+}
+
+void	Server::nick_cmd(User &client, std::istringstream &ss)
+{
+	std::string		args;
+
+	ss >> args;
+	if (!client.isAuthenticated()) return (client.send(":" SERVER_NAME " 451 * :You have not registered\r\n"));
+	if (args.empty()) return (client.send(":" SERVER_NAME " 431 * :Not nickname given\r\n"));
+	if (!isValidNick(args)) return (client.send(":" SERVER_NAME " 432 * " + args + " :Erroneous nickname\r\n"));
+	for (std::map<int, User>::iterator it = clients_.begin(); it != clients_.end(); it++)
+	{
+		if (it->second.getNick() == args)
+			return (client.send(":" SERVER_NAME " 433 * " + args + " :Nickname is already in use\r\n"));
+	}
+	
+	std::string oldNick = client.getNick();
+	client.setNick(args);
+
+	if (client.isRegistered())
+	{
+		std::string msg = ":" + oldNick + " NICK " + args + "\r\n";
+		const std::set<std::string> &userChannels = client.getChannels();
+		for (std::set<std::string>::const_iterator it = userChannels.begin(); it != userChannels.end(); it++)
+		{
+			std::map<std::string, Channel>::iterator ch = channels_.find(*it);
+			if (ch != channels_.end())
+				ch->second.broadcast(msg, clients_, -1);
+		}
+		return ;
+	}
+
+	if (!client.getUsername().empty())
+	{
+		client.setRegistered(true);
+		client.send(":" SERVER_NAME " 001 " + args + " :Welcome to the IRC Network " + args + "\r\n");
+		client.send(":" SERVER_NAME " 002 " + args + " :Your host is " SERVER_NAME ", running version 1.0\r\n");
+		client.send(":" SERVER_NAME " 003 " + args + " :This server was created May 2026\r\n");
+		client.send(":" SERVER_NAME " 004 " + args + " :" SERVER_NAME " 1.0\r\n");
+	}
+}

cmds/pass.cpp

@@ -0,0 +1,27 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   pass.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/10 22:06:22 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/15 22:08:49 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../Server/Server.hpp"
+
+void	Server::pass_cmd(User &client, std::istringstream &ss)
+{
+	std::string		args;
+
+	ss >> args;
+	if (args.empty()) return (client.send(":" SERVER_NAME " 461 * PASS :Not enough parameters\r\n"));
+	if (client.isAuthenticated()) return (client.send(":" SERVER_NAME " 462 " + client.getNick() + " :Unauthorized command (already registered)\r\n"));
+	
+	if (this->password_ == args)
+		client.setAuthenticated(true);
+	else 
+		client.send(":" SERVER_NAME " 464 * :Password incorrect\r\n");
+}

cmds/privmsg.cpp

@@ -0,0 +1,52 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   privmsg.cpp                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/15 15:35:16 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/25 10:02:13 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../Server/Server.hpp"
+
+void	Server::privmsg_cmd(User &client, std::istringstream &ss)
+{
+	std::string	channel;
+	std::string	message;
+
+	ss >> channel;
+	getline(ss, message);
+
+	if (!client.isRegistered()) return (client.send(":" SERVER_NAME " 451 " + client.getNick() + " :You have not registered\r\n"));
+	
+	if (channel.empty())
+		return (client.send(":" SERVER_NAME " 411 " + client.getNick() + " :No recipient given (PRIVMSG)\r\n"));
+
+	if (message.empty()) return (client.send(":" SERVER_NAME " 412 " + client.getNick() + " :No text to send\r\n"));
+
+	if (message[0] == ' ')
+		message = message.substr(1);
+	
+	if (channel[0] == '#')
+	{
+		std::map<std::string, Channel>::iterator it = channels_.find(channel);
+
+		if (it == channels_.end())
+			return (client.send(":" SERVER_NAME " 403 " + client.getNick() + " " + channel + " :No such channel\r\n"));
+		if (!it->second.hasMember(client.getFd()))
+			return (client.send(":" SERVER_NAME " 404 " + client.getNick() + " " + channel + " :Cannot send to channel\r\n"));
+		
+		std::string	msg = ":" + client.getNick() + "!" + client.getUsername() + "@localhost PRIVMSG " + channel + " :" + message + "\r\n";
+		it->second.broadcast(msg, clients_, client.getFd());
+	} else  {
+		for(std::map<int, User>::iterator it = clients_.begin(); it != clients_.end(); it++)
+		{
+			if (it->second.getNick() == channel)
+				return (it->second.send(":" + client.getNick() + "!" + client.getUsername() + "@localhost PRIVMSG " + channel + " :" + message + "\r\n"));
+		}
+		client.send(":" SERVER_NAME " 401 " + client.getNick() + " " + channel + " :No such nick\r\n");
+	}
+}

cmds/quit.cpp

@@ -0,0 +1,42 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   quit.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/15 15:35:16 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/16 11:46:45 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+
+#include "../Server/Server.hpp"
+
+void	Server::quit_cmd(User &client, std::istringstream &ss)
+{
+	std::string	reason;
+
+	std::getline(ss, reason);
+
+	if (!reason.empty() && reason[0] == ' ')
+		reason = reason.substr(1);
+	if (!reason.empty() && reason[0] == ':')
+		reason = reason.substr(1);
+	if (reason.empty())
+		reason = "Leaving";
+
+	std::string	msg = ":" + client.getNick() + "!" + client.getUsername() + "@localhost QUIT :" + reason + "\r\n";
+	
+	const std::set<std::string> channels = client.getChannels();
+	for (std::set<std::string>::const_iterator it = channels.begin(); it != channels.end(); it++)
+	{
+		std::map<std::string, Channel>::iterator ch = channels_.find(*it);
+		if (ch != channels_.end())
+		{
+			ch->second.broadcast(msg, clients_, client.getFd());
+			ch->second.removeMember(client.getFd());
+		}
+	}
+	close(client.getFd());
+}

cmds/topic.cpp

@@ -0,0 +1,51 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   topic.cpp                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/25 10:04:16 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/25 10:19:53 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../Server/Server.hpp"
+
+void	Server::topic_cmd(User &client, std::istringstream &ss)
+{
+	std::string	channel;
+	std::string	message;
+
+	ss >> channel;
+	getline(ss, message);
+
+	if (!client.isRegistered()) return (client.send(":" SERVER_NAME " 451 " + client.getNick() + " :You have not registered\r\n"));
+	
+
+	std::map<std::string, Channel>::iterator it = channels_.find(channel);
+
+	if (it == channels_.end())
+		return (client.send(":" SERVER_NAME " 403 " + client.getNick() + " " + channel + " :No such channel\r\n"));
+
+	if (!it->second.hasMember(client.getFd()))
+		return (client.send(":" SERVER_NAME " 404 " + client.getNick() + " " + channel + " :Cannot send to channel\r\n"));
+	
+	if (message.empty())
+	{
+		std::string res = it->second.getTopic();
+		if (res.empty())
+			return (client.send(":" SERVER_NAME " 331 " + client.getNick() + " " + channel + " :No topic is set\r\n"));
+		client.send(":" SERVER_NAME " 332 " + client.getNick() + " " + channel + " :" + res + "\r\n");
+	}
+	else 
+	{
+		if (!message.empty() && message[0] == ' ')
+			message = message.substr(1);
+		if (!it->second.hasOperator(client.getFd()))
+			return (client.send(":" SERVER_NAME " 482 " + client.getNick() + " " + channel + " :You're not channel operator\r\n"));
+		it->second.setTopic(message);
+		it->second.broadcast(":" + client.getNick() + "!" + client.getUsername() + "@localhost TOPIC " + channel + " :" + message + "\r\n", clients_, -1);
+	}
+
+}

cmds/user.cpp

@@ -0,0 +1,48 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   user.cpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: aortigos <aortigos@student.42malaga.com    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/10 22:06:22 by aortigos          #+#    #+#             */
+/*   Updated: 2026/05/15 22:08:59 by aortigos         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../Server/Server.hpp"
+
+void	Server::user_cmd(User &client, std::istringstream &ss)
+{
+	std::string		username;
+	std::string		hostname;
+	std::string		servername;
+	std::string		realname;
+
+	ss >> username >> hostname >> servername;
+	std::getline(ss, realname);
+
+	if (!client.isAuthenticated()) return (client.send(":" SERVER_NAME " 451 * :You have not registered\r\n"));
+	if (client.isRegistered()) return (client.send(":" SERVER_NAME " 462 " + client.getNick() + " :Unauthorized command (already registered)\r\n"));
+
+	if (!realname.empty() && realname[0] == ' ')
+		realname = realname.substr(1);
+	if (realname.empty() || realname[0] != ':')
+		return (client.send(":" SERVER_NAME " 461 * USER :Not enough parameters\r\n"));
+	if (!realname.empty() && realname[0] == ':')
+		realname = realname.substr(1);
+
+	if (username.empty() || hostname.empty() || servername.empty() || realname.empty())
+		return (client.send(":" SERVER_NAME " 461 * USER :Not enough parameters\r\n"));
+	client.setUsername(username);
+	client.setRealname(realname);
+
+	if (!client.getNick().empty())
+	{
+		client.setRegistered(true);
+		client.send(":" SERVER_NAME " 001 " + client.getNick() + " :Welcome to the IRC Network " + client.getNick() + "\r\n");
+		client.send(":" SERVER_NAME " 002 " + client.getNick() + " :Your host is " SERVER_NAME ", running version 1.0\r\n");
+		client.send(":" SERVER_NAME " 003 " + client.getNick() + " :This server was created May 2026\r\n");
+		client.send(":" SERVER_NAME " 004 " + client.getNick() + " :" SERVER_NAME " 1.0\r\n");
+	}
+}

main.cpp

@@ -6,12 +6,13 @@
 /*   By: iherman- <iherman-@student.42malaga.com    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/05/06 17:57:53 by iherman-          #+#    #+#             */
-/*   Updated: 2026/05/07 13:28:09 by iherman-         ###   ########.fr       */
+/*   Updated: 2026/05/10 19:02:29 by iherman-         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "Server/Server.hpp"
 #include <sstream>
+#include <cstdio>
 
 int	get_port(const char* arg)
 {

tasks.md

@@ -29,24 +29,36 @@ Represents a connected IRC client.
 
 ### First stage
 
-- Server starts
-- It accepts two params, ./ircserv <port> <password>
-- The server accepts one user, user can send messages and we can see from server
-- Only 1 poll()
+- [✓] Server starts
+- [✓] It accepts two params, ./ircserv <port> <password>
+- [✓] The server accepts one user, user can send messages and we can see from server
+- [✓] Only 1 poll()
 
 ### Second stage
 
-- Server can handle multiple clients simultaneously
+- [✓] Server can handle multiple clients simultaneously
+- [✓] Manage SO_REUSEADDR (restarting server fails to bind same port)
 
 ### Third stage
 
-- Client has nickname and username
-- Client needs password for authenticate
-- Client can be regular user or operator (admin)
+- [✓] Dispatcher (select function for each command)
+- [✓] Implement generic parser (extract command and pass args to command function)
+- [✓] Client has nickname and username
+- [✓] PASS command for authenticate
 
 ### Fourth stage
 
-- Client can create/connect to channels
-- Client can send message inside channel (only people inside this channel can read)
+- [✓] Client can create/connect to channels
+- [✓] JOIN command (user can create channel)
+- [✓] PRIVMSG command (send message to a channel)
+- [✓] QUIT command
+- [✓] PRIVMSG difference between channels (#) and users
+
+### Fifth stage
+
+- [ ] PART command (user leaves a channel)
+- [✓] KICK command (operator removes a user from channel)
+- [ ] INVITE command (operator invites a user to channel)
+- [ ] TOPIC command (view or set channel topic)
 
 *It will continue...*