Makefile

@@ -6,7 +6,7 @@
 #    By: apommier <apommier@student.42.fr>          +#+  +:+       +#+         #
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2022/12/01 17:27:29 by apommier          #+#    #+#              #
-#    Updated: 2023/03/13 02:21:45 by apommier         ###   ########.fr        #
+#    Updated: 2023/03/09 00:20:47 by apommier         ###   ########.fr        #
 #                                                                              #
 # **************************************************************************** #
 
@@ -34,7 +34,6 @@ SRCS := main.cpp\
 		commands/channel/privmsg.cpp\
 		commands/channel/notice.cpp\
 		commands/channel/part.cpp\
-		commands/channel/list.cpp\
 \
 		commands/other/quit.cpp\
 		commands/other/ping_pong.cpp\

README.md

@@ -1,442 +0,0 @@
-# ft_irc - École 42
-
-## Description
-ft_irc est un projet de l'École 42 qui consiste à créer un serveur IRC (Internet Relay Chat) fonctionnel en C++. Ce projet permet de comprendre en profondeur les protocoles réseau, la programmation socket, et la gestion d'événements asynchrones.
-
-## Objectifs pédagogiques
-- Maîtriser la **programmation réseau** avec les sockets
-- Comprendre le **protocole IRC** (RFC 1459/2812)
-- Implémenter une **architecture serveur** robuste
-- Gérer les **connexions multiples** de manière asynchrone
-- Apprendre l'**I/O multiplexing** avec epoll/kqueue
-- Développer un **parser de commandes** IRC complexe
-
-## Fonctionnalités implémentées
-
-### Fonctionnalités serveur
-- **Connexions multiples** simultanées
-- **Authentification** avec mot de passe
-- **Gestion des utilisateurs** et nicknames
-- **Channels** (salons de discussion)
-- **Messages privés** entre utilisateurs
-- **Opérateurs de canal** avec privilèges
-- **Mode de canal** et restrictions
-
-### Commandes IRC supportées
-
-#### Authentification et connexion
-- `PASS` - Authentification par mot de passe
-- `NICK` - Définition/changement de nickname
-- `USER` - Informations utilisateur
-- `QUIT` - Déconnexion du serveur
-
-#### Gestion des channels
-- `JOIN` - Rejoindre un canal
-- `PART` - Quitter un canal
-- `PRIVMSG` - Envoyer un message
-- `NOTICE` - Envoyer une notice
-- `TOPIC` - Gérer le sujet du canal
-- `LIST` - Lister les canaux
-- `NAMES` - Lister les utilisateurs d'un canal
-
-#### Commandes d'opérateur
-- `KICK` - Expulser un utilisateur
-- `INVITE` - Inviter un utilisateur
-- `MODE` - Modifier les modes du canal
-- `OPER` - Devenir opérateur serveur
-
-#### Commandes d'information
-- `WHO` - Informations sur les utilisateurs
-- `WHOIS` - Informations détaillées
-- `PING/PONG` - Keep-alive du serveur
-
-## Technologies utilisées
-- **Langage** : C++98 (norme 42)
-- **Sockets** : TCP/IP avec socket BSD
-- **I/O Multiplexing** : epoll (Linux) / kqueue (macOS)
-- **Protocole** : IRC (RFC 1459/2812)
-- **Architecture** : Event-driven server
-
-## Architecture du projet
-
-### Structure des fichiers
-```
-ft_irc/
-├── Makefile              # Compilation
-├── includes/             # Headers
-│   ├── ft_irc.hpp       # Header principal
-│   ├── accessList.hpp   # Gestion des accès
-│   └── function_tab.hpp # Table des commandes
-├── srcs/                # Code source
-│   ├── main.cpp         # Point d'entrée
-│   ├── start_server.cpp # Initialisation serveur
-│   ├── server_loop.cpp  # Boucle principale
-│   ├── epoll.cpp        # Gestion événements
-│   ├── new_connection.cpp # Nouvelles connexions
-│   ├── client_request.cpp # Traitement requêtes
-│   ├── delete_user.cpp  # Déconnexions
-│   ├── utils.cpp        # Fonctions utilitaires
-│   └── commands/        # Commandes IRC
-│       ├── auth/        # Authentification
-│       ├── channel/     # Gestion des canaux
-│       ├── channel_op/  # Commandes opérateur
-│       ├── operator/    # Opérateurs serveur
-│       ├── other/       # Autres commandes
-│       └── parse_commands.cpp
-└── tcpdump/             # Outils de debug réseau
-```
-
-### Architecture logicielle
-```
-┌─────────────────────────────────────┐
-│           ft_irc Server             │
-├─────────────────────────────────────┤
-│  ┌─────────────┐ ┌─────────────┐    │
-│  │   epoll     │ │ Command     │    │
-│  │  Manager    │ │  Parser     │    │
-│  └─────────────┘ └─────────────┘    │
-│  ┌─────────────┐ ┌─────────────┐    │
-│  │ Connection  │ │  Channel    │    │
-│  │  Manager    │ │  Manager    │    │
-│  └─────────────┘ └─────────────┘    │
-│  ┌─────────────┐ ┌─────────────┐    │
-│  │    User     │ │   Access    │    │
-│  │  Manager    │ │  Control    │    │
-│  └─────────────┘ └─────────────┘    │
-└─────────────────────────────────────┘
-```
-
-## Installation et utilisation
-
-### Prérequis
-- **C++** compiler (g++, clang++)
-- **Make** pour la compilation
-- **Système Unix** (Linux/macOS)
-- **Client IRC** pour les tests (irssi, hexchat, etc.)
-
-### Compilation
-```bash
-git clone <repository-url>
-cd ft_irc
-make
-```
-
-### Lancement du serveur
-```bash
-./ircserv <port> <password>
-
-# Exemple
-./ircserv 6667 motdepasse123
-```
-
-### Connexion avec un client
-```bash
-# Avec irssi
-irssi -c localhost -p 6667
-
-# Avec netcat (test basique)
-nc localhost 6667
-```
-
-## Protocole IRC implémenté
-
-### Séquence de connexion
-```
-Client                    Serveur
-  |                         |
-  |--- PASS motdepasse ---->|
-  |--- NICK nickname ------>|
-  |--- USER user 0 * :Real->|
-  |                         |
-  |<-- 001 Welcome ---------|
-  |<-- 002 Your host -------|
-  |<-- 003 Server created --|
-  |<-- 004 Server info -----|
-```
-
-### Format des messages IRC
-```
-:<prefix> <command> <params> :<trailing>
-
-Exemples:
-:nick!user@host PRIVMSG #channel :Hello world
-:server 001 nick :Welcome to the IRC Network
-```
-
-### Codes de réponse implémentés
-- **001-004** : Welcome messages
-- **221** : User mode
-- **331-332** : Topic responses
-- **353** : Names reply
-- **366** : End of names
-- **401-404** : Error messages
-- **461-462** : Parameter errors
-- **471-478** : Channel errors
-
-## Gestion des connexions
-
-### I/O Multiplexing avec epoll
-```cpp
-// Exemple de structure epoll
-struct epoll_event events[MAX_EVENTS];
-int epoll_fd = epoll_create1(0);
-
-// Ajout d'un socket à surveiller
-struct epoll_event ev;
-ev.events = EPOLLIN;
-ev.data.fd = client_fd;
-epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
-
-// Boucle principale
-while (true) {
-    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
-    for (int i = 0; i < nfds; i++) {
-        handle_event(events[i]);
-    }
-}
-```
-
-### Gestion des utilisateurs
-```cpp
-class User {
-private:
-    int socket_fd;
-    std::string nickname;
-    std::string username;
-    std::string realname;
-    std::string hostname;
-    bool is_authenticated;
-    std::vector<std::string> channels;
-
-public:
-    // Méthodes de gestion utilisateur
-    void authenticate(const std::string& password);
-    void join_channel(const std::string& channel);
-    void send_message(const std::string& message);
-};
-```
-
-### Gestion des canaux
-```cpp
-class Channel {
-private:
-    std::string name;
-    std::string topic;
-    std::vector<User*> users;
-    std::vector<User*> operators;
-    std::map<char, bool> modes;
-
-public:
-    // Méthodes de gestion canal
-    void add_user(User* user);
-    void remove_user(User* user);
-    void broadcast_message(const std::string& message);
-    void set_mode(char mode, bool value);
-};
-```
-
-## Parser de commandes
-
-### Architecture du parser
-```cpp
-// Table des commandes
-typedef struct {
-    std::string command;
-    void (*function)(User* user, std::vector<std::string> params);
-    bool need_auth;
-    int min_params;
-} command_t;
-
-// Parsing d'une ligne IRC
-std::vector<std::string> parse_irc_message(const std::string& message) {
-    std::vector<std::string> tokens;
-    // Parsing selon RFC IRC
-    return tokens;
-}
-```
-
-### Exemples de commandes
-
-#### PRIVMSG
-```cpp
-void cmd_privmsg(User* user, std::vector<std::string> params) {
-    if (params.size() < 2) {
-        send_error(user, "461", "PRIVMSG :Not enough parameters");
-        return;
-    }
-    
-    std::string target = params[0];
-    std::string message = params[1];
-    
-    if (target[0] == '#') {
-        // Message vers un canal
-        Channel* channel = find_channel(target);
-        if (channel && channel->has_user(user)) {
-            channel->broadcast_message(user, message);
-        }
-    } else {
-        // Message privé
-        User* target_user = find_user(target);
-        if (target_user) {
-            target_user->send_message(format_privmsg(user, message));
-        }
-    }
-}
-```
-
-#### JOIN
-```cpp
-void cmd_join(User* user, std::vector<std::string> params) {
-    if (params.empty()) {
-        send_error(user, "461", "JOIN :Not enough parameters");
-        return;
-    }
-    
-    std::string channel_name = params[0];
-    if (channel_name[0] != '#') {
-        channel_name = "#" + channel_name;
-    }
-    
-    Channel* channel = find_or_create_channel(channel_name);
-    channel->add_user(user);
-    user->join_channel(channel_name);
-    
-    // Envoyer les messages de confirmation
-    send_join_messages(user, channel);
-}
-```
-
-## Sécurité et robustesse
-
-### Authentification
-- **Mot de passe serveur** obligatoire
-- **Validation des nicknames** selon RFC
-- **Limitation des connexions** par IP
-- **Timeouts** pour les connexions inactives
-
-### Protection contre les attaques
-- **Rate limiting** des commandes
-- **Validation des paramètres** stricte
-- **Buffer overflow** prevention
-- **Flood protection** basique
-
-### Gestion d'erreurs
-```cpp
-// Exemple de gestion d'erreur robuste
-try {
-    process_client_message(client_fd, message);
-} catch (const std::exception& e) {
-    log_error("Client " + std::to_string(client_fd) + ": " + e.what());
-    disconnect_client(client_fd);
-}
-```
-
-## Tests et validation
-
-### Tests manuels
-```bash
-# Test de connexion basique
-echo -e "PASS motdepasse\r\nNICK testnick\r\nUSER test 0 * :Test User\r\n" | nc localhost 6667
-
-# Test de canal
-echo -e "JOIN #test\r\nPRIVMSG #test :Hello world\r\n" | nc localhost 6667
-```
-
-### Tests avec clients IRC
-- **irssi** - Client terminal
-- **HexChat** - Client graphique
-- **IRCCloud** - Client web
-- **Textual** - Client macOS
-
-### Outils de debug
-```bash
-# Monitoring réseau avec tcpdump
-tcpdump -i lo -A -s 0 port 6667
-
-# Logs du serveur
-tail -f server.log
-
-# Monitoring des connexions
-netstat -an | grep 6667
-```
-
-## Performance et optimisation
-
-### Métriques supportées
-- **Connexions simultanées** : 500+
-- **Messages par seconde** : 1000+
-- **Latence moyenne** : <10ms
-- **Utilisation mémoire** : ~1MB par 100 users
-
-### Optimisations implémentées
-- **Event-driven architecture** avec epoll
-- **Buffer pooling** pour les messages
-- **Lazy loading** des données utilisateur
-- **Efficient string handling**
-
-## Conformité RFC
-
-### RFC 1459 (Original IRC)
-- ✅ Commandes de base
-- ✅ Format des messages
-- ✅ Codes de réponse
-- ✅ Gestion des canaux
-
-### RFC 2812 (IRC Client Protocol)
-- ✅ Améliorations du protocole
-- ✅ Nouvelles commandes
-- ✅ Gestion des modes
-- ✅ Sécurité renforcée
-
-## Extensions possibles
-
-### Fonctionnalités bonus
-- **SSL/TLS** support
-- **Services** (NickServ, ChanServ)
-- **Modules** dynamiques
-- **IPv6** support
-- **Database** backend
-- **Clustering** multi-serveurs
-
-### Intégrations
-- **Web interface** d'administration
-- **Logs** centralisés
-- **Metrics** et monitoring
-- **API REST** pour l'administration
-
-## Compétences développées
-- **Programmation réseau** avancée en C++
-- **Protocoles Internet** et RFC
-- **Architecture event-driven**
-- **I/O multiplexing** et performance
-- **Parsing** de protocoles complexes
-- **Gestion d'état** distribuée
-- **Debugging** réseau et système
-- **Testing** d'applications réseau
-
-## Contraintes 42
-- **C++98** uniquement
-- **Pas de boost** ou bibliothèques externes
-- **select/poll/epoll** pour I/O multiplexing
-- **Norme de codage** 42 respectée
-- **Pas de memory leaks**
-
-## Outils de développement
-- **Wireshark** - Analyse de trafic
-- **Valgrind** - Détection memory leaks
-- **gdb** - Debugging
-- **strace** - Système calls tracing
-
-## Documentation de référence
-- [RFC 1459 - Internet Relay Chat Protocol](https://tools.ietf.org/html/rfc1459)
-- [RFC 2812 - Internet Relay Chat: Client Protocol](https://tools.ietf.org/html/rfc2812)
-- [Modern IRC Guide](https://modern.ircdocs.horse/)
-
-## Auteur
-Alexandre Pommier (apommier) - École 42
-## Licence
-Projet académique - École 42
-
----
-
-*"Connecting people through code"* 💬🌐

includes/ft_irc.hpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/01 17:27:37 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 09:50:10 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 21:04:49 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -194,7 +194,6 @@ void	print_registered_msg(fdList &allFds, int userNbr);
 /* *******************************CMD UTILS********************************** */
 /* ************************************************************************** */
 
-void	names_reply(fdList &allFds, channelData &chan, int fd, int userNbr);
 void	split(std::string const &str, const char delim, std::vector<std::string> &out);
 void	split_but_keep(std::string const &str, const char delim, std::vector<std::string> &out); //same as split but keep one delimeter
 
@@ -242,13 +241,8 @@ void	parse_commands(std::string buffer, fdList &allFds, int userNbr);
 /* ******************************MODE UTILS********************************** */
 /* ************************************************************************** */
 
-//bool	str_to_int(int &i, const std::string s);
+void	ban_reply(channelData &chan, clientData &user);
-int			print_client_list(std::vector<clientData *> &list);
+void	chan_reply(channelData &chan, clientData &user);
-void		ban_reply(channelData &chan, clientData &user);
+void	user_reply(clientData &user);
-void		chan_reply(channelData &chan, clientData &user);
+int		search_and_erase(std::string &str, std::string toFind);
-void		user_reply(clientData &user);
+bool	str_to_int(int &i, const std::string s);
-void		chan_mode_reply(fdList &allFds, channelData &chan, int userNbr, std::string mode, int sign);
-void		user_mode_reply(fdList &allFds, clientData &user, int userNbr, std::string mode);
-int			search_and_erase(std::string &str, std::string toFind);
-bool		str_to_int(int &i, const std::string s);
-std::string	int_to_str(int i);

srcs/client_request.cpp

@@ -6,28 +6,50 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/09 22:34:36 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:39:34 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/09 05:00:20 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "../includes/ft_irc.hpp"
 
-bool clientRequest(fdList &allFds, int userNbr) 
+bool clientRequest(fdList &allFds, int userNbr)//, 
 {
+	//int userFd = allFds.events[user].data.fd;
 	char buf[1024] = {0};
 	std::string buffer;
 	size_t len = 1024;
 	int ret = 0;
 	
+	//buf.reserve(1024);
+	//se demerder pour join quand pas \n
+	// std::cout << "fd in client request " << allFds.userData[userNbr].fd << std::endl;
+	// std::cout << "fd of list in client request " << allFds.userFdList[userNbr] << std::endl;
+	// std::cout << "user nbr " << userNbr << std::endl;
+	
+	//std::cout << "client request!" << std::endl;
+	//if (recv(allFds.userData[userNbr].fd, buf, len, 0) == -1)
 	if ((ret = recv(allFds.userData[userNbr].fd, buf, len, 0)) == -1)
 		ft_error("recv() error");
 	buffer = buf;
 	buffer[ret] = 0;
 	if (buffer.empty())
 	{
+		//delete client
 		delete_user(allFds, userNbr);
+		// close(allFds.userData[userNbr].fd);
+		// allFds.userData.erase(allFds.userData.begin() + userNbr);
+		// allFds.userFdList.erase(allFds.userFdList.begin() + userNbr);
+		// allFds.nbrUser--;
+		// std::cout << "buffer empty\n";
 		return (1);
 	}
+	// for (int i = 0; buffer[i]; i++)
+	// {
+	// 	std::cout << i << " = " << (int)buffer[i] << std::endl;	
+	// }
+	
+	//split with \n and while (tab de split) -> parsing
+
 	std::vector<std::string> splitBuff;
 	split_but_keep(buffer, '\n', splitBuff);
 	for (size_t i = 0; i < splitBuff.size(); i++)

srcs/commands/auth/connect_client.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/12 23:30:11 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:28:12 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:19:44 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -53,12 +53,19 @@ void print_registered_msg(fdList &allFds, int userNbr)
 
 void connect_client(fdList &allFds, int userNbr)
 {
+	//std::cout << "connect client start\n";
+	
 	if (allFds.userData[userNbr].password.empty() || allFds.userData[userNbr].password != allFds.password)
 	{
 		std::cout << "password= " << allFds.userData[userNbr].password << std::endl;
 		cmd_error(allFds, allFds.userData[userNbr].fd, "464 * :Password incorrect\r\n");
 		return ;
 	}
+   	//464    ERR_PASSWDMISMATCH
+    //":Password incorrect"
+
 	allFds.userData[userNbr].registered = 1;
 	print_registered_msg(allFds, userNbr);
+	//std::cout << "connect client end\n";
+	//ft_putstr_fd(allFds.userData[userNbr].fd, ":irc.local NOTICE kinou :*** Could not resolve your hostname: Request timed out; using your IP address (172.17.0.1) instead.\nirc.local 376 kinou :End of message of the day.");
 }

srcs/commands/auth/nick.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/06 14:28:38 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:28:37 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:20:28 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -35,9 +35,15 @@ void	NICK(std::string buffer, fdList &allFds, int userNbr)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "433 * " + splitBuff[1] + " :Nickname is already in use\r\n");
 		return ;
 	}
+	//if nickname ok then (another user has it? )
+	//ERR_NONICKNAMEGIVEN
 	allFds.userData[userNbr].nickname = splitBuff[1];
-	if (!allFds.userData[userNbr].registered && !allFds.userData[userNbr].userName.empty())
+	if (!allFds.userData[userNbr].registered && !allFds.userData[userNbr].userName.empty() /*&& !allFds.userData[userNbr].password.empty()*/)
+	{
 		connect_client(allFds, userNbr);
+		// allFds.userData[userNbr].registered = 1;
+		// print_registered_msg(allFds, userNbr);
+	}
 	
 	return ;
 }

srcs/commands/auth/pass.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/06 14:40:42 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:28:47 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:21:05 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -29,8 +29,21 @@ void	PASS(std::string buffer, fdList &allFds, int userNbr)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "462 * PASS :You may not reregister\r\n");
 		return ;
 	}
+	
+	// if (splitBuff.size() != 2)
+	// {
+	// 	cmd_error(allFds, userNbr, "461 * PASS :Not enough parameters");
+	// 		//write(allFds.userData[userNbr].fd, "ERR_NEEDMOREPARAMS", 18);
+	// 	return ;
+	// }
+
 	password = buffer.substr(5, buffer.npos);
 	allFds.userData[userNbr].password = password;
+
 	if (!allFds.userData[userNbr].userName.empty() && !allFds.userData[userNbr].nickname.empty())
+	{
 		connect_client(allFds, userNbr);
+		// allFds.userData[userNbr].registered = 1;
+		// print_registered_msg(allFds, userNbr);
+	}
 }

srcs/commands/auth/user.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/06 14:40:39 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:29:05 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:21:18 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -21,16 +21,23 @@ void USER(std::string buffer, fdList &allFds, int userNbr)
 {
 	if (allFds.userData[userNbr].registered == 1)
 	{
+// " + allFds.userData[userNbr].nickname + " 
 		cmd_error(allFds, allFds.userData[userNbr].fd, "462 " + allFds.userData[userNbr].nickname + " USER :You may not reregister\r\n");
 		return ;
 	}
+	
 	std::string realName = buffer.substr(buffer.find_first_of(":") + 1 , buffer.npos);
 	std::vector<std::string> splitBuff;
+	
+	
 	buffer.resize(buffer.size() - realName.size());
+	//std::cout << "Buffer in userNbr = ---" << buffer << "---" << std::endl;
+	//std::cout << "realname in userNbr = ---" << realName << "---" << std::endl;
 	split(buffer, ' ', splitBuff);
 	if (splitBuff.size() < 4)
 	{
 		cmd_error(allFds, allFds.userData[userNbr].fd, "461 " + allFds.userData[userNbr].nickname + "USER :Not enough parameters\r\n");
+		//write(allFds.userData[userNbr].fd, "ERR_NEEDMOREPARAMS", 18);
 		return ;
 	}
 	allFds.userData[userNbr].userName = splitBuff[1];
@@ -38,6 +45,10 @@ void USER(std::string buffer, fdList &allFds, int userNbr)
 	allFds.userData[userNbr].serverName = splitBuff[3];
 	
 	allFds.userData[userNbr].realName = realName;
-	if (!allFds.userData[userNbr].nickname.empty())
+	if (!allFds.userData[userNbr].nickname.empty() /*&& !allFds.userData[userNbr].password.empty()*/)
+	{
 		connect_client(allFds, userNbr);
+		// allFds.userData[userNbr].registered = 1;
+		// print_registered_msg(allFds, userNbr);
+	}
 }

srcs/commands/channel/channel_utils.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/09 17:21:57 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:29:41 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:21:38 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,15 +16,18 @@ int is_chan_op(fdList &allFds, channelData *chanName, int userNbr)
 {
 	std::vector<clientData*>::iterator start = chanName->opList.begin();
 	std::vector<clientData*>::iterator  pastEnd = chanName->opList.end();
-
+	//std::cout << "name1= ---" << chanName << "---\n";
 	if (allFds.userData[userNbr].op)
 		return (1);
 	while (start != pastEnd)
 	{
+		//std::cout << "result in find chan = " << pastEnd - start << std::endl;
+		//std::cout << "test = " << chanName->opList[pastEnd - start - 1]->nickname << "---\n";
 		if (chanName->opList[pastEnd - start - 1]->nickname == allFds.userData[userNbr].nickname)
 			return (1);
 		start++;
 	}
+	//std::cout << "chan not found in is op\n";
 	return (0);	
 }
 
@@ -32,18 +35,37 @@ int is_joined(fdList &allFds, std::string chanName, int userNbr)
 {
 	std::vector<channelData*>::iterator start = allFds.userData[userNbr].joinedChan.begin();
 	std::vector<channelData*>::iterator  pastEnd = allFds.userData[userNbr].joinedChan.end();
-	
+	//std::cout << "name1= ---" << chanName << "---\n";
 	while (start != pastEnd)
 	{
+		
+		//std::cout << "result in find chan = " << pastEnd - start << std::endl;
+		//std::cout << "test is joined= " << allFds.userData[userNbr].joinedChan[pastEnd - start - 1]->name << "---\n";
 		if (allFds.userData[userNbr].joinedChan[pastEnd - start - 1]->name == chanName)
 			return (pastEnd - start - 1);
 		start++;
 	}
+	//std::cout << "chan not found in is joined\n";
 	return (-1);	
 }
 
 int find_channel(fdList &allFds, std::string chanName)//return channel nbr
 {
+	// std::_List_iterator<channelData> start = allFds.channelList.begin();
+	// std::_List_iterator<channelData> pastEnd = allFds.channelList.end();
+	// //std::cout << "name1= ---" << chanName << "---\n";
+	// while (start != pastEnd)
+	// {
+	// 	//std::cout << "chan = ---" << allFds.channelList[pastEnd - start - 1].name << "---" << std::endl;
+	// 	//std::cout << "test = " << allFds.channelList[pastEnd - start - 1].name << "---\n";
+	// 	if (allFds.channelList[pastEnd - start - 1].name == chanName)
+	// 		return (pastEnd - start - 1);
+	// 	start++;
+	// }
+	// //std::cout << "chan not found in find \n";
+	// return (-1);
+
+
 	int size = allFds.channelList.size();
 	for (int i = 0; i < size; i++)
 	{
@@ -55,6 +77,20 @@ int find_channel(fdList &allFds, std::string chanName)//return channel nbr
 
 int find_user(fdList &allFds, std::string userName)//return direct user fd
 {
+	// std::_List_iterator<clientData> start = allFds.userData.begin();
+	// std::_List_iterator<clientData> pastEnd = allFds.userData.end();
+	// //std::cout << "name1= ---" << userName << "---\n";
+	// while (start != pastEnd)
+	// {
+	// 	//std::cout << "result in find user = " << pastEnd - start << std::endl;
+	// 	//std::cout << "name2= ---" << allFds.userData[pastEnd - start - 1].nickname << "---\n";
+	// 	if (allFds.userData[pastEnd - start - 1].nickname == userName)
+	// 		return (pastEnd - start - 1);
+	// 	start++;
+	// }
+	// //std::cout << "user not found\n";
+	// return (-1);
+
 	int size = allFds.userData.size();
 	for (int i = 0; i < size; i++)
 	{
@@ -67,9 +103,6 @@ int find_user(fdList &allFds, std::string userName)//return direct user fd
 int is_in_same(fdList &allFds, int userNbr, int userNbr2)
 {
 	size_t size;
-	
-	if (userNbr < 0 || userNbr2 < 0)
-		return (0);
 	if (allFds.userData[userNbr].joinedChan.size() <= allFds.userData[userNbr2].joinedChan.size())
 		size = allFds.userData[userNbr].joinedChan.size();
 	else
@@ -84,3 +117,21 @@ int is_in_same(fdList &allFds, int userNbr, int userNbr2)
 	}
 	return (0);
 }
+
+// int is_in_same(fdList &allFds, int userNbr, int userNbr2)
+// {
+// 	size_t size;
+// 	if (allFds.userData[userNbr].joinedChan.size() <= allFds.userData[userNbr2].joinedChan.size())
+// 		size = allFds.userData[userNbr].joinedChan.size();
+// 	else
+// 		size = allFds.userData[userNbr2].joinedChan.size();
+// 	for (size_t i = 0; i < size; i++)
+// 	{
+// 		for (size_t j = 0; j < size; j++)
+// 		{
+// 			if (allFds.userData[userNbr].joinedChan[i] == allFds.userData[userNbr2].joinedChan[j])
+// 				return (1);
+// 		}
+// 	}
+// 	return (0);
+// }

srcs/commands/channel/join.cpp

@@ -6,12 +6,36 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/09 15:40:33 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/14 02:13:25 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:22:44 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "../../../includes/ft_irc.hpp"
 
+
+// Commande: JOIN
+// Paramètres: <canal>{,<canal>} [<clé>{,<clé>}]
+//		1459
+//    ERR_NEEDMOREPARAMS +             ERR_BANNEDFROMCHAN
+//    ERR_INVITEONLYCHAN +             ERR_BADCHANNELKEY 
+//    ERR_CHANNELISFULL x              ERR_BADCHANMASK ? +
+//    ERR_NOSUCHCHANNEL x              ERR_TOOMANYCHANNELS x
+//    RPL_TOPIC
+
+		//		2812
+        //    ERR_NEEDMOREPARAMS              ERR_BANNEDFROMCHAN
+        //    ERR_INVITEONLYCHAN              ERR_BADCHANNELKEY
+        //    ERR_CHANNELISFULL               ERR_BADCHANMASK
+        //    ERR_NOSUCHCHANNEL               ERR_TOOMANYCHANNELS
+        //    ERR_TOOMANYTARGETS              ERR_UNAVAILRESOURCE
+        //    RPL_TOPIC
+
+void leave_all(fdList &allFds, int userNbr)
+{
+	(void)allFds;
+	(void)userNbr;
+}
+
 int chan_check(fdList &allFds, int userNbr, int chanNbr, std::vector<std::string> splitBuff)
 {
 	std::string errorStr;
@@ -53,6 +77,7 @@ void join_or_create(std::string buffer, fdList &allFds, int userNbr)
 	channelData joined_chan;
 	std::vector<std::string> splitBuff;
 	
+	//std::cout << "JOINORCREATE\n";
 	split(buffer, ' ', splitBuff);
 	chanNbr = find_channel(allFds, splitBuff[1]);
 	if (chanNbr != -1) //chan already exist
@@ -61,33 +86,49 @@ void join_or_create(std::string buffer, fdList &allFds, int userNbr)
 			return ;
 		allFds.userData[userNbr].joinedChan.push_back(&allFds.channelList[chanNbr]); //add chan in user data
 		allFds.channelList[chanNbr].userList.push_back(&allFds.userData[userNbr]);//add user in chan data
+		//allFds.channelList[chanNbr].size()++;
 		joined_chan = *(allFds.userData[userNbr].joinedChan.back());
 		if ((invitedUser = find_client_list(allFds.channelList[chanNbr].invitedList, &allFds.userData[userNbr])) != -1)
 			allFds.channelList[chanNbr].invitedList.erase(allFds.channelList[chanNbr].invitedList.begin() + invitedUser);
 	}
 	else //chan doesn't exist yet
 	{
-		channelData tmp_chan;
+		//std::cout << "new chan\n";
-		allFds.channelList.push_back(tmp_chan);
+		channelData new_chan;
-		channelData &new_chan = allFds.channelList[allFds.channelList.size() - 1];
 		if (splitBuff[1][0] != '#' && splitBuff[1][0] != '&')
 			cmd_error(allFds, allFds.userData[userNbr].fd, "476 " + allFds.userData[userNbr].nickname + " " + splitBuff[1] + " :Bad Channel Mask\r\n");
 		new_chan.name = splitBuff[1];
+		//new_chan.nbrUser = 1;
 		new_chan.opList.push_back(&allFds.userData[userNbr]);
 		new_chan.userList.push_back(&allFds.userData[userNbr]);
+		joined_chan = new_chan;
+		allFds.channelList.push_back(new_chan);
 		allFds.userData[userNbr].joinedChan.push_back(&allFds.channelList.back());//add chan in user data
-		joined_chan = allFds.channelList[allFds.channelList.size() - 1];
 	}
+	// if (chanNbr == -1)
+	// {
+	// 	chanNbr = 
+	// 	find_channel(allFds, splitBuff[1])
+	// }
+
 	std::string fullMsg;
 	fullMsg = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName + "@" + allFds.userData[userNbr].ip + " JOIN :" + joined_chan.name + "\r\n";
 	for (size_t i = 0; i < joined_chan.userList.size(); i++)
+	{
 		send(joined_chan.userList[i]->fd, fullMsg.c_str(), fullMsg.size(), 0);
-	std::cout << "size uselist=" << joined_chan.userList.size() << std::endl;
+		//std::cout << "loop here\n";
-	names_reply(allFds, joined_chan, allFds.userData[userNbr].fd, userNbr);
+	}
+
 	if (chanNbr == -1)
 		chanNbr = find_channel(allFds, splitBuff[1]);
 	if (!allFds.channelList[chanNbr].topic.empty())
 		cmd_reply(allFds, allFds.userData[userNbr].fd, "332 TOPIC " + allFds.channelList[chanNbr].name + " :" + allFds.channelList[chanNbr].topic + "\r\n");
+	//else
+	//	cmd_error(allFds, allFds.userData[userNbr].fd, "NOTICE 331 TOPIC " + allFds.channelList[chanNbr].name + " :No topic is set\n");
+	// if (chanNbr == -1)
+	// {
+			
+	// }
 }
 
 
@@ -99,14 +140,27 @@ void join_loop(fdList &allFds, std::vector<std::string> splitBuff, int userNbr)
 	std::vector<std::string>	splitPwd;
 	std::string					buffer;
 	
+	//std::cout << "join loop buf= " << splitBuff[1] << std::endl;
+	//std::cout << "==========join loop========\n";
 	split(splitBuff[1], ',', splitChan);
 	split(splitBuff[1], ',', splitPwd);
+	if (splitBuff[1] == "0")
+	{
+		leave_all(allFds, userNbr);
+		return ;
+	}
+	//std::cout << "==========join loop2========\n";
+	//std::cout << "size= " << splitChan.size() << std::endl;
+	//std::cout << "content= " << splitChan[0] << std::endl;
 	for (size_t i = 0; i < splitChan.size(); i++)
 	{
 		if (splitChan[i][0] != '#' && splitChan[i][0] != '&')
 		{
-			buffer = "476 " + allFds.userData[userNbr].nickname + " JOIN " + splitChan[i] + " :Bad Channel Mask\r\n";
+			//error bad channel name
+			buffer = "476 " + allFds.userData[userNbr].nickname + " JOIN " + splitChan[i] + " ::Bad Channel Mask\r\n";
 			cmd_error(allFds, allFds.userData[userNbr].fd, buffer);
+			//:Bad Channel Mask
+			//std::cout << "bad chan mask\n";
 			return ;
 		}
 		if (i < splitPwd.size())
@@ -114,7 +168,9 @@ void join_loop(fdList &allFds, std::vector<std::string> splitBuff, int userNbr)
 		else
 			buffer = "JOIN " + splitChan[i];
 		join_or_create(buffer, allFds, userNbr);
+		//std::cout << "i= " << i << "   ==========join loop3========\n";
 	}
+	//std::cout << "==========join loop3========\n";
 }
 
 
@@ -124,6 +180,7 @@ void JOIN(std::string buffer, fdList &allFds, int userNbr)
 {
 	std::vector<std::string> splitBuff;
 	std::string msg;
+	//std::cout << "==========join start========\n";
 
 	std::cout << "userNbr= " << userNbr << std::endl;
 	if (!allFds.userData[userNbr].registered) 
@@ -134,8 +191,13 @@ void JOIN(std::string buffer, fdList &allFds, int userNbr)
 	split(buffer, ' ', splitBuff);
 	if (splitBuff.size() < 2) 
 	{
+		/*change error*/
+		//std::cout << "JOIN : need more param\n";
 		cmd_error(allFds, allFds.userData[userNbr].fd, "461 " + allFds.userData[userNbr].nickname + " JOIN :Not enough parameters\r\n"); //ERR_NEEDMOREPARAMS
 		return ;
 	}
 	join_loop(allFds, splitBuff, userNbr);
+	//if (splitBuff[1].find(' ') != std::string::npos || splitBuff[1].find(7) != std::string::npos) 
+
+	//send 352 and 315 or 353 and 366 (WHO or NAME)
 }

srcs/commands/channel/list.cpp

@@ -6,65 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/18 00:50:51 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:31:44 by apommier         ###   ########.fr       */
+/*   Updated: 2023/02/18 00:50:52 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "../../../includes/ft_irc.hpp"
-
-void	list_reply(fdList &allFds, channelData &chan, int fd, int userNbr)
-{
-	//:irc.server.com 321 MonPseudo :Channel :Users Name          //start
-	//:irc.server.com 322 MonPseudo #channel 10 :Channel Topic    //list
-	//:irc.server.com 323 MonPseudo :End of LIST                  //end
-	std::string msg;
-	msg = "322 " + allFds.userData[userNbr].nickname + " :" + chan.name + " " + int_to_str(chan.userList.size()) + " :" + chan.topic + "\r\n";//"ChannelName UserNbr :Topic\r\n";
-	cmd_reply(allFds, fd, msg);
-}
-
-void	list_loop(fdList &allFds, std::vector<std::string> splitBuff, int userNbr)
-{
-	std::vector<std::string>	splitChan;
-	int pos;
-	
-	split(splitBuff[1], ',', splitChan);
-	for (size_t i = 0; i < splitChan.size(); i++)
-	{
-		pos = find_channel(allFds, splitChan[i]);
-		if (pos != -1)
-		{
-			if ((!allFds.channelList[pos].mode.p && !allFds.channelList[pos].mode.s) 
-					|| is_joined(allFds, allFds.channelList[pos].name, userNbr) || allFds.userData[userNbr].op)
-				list_reply(allFds, allFds.channelList[pos], allFds.userData[userNbr].fd, userNbr);
-		}
-	}
-}
-
-void	LIST(std::string buffer, fdList &allFds, int userNbr)
-{
-	std::vector<std::string> splitBuff;
-	std::string msg;
-	
-	if (!allFds.userData[userNbr].registered) 
-	{
-		cmd_error(allFds, allFds.userData[userNbr].fd, "451 " + allFds.userData[userNbr].nickname + " LIST :You have not registered\r\n");
-		return ;
-	}
-	split(buffer, ' ', splitBuff);
-	msg = "321 " + allFds.userData[userNbr].nickname + " :ChannelName UserNbr :Topic\r\n";
-	cmd_reply(allFds, allFds.userData[userNbr].fd, msg);
-	if (splitBuff.size() == 1 || splitBuff[1] == "0")
-	{
-		for (size_t i = 0; i < allFds.channelList.size(); i++)
-		{
-			if ((!allFds.channelList[i].mode.p && !allFds.channelList[i].mode.s) 
-					|| is_joined(allFds, allFds.channelList[i].name, userNbr) || allFds.userData[userNbr].op)
-				list_reply(allFds, allFds.channelList[i], allFds.userData[userNbr].fd, userNbr);
-		}
-		return ;
-	}
-	else
-		list_loop(allFds, splitBuff, userNbr);
-	msg = "323 " + allFds.userData[userNbr].nickname + " :End of LIST\r\n";
-	cmd_reply(allFds, allFds.userData[userNbr].fd, msg);
-}

srcs/commands/channel/notice.cpp

@@ -6,12 +6,20 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/14 21:24:55 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/14 02:15:04 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:09:53 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "../../../includes/ft_irc.hpp"
 
+// Commande: PRIVMSG
+// Paramètres: <destinataire>{,<destinataire>} <texte à envoyer >
+//    ERR_NORECIPIENT                 ERR_NOTEXTTOSEND +
+//    ERR_CANNOTSENDTOCHAN            ERR_NOTOPLEVEL 
+//    ERR_WILDTOPLEVEL                ERR_TOOMANYTARGETS
+//    ERR_NOSUCHNICK +
+//    RPL_AWAY
+
 void send_notice_msg(fdList &allFds, std::string msg, std::string dest, int userNbr)
 {
 	int pos;
@@ -20,27 +28,25 @@ void send_notice_msg(fdList &allFds, std::string msg, std::string dest, int user
 	fullMsg = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName + "@172.17.0.1 " + msg + "\r\n";
 	if (dest[0] == '&' || dest[0] == '#')
 	{	
-		pos = find_channel(allFds, dest);
+		if (is_joined(allFds, dest, userNbr) == -1)
-		if (pos == -1)
 			return ;
-		if (allFds.channelList[pos].mode.n && is_joined(allFds, dest, userNbr) == -1  )
+		if ((pos = find_channel(allFds, dest)) == -1)
-			return ;
-		if (allFds.channelList[pos].mode.m && !allFds.userData[userNbr].op 
-				&& !is_chan_op(allFds, &allFds.channelList[pos], userNbr) 
-				&& find_client_list(allFds.channelList[pos].verboseList, &allFds.userData[userNbr]) == -1)
 			return ;
 		for (size_t i = 0; i < allFds.channelList[pos].userList.size(); i++)
 		{
-			if (&allFds.userData[userNbr] != allFds.channelList[pos].userList[i] && allFds.channelList[pos].userList[i]->mode.s)
+			//std::cout << "send nickname " << allFds.channelList[pos].userList[i]->nickname << std::endl;
+			if (i != (size_t)userNbr)
 				send(allFds.channelList[pos].userList[i]->fd, fullMsg.c_str(), fullMsg.size(), 0);
+			//std::cout << "loop here\n";
 		}
 		return ;
 	}
-	pos = find_user(allFds, dest);
+	pos = find_user(allFds, dest); //return direct user fd
-	if (pos == -1)
+	if (pos != -1)
-		return ;
+	{
-	if (allFds.userData[pos].mode.s)
 		send(allFds.userData[pos].fd, fullMsg.c_str(), fullMsg.size(), 0);
+		return ;
+	}
 }
 
 void NOTICE(std::string buffer, fdList &allFds, int userNbr)
@@ -48,15 +54,17 @@ void NOTICE(std::string buffer, fdList &allFds, int userNbr)
 	std::vector<std::string> splitBuff;
 	std::string msg;
 	
-	if (!allFds.userData[userNbr].registered) 
+	//std::cout << "notice bufer= --" << buffer << std::endl;
-		return ;
 	split(buffer, ' ', splitBuff);
 	if (splitBuff.size() < 2)
 		return ;
 	if (splitBuff.size() < 3)
 		return ;
+
+	std::cout << "notice =" << msg << std::endl;
 	std::vector<std::string> dest;
 	split(splitBuff[1], ',', dest);
 	for (size_t i = 0; i < dest.size(); i++)
 		send_notice_msg(allFds, buffer, dest[i], userNbr);
 }
+

srcs/commands/channel/part.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/19 22:10:07 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:32:06 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:23:22 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -27,20 +27,40 @@ void leave_chan(fdList &allFds, std::string chan, int userNbr, std::string msg)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "422 " + allFds.userData[userNbr].nickname + " " + chan + " :You're not on that channel\r\n");
 		return ;
 	}
+	//del_user_in_chan(&allFds.userData[userNbr], &allFds.channelList[chanPos]);
 	int pos = find_client_list(allFds.channelList[chanPos].userList, &allFds.userData[userNbr]);
 	allFds.channelList[chanPos].userList.erase(allFds.channelList[chanPos].userList.begin() + pos);
+	//allFds.channelList[chanPos].size()--;
 	del_chan_in_user(&allFds.userData[userNbr], &allFds.channelList[chanPos]);
+	//:WiZ!jto@tolsun.oulu.fi PART #playzone :I lost
+	//:awd!kinou@kinou PART #test
+	//reply = ":" + allFds.userData[userNbr].nickname + "!" + 
+	
+	//reply = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName + "@" + allFds.userData[userNbr].ip + " PART " + allFds.channelList[chanPos].name;
+	//reply = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName + "@" + allFds.userData[userNbr].ip + " PART :" + allFds.channelList[chanPos].name + "\n";
 	reply = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName + "@" + allFds.userData[userNbr].ip;
 	if (!msg.empty())
 		reply += " PART " + allFds.channelList[chanPos].name + " " + msg + "\r\n";
 	else
 		reply += " PART :" + allFds.channelList[chanPos].name + "\r\n";
+
+	//:awd!kinou@172.17.0.1 PART :#test tcpdump
+	//:awd!kinou@127.0.0.1 PART :#test
+	//(void )msg;
+	//	reply += " " + msg;
+	//else
+	//	reply += "\n";
+	//std::cout << "leave msg=" << reply << std::endl;
 	send(allFds.userData[userNbr].fd, reply.c_str(), reply.size(), 0);
+	//allFds.channelList[chanPos].size()--;
 	for (size_t i = 0; i < allFds.channelList[chanPos].userList.size(); i++)
 	{
 		if (allFds.channelList[chanPos].userList[i]->mode.s)
 			send(allFds.channelList[chanPos].userList[i]->fd, reply.c_str(), reply.size(), 0);
+		//std::cout << "loop here\n";
 	}
+	
+	//cmd_reply(allFds, allFds.userData[userNbr].fd, reply + "\n");
 }
 
 void	PART(std::string buffer, fdList &allFds, int userNbr)

srcs/commands/channel/privmsg.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/11 08:53:03 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:32:35 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:11:34 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -30,6 +30,7 @@ void PRIVMSG(std::string buffer, fdList &allFds, int userNbr)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "451 " + allFds.userData[userNbr].nickname + " PRIVMSG :You have not registered\r\n");
 		return ;
 	}
+	//std::cout << "privmsg bufer= --" << buffer << std::endl;
 	split(buffer, ' ', splitBuff);
 	if (splitBuff.size() < 2)
 	{
@@ -41,6 +42,7 @@ void PRIVMSG(std::string buffer, fdList &allFds, int userNbr)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "412 " + allFds.userData[userNbr].nickname + " PRIVMSG :No text to send\r\n");
 		return ;
 	}
+	//std::cout << "privmsg =" << msg << std::endl;
 	std::vector<std::string> dest;
 	split(splitBuff[1], ',', dest);
 	for (size_t i = 0; i < dest.size(); i++)
@@ -66,6 +68,10 @@ void send_msg(fdList &allFds, std::string msg, std::string dest, int userNbr)
 			cmd_error(allFds, allFds.userData[userNbr].fd, "442 " + allFds.userData[userNbr].nickname + " PRIVMSG " + dest + " :You're not on that channel\r\n");
 			return ;
 		}
+		// if (find_client_list(allFds.channelList[pos].verboseList, &allFds.userData[userNbr]) != -1)
+		// {
+		// 	allFds.channelList[pos].verboseList.erase();
+		// }
 		if (allFds.channelList[pos].mode.m && !allFds.userData[userNbr].op 
 			&& !is_chan_op(allFds, &allFds.channelList[pos], userNbr) 
 			&& find_client_list(allFds.channelList[pos].verboseList, &allFds.userData[userNbr]) == -1)
@@ -75,12 +81,19 @@ void send_msg(fdList &allFds, std::string msg, std::string dest, int userNbr)
 		}
 		for (size_t i = 0; i < allFds.channelList[pos].userList.size(); i++)
 		{
+			//std::cout << "send nickname " << allFds.channelList[pos].userList[i]->nickname << std::endl;
+			
 			if (&allFds.userData[userNbr] != allFds.channelList[pos].userList[i] && allFds.channelList[pos].userList[i]->mode.s)
+			{
+				//std::cout << "send msg to user nbr" << i << std::endl;
 				send(allFds.channelList[pos].userList[i]->fd, fullMsg.c_str(), fullMsg.size(), 0);
+			}
+			//std::cout << "loop here\n";
 		}
 		return ;
 	}
-	pos = find_user(allFds, dest);
+	pos = find_user(allFds, dest); //return direct user fd
+	//std::cout << "pos of user = " << pos << std::endl;
 	if (pos == -1)
 	{
 		cmd_error(allFds, allFds.userData[userNbr].fd, "401 " + allFds.userData[userNbr].nickname + " PRIVMSG " + dest + " :No such nick\r\n");
@@ -88,4 +101,6 @@ void send_msg(fdList &allFds, std::string msg, std::string dest, int userNbr)
 	}
 	if (allFds.userData[pos].mode.s)
 		send(allFds.userData[pos].fd, fullMsg.c_str(), fullMsg.size(), 0);
+	//std::cout << "msg send\n";
+	//std::cout << "msg = " << fullMsg << std::endl;
 }

srcs/commands/channel_op/invite.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/11 19:19:56 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:32:44 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:24:11 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -54,6 +54,11 @@ void	INVITE(std::string buffer, fdList &allFds, int userNbr)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "443 " + allFds.userData[userNbr].nickname + " " + splitBuff[1] + " " + splitBuff[2] + " :is already on channel\r\n");
 		return ;
 	}
+	// if (is_joined(allFds, splitBuff[2], invitedNbr) != -1)
+	// {
+	// 	cmd_error(allFds, allFds.userData[userNbr].fd, "443 " + allFds.userData[userNbr].nickname + " " + splitBuff[1] + " " + splitBuff[2] + " :is already on channel\n");
+	// 	return ;
+	// }
 	if ((chanNbr = find_channel(allFds, splitBuff[2])) != -1)
 	{
 		chan = allFds.channelList[chanNbr];
@@ -67,6 +72,8 @@ void	INVITE(std::string buffer, fdList &allFds, int userNbr)
 		return ;
 	}
 	std::cout << "invite him !!!!" << splitBuff[1] << " to " <<  splitBuff[2] << std::endl;
+	//RPL_INVITING
+	//RPL_AWAY
 	chan.invitedList.push_back(&allFds.userData[invitedNbr]);//set authorization to join
 	msg = "341 " + allFds.userData[userNbr].nickname + " " + chan.name + " " + splitBuff[1] + "\r\n";
 	cmd_reply(allFds, allFds.userData[userNbr].fd, msg);

srcs/commands/channel_op/kick.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/11 19:19:32 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:32:52 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:12:00 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -70,12 +70,22 @@ void	KICK(std::string buffer, fdList &allFds, int userNbr)
 	}
 	kickMsg = allFds.userData[userPos].nickname + " have been kicked by " + allFds.userData[userNbr].nickname + "\r\n";
 	PART("PART " + splitBuff[1] + " has been kicked by " + allFds.userData[userNbr].nickname, allFds, userPos);
+	//del_user_in_chan(&allFds.userData[userPos], &allFds.channelList[chanPos]);
+	//del_chan_in_user(&allFds.userData[userPos], &allFds.channelList[chanPos]);
 	std::cout << "kick msg---" << msg << "---" << std::endl;
 	send(allFds.userData[userPos].fd, msg.c_str(), msg.size(), 0);
+	//send_msg(allFds, msg, splitBuff[1], userNbr);
 	for (size_t i = 0; i < allFds.channelList[chanPos].userList.size(); i++)
 	{
 		if (allFds.channelList[chanPos].userList[i]->mode.s)
 			send(allFds.channelList[chanPos].userList[i]->fd, kickMsg.c_str(), kickMsg.size(), 0);
 	}
+	//cmd_reply(allFds, allFds.userData[userPos].fd, msg);
+	
+	// else if (!allFds.userData[userNbr].op)
+	// {
+	// 	cmd_error(allFds, allFds.userData[userNbr].fd, "482 " + allFds.userData[userNbr].nickname + " " + splitBuff[1] + " :You're not channel operator\n");
+	// 	return ;
+	// }
 	return ;
 }

srcs/commands/channel_op/mode.cpp

@@ -3,90 +3,70 @@
 /*                                                        :::      ::::::::   */
 /*   mode.cpp                                           :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
-/*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
+/*   By: sadjigui <sadjigui@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/02/11 19:19:30 by sadjigui          #+#    #+#             */
+/*   Created: 2023/02/11 19:19:30 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:35:17 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 21:50:12 by sadjigui         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "../../../includes/ft_irc.hpp"
 #include <sstream>
 
-//:kinou3!kinou@172.17.0.1 MODE #test +o :kinou1 
-//:kinou3!kinou@172.17.0.1 MODE #test :+p 
-//kinou3 = baseop
-//kinou1 = newOP
-
 void	chan_opt_o(fdList &allFds, int userNbr, std::vector<std::string> opt, int chanNbr, bool sign)
 {
+	(void)allFds;
+	(void)userNbr;
 	(void)chanNbr;
-	int pos;
 	
-	if (opt.size() < 4)
+	if (opt.size() != 4)
 	{
-		cmd_error(allFds, allFds.userData[userNbr].fd, "461 " + allFds.userData[userNbr].nickname + " MODE " + opt[0] + " :Not enough parameters\r\n");
+		std::cout << "ERR_NEEDMOREPARAMS" << std::endl;
 		return ;
 	}
 	if ((find_user(allFds, opt[3]) == -1))
 	{
-		cmd_error(allFds, allFds.userData[userNbr].fd, "401 " + allFds.userData[userNbr].nickname + " MODE " + opt[1] + " :No such nick\r\n");
+		std::cout << "User :" << opt[3] << " not found" << std::endl;
+		cmd_error(allFds, allFds.userData[userNbr].fd, "401 *" + opt[1] + " :No such nick/channel\n");
 		return ;
 	}
-	pos = find_client_list(allFds.channelList[chanNbr].opList, &allFds.userData[userNbr]) != -1;
+
-	if (pos == -1 && !allFds.userData[userNbr].op)
+	//A voir
-	{
+	if (allFds.userData[userNbr].mode.o == true && sign == true)
-		cmd_error(allFds, allFds.userData[userNbr].fd, "482 " + allFds.userData[userNbr].nickname + " MODE " + opt[1] + " :You're not channel operator\r\n");
+		allFds.userData[find_user(allFds, opt[3])].mode.o = (sign = true) ? true : false;
-		return ;
+	
-	}
+	std::cout << "-------> " << opt[3] << std::endl;
-	if (sign == false)
-		allFds.channelList[chanNbr].opList.erase(allFds.channelList[chanNbr].opList.begin() + pos);
-	else
-		allFds.channelList[chanNbr].opList.push_back(&allFds.userData[userNbr]);
-	chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "o", sign);
 }
 
-void	chan_opt_k(fdList &allFds, int userNbr, std::vector<std::string> opt, int chanNbr, bool sign)
+void	chan_opt_k(fdList &allFds, std::vector<std::string> opt, int chanNbr, bool sign)
 {
-	if (find_client_list(allFds.channelList[chanNbr].opList, &allFds.userData[userNbr]) == -1 && !allFds.userData[userNbr].op)
+	if (opt.size() != 4)
 	{
-		cmd_error(allFds, allFds.userData[userNbr].fd, "482 " + allFds.userData[userNbr].nickname + " MODE " + opt[1] + " :You're not channel operator\n");
+		std::cout << "ERR_NEEDMOREPARAMS" << std::endl;
-		return ;
+		std::cout << "how to use it :/MODE <channel >+k <password>" << std::endl;
-	}
-	if (opt.size() < 3)
-	{
-		cmd_error(allFds, allFds.userData[userNbr].fd, "461 " + allFds.userData[userNbr].nickname + " MODE " + opt[0] + " :Not enough parameters\n");
 		return ;
 	}
 	if (sign == true)
-	{
-		allFds.channelList[chanNbr].mode.k = 1;
 		allFds.channelList[chanNbr].password = opt[3];
-	}
-	else
-		allFds.channelList[chanNbr].mode.k = 0;
-	chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "k", sign);
 }
 
 void	chan_opt_v(fdList &allFds, int userNbr, std::vector<std::string> opt, int chanNbr, bool sign)
 {
-	if (find_client_list(allFds.channelList[chanNbr].opList, &allFds.userData[userNbr]) < 0)
+	(void)userNbr;
-	{
+	(void)chanNbr;
-		cmd_error(allFds, allFds.userData[userNbr].fd, "482 " + allFds.userData[userNbr].nickname + " MODE " + opt[1] + " :You're not channel operator\n");
+	(void)sign;
-		return ;
+	
-	}
 	if (opt.size() < 4)
 	{
 		std::cout << "ERR_NEEDMOREPARAMS" << std::endl;
 		std::cout << "how to use it :/MODE <channel> +/-v <user>" << std::endl;
-		cmd_error(allFds, allFds.userData[userNbr].fd, "461 " + allFds.userData[userNbr].nickname + " MODE " + opt[0] + " :Not enough parameters\n");
 		return ;
 	}
 	
 	int target = find_user(allFds, opt[3]);
 	if (target == -1)
 	{
-		cmd_error(allFds, allFds.userData[userNbr].fd, "401 " + allFds.userData[userNbr].nickname + " MODE " + opt[3] + " :No such nick\n");
+		cmd_error(allFds, allFds.userData[userNbr].fd, "401 *" + opt[3] + " :No such nick/channel\n");
 		return ;
 	}
 	
@@ -95,144 +75,146 @@ void	chan_opt_v(fdList &allFds, int userNbr, std::vector<std::string> opt, int c
 		allFds.channelList[chanNbr].verboseList.push_back(&allFds.userData[target]);
 	if (sign == false && pos != -1)
 		allFds.channelList[chanNbr].verboseList.erase(allFds.channelList[chanNbr].verboseList.begin() + pos);
-	chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "v", sign);
 }
 
 void	chan_opt_b(fdList &allFds, int userNbr, std::vector<std::string> opt, int chanNbr, bool sign)
 {
 	std::vector<clientData *> ban(allFds.channelList[chanNbr].banList);
-	std::vector<std::string> name;
+	(void)userNbr;
+	(void)opt;
+	(void)chanNbr;
+	(void)sign;
+	(void)ban;
 	int pos;
-	int target_in_client;
-	int target_in_ban;
 	
 	if (opt.size() == 3 && sign == true)
-		ban_reply(allFds.channelList[chanNbr], allFds.userData[userNbr]);
-	if (opt.size() >= 4)
 	{
-		if (find_client_list(allFds.channelList[chanNbr].opList, &allFds.userData[userNbr]) < 0)
+		if (ban.empty() == true)
 		{
-			cmd_error(allFds, allFds.userData[userNbr].fd, "482 " + allFds.userData[userNbr].nickname + " MODE " + opt[1] + " :You're not channel operator\n");
+			std::cout << "Nobody was banned on this channel" << std::endl;
 			return ;
 		}
-		split(opt[3], ',', name);
+		for (long unsigned int i = 0; i < ban.size(); i++)
-		
-		for (size_t i = 0; i < name.size(); i++)
 		{
-			target_in_client = find_user(allFds, name[i]);
+			std::cout << ban[i]->nickname << std::endl;
-			if (target_in_client == -1)
+		}
-			{
+		ban_reply(allFds.channelList[chanNbr], allFds.userData[userNbr]);
-				std::cout << "No user found" << std::endl;
-				cmd_error(allFds, allFds.userData[userNbr].fd, "401 " + allFds.userData[userNbr].nickname + " MODE " + name[i] + " :No such nick\n");
-			}
 
-			target_in_ban = find_client_list(allFds.channelList[chanNbr].banList, &allFds.userData[target_in_client]);
+	}
-			if (sign == true && target_in_ban == -1)
+	if (opt.size() >= 4)
-			{
+	{
-				if (find_client_list(allFds.channelList[chanNbr].opList, &allFds.userData[target_in_client]))
+		int target_in_client = find_user(allFds, opt[3]);
-				{
+		if (target_in_client == -1)
-					allFds.channelList[chanNbr].banList.push_back(&allFds.userData[target_in_client]);
+		{
-					std::cout << "call kick\n";
+			std::cout << "No user found" << std::endl;
-					KICK("/KICK " + allFds.channelList[chanNbr].name + " " + allFds.userData[target_in_client].nickname + " You have been banned from this channel", allFds, userNbr);
+			return ;
-					if ((pos = find_client_list(allFds.channelList[chanNbr].userList, &allFds.userData[target_in_client])) != -1)
+		}
-						allFds.channelList[chanNbr].userList.erase(allFds.channelList[chanNbr].userList.begin() + pos);
+		int target_in_ban = find_client_list(allFds.channelList[chanNbr].banList, &allFds.userData[target_in_client]);
-					if ((pos = find_client_list(allFds.channelList[chanNbr].opList, &allFds.userData[target_in_client])) != -1)
+		if (sign == true && target_in_ban == -1)
-						allFds.channelList[chanNbr].opList.erase(allFds.channelList[chanNbr].opList.begin() + pos);
+		{
-				}
+			allFds.channelList[chanNbr].banList.push_back(&allFds.userData[target_in_client]);
-				else
+			std::cout << "call kick\n";
-					cmd_error(allFds, allFds.userData[userNbr].fd, "482 " + allFds.userData[userNbr].nickname + " MODE " + opt[0] + " :You're not channel operator\n");
+			KICK("/KICK " + allFds.channelList[chanNbr].name + " " + allFds.userData[target_in_client].nickname + " You have been banned from this channel", allFds, userNbr);
-			}
+			if ((pos = find_client_list(allFds.channelList[chanNbr].userList, &allFds.userData[target_in_client])) != -1)
-			if (sign == false && target_in_ban != -1)
+				allFds.channelList[chanNbr].userList.erase(allFds.channelList[chanNbr].userList.begin() + pos);
-			{
+			if ((pos = find_client_list(allFds.channelList[chanNbr].opList, &allFds.userData[target_in_client])) != -1)
-				std::cout <<"target in bam == "<< allFds.channelList[chanNbr].banList[target_in_ban]->nickname << std::endl;
+				allFds.channelList[chanNbr].opList.erase(allFds.channelList[chanNbr].opList.begin() + pos);
-				allFds.channelList[chanNbr].banList.erase(allFds.channelList[chanNbr].banList.begin() + (target_in_ban));
+		}
-			}
+		if (sign == false && target_in_ban != -1)
-			std::cout << "counter" << std::endl;
+		{
+			std::cout <<"target in bam == "<< allFds.channelList[chanNbr].banList[target_in_ban]->nickname << std::endl;
+			allFds.channelList[chanNbr].banList.erase(allFds.channelList[chanNbr].banList.begin() + (target_in_ban));
 		}
 	}
-	chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "b", sign);
-	return ;
 }
 
 void do_chan_opt(fdList &allFds, int userNbr, std::vector<std::string> opt, int chanNbr /*, channel (string or direct reference or pointer but no copy)*/)
 {
+	(void)allFds;
+	(void)userNbr;
 	bool sign = true;
 
+	// if (allFds.userData[userNbr].mode.o == false)
+	// {
+	// 	return ;
+	// }
 	if (opt[2][0] == '-')
 		sign = false;
 	for (int i = 1; opt[2][i]; i++)
 	{
 		switch (opt[2][i])
 		{
-			case 'o': chan_opt_o(allFds, userNbr, opt, chanNbr, sign);
+			case 'o': chan_opt_o(allFds, userNbr, opt, chanNbr, sign); //std::cout << "launching option: " << opt[2][i] << std::endl;
 				break ;
-			case 'p': allFds.channelList[chanNbr].mode.p = (sign == true) ? true : false;
+			case 'p': allFds.channelList[chanNbr].mode.p = (sign = true) ? true : false;
-				chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "p", sign);
 				break ;
-			case 's': allFds.channelList[chanNbr].mode.s = (sign == true) ? true : false;
+			case 's': allFds.channelList[chanNbr].mode.s = (sign = true) ? true : false;
-				chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "s", sign);
 				break ;
-			case 'i': allFds.channelList[chanNbr].mode.i = (sign == true) ? true : false;
+			case 'i': allFds.channelList[chanNbr].mode.i = (sign = true) ? true : false;
-				chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "i", sign);
 				break ;
-			case 't': allFds.channelList[chanNbr].mode.t = (sign == true) ? true : false;
+			case 't': allFds.channelList[chanNbr].mode.t = (sign = true) ? true : false;
-				chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "t", sign);
 				break ;
-			case 'n': allFds.channelList[chanNbr].mode.n = (sign == true) ? true : false;
+			case 'n': allFds.channelList[chanNbr].mode.n = (sign = true) ? true : false;
-				chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "n", sign);
 				break ;
-			case 'm': allFds.channelList[chanNbr].mode.m = (sign == true) ? true : false;
+			case 'm': allFds.channelList[chanNbr].mode.m = (sign = true) ? true : false;
-				chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "m", sign);
 				break ;
 			case 'l':
 				if (sign == true)
 					str_to_int(allFds.channelList[chanNbr].maxUser, opt[3]);
-				chan_mode_reply(allFds, allFds.channelList[chanNbr], userNbr, "l", sign);
 				break ;
 			case 'b': chan_opt_b(allFds, userNbr, opt, chanNbr, sign);
 				break ;
 			case 'v': chan_opt_v(allFds, userNbr, opt, chanNbr, sign);
 				break ;
-			case 'k': chan_opt_k(allFds, userNbr, opt, chanNbr, sign);
+			case 'k': chan_opt_k(allFds, opt, chanNbr, sign);
 				break ;
 			default : std::cout << "Not launching option" << std::endl;
 				break ;	
 		}
+		//mode_i()
+		//call option 
+		//switch ? if forest? map container ? 2 tab (name and function pointer) ?
+		// opt_i(int signe (+ ou -), channel, user);
 	}
 	return;
 }
 
 void	do_user_opt(fdList &allFds, int userNbr, std::vector<std::string> opt, int new_target)
 {
+	(void)allFds;
+	(void)userNbr;
+	(void)new_target;
+	//char opts[4] = {'i', 's', 'w', 'o'};
 	bool sign = true;
-	
 	if (allFds.userData[userNbr].nickname != opt[1])
 	{
-		cmd_error(allFds, allFds.userData[userNbr].fd, "502 " + allFds.userData[userNbr].nickname + " MODE " + opt[1] + " :Cant change mode for other users\r\n");
+		std::cout << "not the same user ! don't try to change someone else MODE you stupid bitch\n";
+		cmd_error(allFds, allFds.userData[userNbr].fd, "502 *" + opt[1] + " :Cant change mode for other users\n");
 		return ;
 	}
 	if (opt[2][0] == '-')
-	{
-		std::cout << "sign = false\n";
 		sign = false;
-	}
 	for (int i = 1; opt[2][i]; i++)
 	{
 		switch(opt[2][i])
 		{
-			case 'i': allFds.userData[new_target].mode.i = (sign == true) ? true : false;
+			case 'i': allFds.userData[new_target].mode.i = (sign = true) ? true : false;
-				user_mode_reply(allFds, allFds.userData[new_target]/*clientData &user*/, userNbr, "i");
 				break ;
-			case 's': allFds.userData[new_target].mode.s = (sign == true) ? true : false;
+			case 's': allFds.userData[new_target].mode.s = (sign = true) ? true : false;
 				break ;
-			case 'w': allFds.userData[new_target].mode.w = (sign == true) ? true : false;
+			case 'w': allFds.userData[new_target].mode.w = (sign = true) ? true : false;
 				break ;
 			case 'o':
 				if (sign == true)
 					return ;
-				allFds.userData[new_target].mode.o = (sign == true) ? true : false;
+				if (allFds.userData[userNbr].mode.o == false) 
+				{
+					cmd_error(allFds, allFds.userData[userNbr].fd, "482 *" + opt[1] + " :You're not channel operator\n");
+					return ;
+				}
+				allFds.userData[new_target].mode.o = (sign = true) ? true : false;
 				break ;
-			default:
+			default: std::cout << "Default" << std::endl;
 				break ;
 		}
 	}
@@ -241,61 +223,57 @@ void	do_user_opt(fdList &allFds, int userNbr, std::vector<std::string> opt, int
 
 void	MODE(std::string buffer, fdList &allFds, int userNbr)
 {
+	(void)userNbr;
 	std::vector<std::string> splitBuff;
 	int pos;
-
 	split(buffer, ' ', splitBuff);
-	if (splitBuff.size() < 2)
+	if (splitBuff.size() < 3) 
 	{
-		cmd_error(allFds, allFds.userData[userNbr].fd, "461 " + allFds.userData[userNbr].nickname + " MODE " + splitBuff[0] + " :Not enough parameters\n");
+		cmd_error(allFds, allFds.userData[userNbr].fd, "461 *" + splitBuff[0] + " :Not enough parameters\n");
 		return ;
 	}
-	if (splitBuff[1][0] == '#' || splitBuff[1][0] == '&')
+	if (splitBuff[1][0] == '#' || splitBuff[1][0] == '&') //splitbuff[1] always equal to <channel> or <nickname>
 	{
-		if ((pos = find_channel(allFds, splitBuff[1])) == -1)
+		if ((pos = find_channel(allFds, splitBuff[1])) == -1) //if true chan doesn't exist
 		{
 			std::cout << splitBuff[1] << ": No such channel" << std::endl;
-			cmd_error(allFds, allFds.userData[userNbr].fd, "403 " + allFds.userData[userNbr].nickname + " MODE " + splitBuff[1] + " :No such channel\n");
+			cmd_error(allFds, allFds.userData[userNbr].fd, "403 *" + splitBuff[1] + " :No such channel\n");
+			return ;
+		}//else
+		//verify_option(allFds, str, i); //needed?
+
+		// std::cout << "splitbuff[2] = " << splitBuff[2] << std::endl;
+		
+		search_and_erase(splitBuff[2], "opsitnmlbvk");
+		// std::cout << "splitbuff[2] after = " << splitBuff[2] << std::endl;
+		if ((splitBuff[2].size() < 2) || (splitBuff[2][0] != '-' && splitBuff[2][0] != '+'))
+		{
+			std::cout << "Bad params" << std::endl;
 			return ;
 		}
-		if (splitBuff.size() > 2)
+		do_chan_opt(allFds, userNbr, splitBuff, pos);
-		{
+		chan_reply(allFds.channelList[pos], allFds.userData[userNbr]);
-			search_and_erase(splitBuff[2], "opsitnmlbvk");
+		//do_option one by one here (do_chan_opt)?
-			if ((splitBuff[2].size() < 2) || (splitBuff[2][0] != '-' && splitBuff[2][0] != '+'))
-			{
-				if (splitBuff[2].size() > 2)
-				{
-					if (splitBuff[2] == "b")
-						ban_reply(allFds.channelList[pos], allFds.userData[userNbr]);
-				}		
-				std::cout << "Bad params" << std::endl;
-				return ;
-			}
-			do_chan_opt(allFds, userNbr, splitBuff, pos);
-		}
-		else
-			chan_reply(allFds.channelList[pos], allFds.userData[userNbr]);
 		return ;
 	}
+	// pos = find_user(allFds, splitBuff[1]);
 	else if ((pos = find_user(allFds, splitBuff[1]))  == -1)
 	{
 		std::cout << "user doesn't exist" << std::endl;
-		cmd_error(allFds, allFds.userData[userNbr].fd, "401 " + allFds.userData[userNbr].nickname + " MODE " + splitBuff[1] + " :No such nick\n");
+		cmd_error(allFds, allFds.userData[userNbr].fd, "401 *" + splitBuff[1] + " :No such nick/channel\n");
 		return ;
 	}
 	else
 	{
-		if (splitBuff.size() > 2)
+		search_and_erase(splitBuff[2], "iswo");
+		if ((splitBuff[2].size() < 2) && (splitBuff[2][0] != '-' || splitBuff[2][0] != '+'))
 		{
-			search_and_erase(splitBuff[2], "iswo");
+			cmd_error(allFds, allFds.userData[userNbr].fd, "461 *" + splitBuff[0] + " :Not enough parameters\n");
-			if ((splitBuff[2].size() < 2) && (splitBuff[2][0] != '-' || splitBuff[2][0] != '+'))
+			return ;
-			{
-				cmd_error(allFds, allFds.userData[userNbr].fd, "461 " + allFds.userData[userNbr].nickname + " MODE " + splitBuff[0] + " :Not enough parameters\n");
-				return ;
-			}
-			do_user_opt(allFds, userNbr, splitBuff, pos);
 		}
-		else 
+		do_user_opt(allFds, userNbr, splitBuff, pos);
-			user_reply(allFds.userData[userNbr]);
+		user_reply(allFds.userData[userNbr]);
 	}
+	//do_option one by one here (do_user_opt)?
+	
 }

srcs/commands/channel_op/topic.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/11 19:19:52 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:35:41 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:25:05 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -18,6 +18,7 @@ void	TOPIC(std::string buffer, fdList &allFds, int userNbr)
 	int chanNbr;
 	std::vector<std::string> splitBuff;
 	
+	std::cout << "topic im here1\n";//RPL_NOTOPIC //RPL_TOPIC
 	if (!allFds.userData[userNbr].registered) 
 	{
 		cmd_error(allFds, allFds.userData[userNbr].fd, "451 " + allFds.userData[userNbr].nickname + " TOPIC :You have not registered\r\n");
@@ -43,6 +44,12 @@ void	TOPIC(std::string buffer, fdList &allFds, int userNbr)
 			return ;
 		}
 	}
+	// else if (!allFds.userData[userNbr].op && !allFds.userData[userNbr].op)
+	// {
+	// 	cmd_error(allFds, allFds.userData[userNbr].fd, "482 " + allFds.userData[userNbr].nickname + " " + splitBuff[1] + " :You're not channel operator\n");
+	// 	return ;
+	// }
+	std::cout << "topic im here2\n";//RPL_NOTOPIC //RPL_TOPIC
 	if (splitBuff.size() < 3)
 	{
 		if (!allFds.channelList[chanNbr].topic.empty())
@@ -50,12 +57,14 @@ void	TOPIC(std::string buffer, fdList &allFds, int userNbr)
 		else
 			cmd_error(allFds, allFds.userData[userNbr].fd, "331 TOPIC " + splitBuff[1] + " :No topic is set\r\n");
 		return;
+		//std::cout << "PRINT TOPIC here\n";//RPL_NOTOPIC //RPL_TOPIC
 	}
 	else
 	{
 		allFds.channelList[chanNbr].topic = buffer.substr(6 + splitBuff[1].size() + 2, std::string::npos);
-		for (size_t i = 0; i < allFds.channelList[chanNbr].userList.size(); i++)
+		//std::cout << "topic= " << allFds.channelList[chanNbr].topic << std::endl;
-			cmd_reply(allFds, allFds.channelList[chanNbr].userList[i]->fd, "332 TOPIC " + splitBuff[1] + " :" + allFds.channelList[chanNbr].topic + "\r\n");
+		cmd_reply(allFds, allFds.userData[userNbr].fd, "332 TOPIC " + splitBuff[1] + " :" + allFds.channelList[chanNbr].topic + "\r\n");
+		//std::cout << "PRINT TOPIC here topic set\n";//RPL_NOTOPIC //RPL_TOPIC
 	}
 	return ;
 }

srcs/commands/channel_op/utils_mode.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/03/09 00:13:32 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:36:06 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:03:03 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -22,8 +22,7 @@ void ban_reply(channelData &chan, clientData &user)
 		fullReply = reply + chan.banList[i]->nickname + "!" + chan.banList[i]->userName + "@" + chan.banList[i]->hostName + "\r\n";
 		send(user.fd, fullReply.c_str(), fullReply.size(), 0);
 	}
-	//:irc.local 368 kinou3 #test :End of channel ban list 
+	endReply = ":irc.local 367 " + user.nickname + " " + chan.name + " :End of channel ban list\r\n";
-	endReply = ":irc.local 368 " + user.nickname + " " + chan.name + " :End of channel ban list\r\n";
 	send(user.fd, endReply.c_str(), endReply.size(), 0);
 }
 
@@ -33,8 +32,7 @@ void chan_reply(channelData &chan, clientData &user)
 	(void) chan;
 	//int mode;
 	//std::string reply = " +";
-	//:irc.local 324 kinou3 #test :+nt
+	std::string reply = ":irc.local 324 " + user.nickname + " " + chan.name + " +";
-	std::string reply = ":irc.local 324 " + user.nickname + " " + chan.name + " :+";
 	if (chan.mode.p)
 		reply += 'p';
 	if (chan.mode.s)
@@ -62,59 +60,13 @@ void chan_reply(channelData &chan, clientData &user)
 	//return (reply);
 }
 
-void chan_mode_reply(fdList &allFds, channelData &chan, int userNbr, std::string mode, int sign)
-{
-	std::string reply;
-	std::string base_reply = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName
-		+ "@" + allFds.userData[userNbr].ip + " MODE " + chan.name;// + " :+" + mode + "\r\n";
-
-	if (sign && contain_any(mode, "olbvk"))
-	{
-		reply += " +";
-		if (mode == "o")
-			reply += mode + " :" + chan.opList.back()->nickname;
-		else if (mode == "l")
-			reply += mode + " :" + int_to_str(chan.maxUser);
-		else if (mode == "b")
-			reply += mode + " :" + chan.banList.back()->nickname;
-		else if (mode == "v")
-			reply += mode + " :" + chan.verboseList.back()->nickname;
-		else if (mode == "k")
-			reply += mode + " :" + chan.password;
-	}
-	else if (contain_any(mode, "obv"))
-	{
-		if (mode == "o")
-			reply += " -" + mode + " :" + chan.verboseList.back()->nickname;
-		else if (mode == "b")
-			reply += " -" + mode + " :" + chan.verboseList.back()->nickname;
-		else if (mode == "v")
-			reply += " -" + mode + " :" + chan.verboseList.back()->nickname;
-	}
-	else if (sign)
-			reply += " :+" + mode;
-	else
-		reply += " :-" + mode;
-	reply = base_reply + reply;
-	reply += "\r\n";
-	std::cout << "reply=" << reply << std::endl;
-	for (size_t i = 0; i < chan.userList.size(); i++)
-	{
-		std::cout << "i=" << i << std::endl;
-		send(chan.userList[i]->fd, reply.c_str(), reply.size(), 0);
-	}
-}
-
-void user_mode_reply(fdList &allFds, clientData &user, int userNbr, std::string mode)
-{
-	std::string reply = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName
-		+ "@" + allFds.userData[userNbr].ip + " MODE " + user.nickname + " :+" + mode + "\r\n";
-	send(allFds.userData[userNbr].fd, reply.c_str(), reply.size(), 0);
-}
-
 void user_reply(clientData &user)
 {
-	std::string reply = ":irc.local 221 " + user.nickname + " +";
+	//:irc.server.com 221 ClientName +ix
+
+	//std::string reply;
+	std::string reply = " +";
+	std::string reply_begin = ":irc.local 221 " + user.nickname + " +";
 	if (user.mode.i)
 		reply += 'i';
 	if (user.mode.s)
@@ -124,12 +76,12 @@ void user_reply(clientData &user)
 	if (user.mode.o)
 		reply += 'o';
 	reply += "\r\n";
-	std::cout << reply;
 	send(user.fd, reply.c_str(), reply.size(), 0);	
 }
 
 int search_and_erase(std::string &str, std::string toFind)
 {
+	// std::vector<string>::iterator i = str.begin;
 	int i = 1; //1 instead of 0 to skip +/-
 	while (str[i] != 0)
 	{

srcs/commands/cmd_utils.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/10 15:46:10 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:38:37 by apommier         ###   ########.fr       */
+/*   Updated: 2023/02/13 18:22:37 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -29,14 +29,10 @@ void split_but_keep(std::string const &str, const char delim, std::vector<std::s
     size_t start;
     size_t end = 0;
  
-	if (str.find_first_of(delim, end) == std::string::npos)
-	{
-		out.push_back(str);
-		return ;
-	}
     while ((start = str.find_first_not_of(delim, end)) != std::string::npos)
     {
-        end = str.find(delim, start);
+        end = str.find(delim, start); //find end of string
-        out.push_back(str.substr(start, end + 1 - start));
+        out.push_back(str.substr(start, end + 1 - start)); //here
+		//std::cout << "split test = ---" << str.substr(start, end + 1 - start) << "---\n";
     }
 }

srcs/commands/not_done_cmd.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/09 22:04:11 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/14 02:11:01 by apommier         ###   ########.fr       */
+/*   Updated: 2023/02/19 22:11:59 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,16 +14,39 @@
 
 void	SERVER(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
 	return ;
 }
 
+// void	OPER(std::string buffer, fdList &allFds, int userNbr)
+// {
+// 	(void)buffer; 
+// 	(void)allFds;
+// 	(void)userNbr;
+// 	return ;
+// }
+
+
+
+
+
+
+void	LIST(std::string buffer, fdList &allFds, int userNbr)
+{
+	(void)buffer; 
+	(void)allFds;
+	(void)userNbr;
+	return ;
+}
+
+
+
+
+
 void	VERSION(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -32,7 +55,6 @@ void	VERSION(std::string buffer, fdList &allFds, int userNbr)
 
 void	STATS(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -41,7 +63,6 @@ void	STATS(std::string buffer, fdList &allFds, int userNbr)
 
 void	LINKS(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -50,7 +71,6 @@ void	LINKS(std::string buffer, fdList &allFds, int userNbr)
 
 void	TIME(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -59,7 +79,6 @@ void	TIME(std::string buffer, fdList &allFds, int userNbr)
 
 void	CONNECT(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -68,7 +87,6 @@ void	CONNECT(std::string buffer, fdList &allFds, int userNbr)
 
 void	TRACE(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -77,7 +95,6 @@ void	TRACE(std::string buffer, fdList &allFds, int userNbr)
 
 void	ADMIN(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -86,16 +103,32 @@ void	ADMIN(std::string buffer, fdList &allFds, int userNbr)
 
 void	INFO(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
 	return ;
 }
 
+// void	PRIVMSG(std::string buffer, fdList &allFds, int userNbr)
+// {
+// 	(void)buffer; 
+// 	(void)allFds;
+// 	(void)userNbr;
+// 	return ;
+// }
+
+// void	NOTICE(std::string buffer, fdList &allFds, int userNbr)
+// {
+// 	(void)buffer; 
+// 	(void)allFds;
+// 	(void)userNbr;
+// 	return ;
+// }
+
+
+
 void	WHOIS(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -104,16 +137,26 @@ void	WHOIS(std::string buffer, fdList &allFds, int userNbr)
 
 void	WHOWAS(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
 	return ;
 }
 
+
+
+// void	PING(std::string buffer, fdList &allFds, int userNbr)
+// {
+// 	(void)buffer; 
+// 	(void)allFds;
+// 	(void)userNbr;
+// 	return ;
+// }
+
+
+
 void	ERROR(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -122,7 +165,6 @@ void	ERROR(std::string buffer, fdList &allFds, int userNbr)
 
 void	AWAY(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -131,7 +173,6 @@ void	AWAY(std::string buffer, fdList &allFds, int userNbr)
 
 void	REHASH(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -140,7 +181,6 @@ void	REHASH(std::string buffer, fdList &allFds, int userNbr)
 
 void	RESTART(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -149,7 +189,6 @@ void	RESTART(std::string buffer, fdList &allFds, int userNbr)
 
 void	SUMMON(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -158,7 +197,6 @@ void	SUMMON(std::string buffer, fdList &allFds, int userNbr)
 
 void	OPERWALL(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -167,7 +205,6 @@ void	OPERWALL(std::string buffer, fdList &allFds, int userNbr)
 
 void	USERHOST(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;
@@ -176,7 +213,6 @@ void	USERHOST(std::string buffer, fdList &allFds, int userNbr)
 
 void	ISON(std::string buffer, fdList &allFds, int userNbr)
 {
-	std::cout << "command not supported\n";
 	(void)buffer; 
 	(void)allFds;
 	(void)userNbr;

srcs/commands/operator/kill.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/15 16:34:57 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:36:13 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:14:02 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -44,6 +44,7 @@ void	KILL(std::string buffer, fdList &allFds, int userNbr)
 	msg = "connection killed by " + allFds.userData[userNbr].nickname + " " + buffer.substr(buffer.find_first_of(':'), std::string::npos);
 	fullMsg = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName + "@172.17.0.1 " + msg + "\r\n";
 	send(allFds.userData[pos].fd, fullMsg.c_str(), fullMsg.size(), 0);
+	//send_notice_msg(allFds, allFds.userData[userNbr].fd, userNbr)
 	delete_user(allFds, pos);
 	return ;
 }

srcs/commands/operator/oper.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/11 19:04:47 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:36:20 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:14:14 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -28,6 +28,7 @@ void	OPER(std::string buffer, fdList &allFds, int userNbr)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "461 " + allFds.userData[userNbr].nickname + " OPER :Not enough parameters\r\n");
 		return ;
 	}
+	//:irc.local 491 kinou2 
 	if (splitBuff[1] != OP_NAME)
 	{
 		cmd_error(allFds, allFds.userData[userNbr].fd, "491 " + allFds.userData[userNbr].nickname + " :Invalid oper credentials\r\n");
@@ -38,8 +39,14 @@ void	OPER(std::string buffer, fdList &allFds, int userNbr)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "464 " + allFds.userData[userNbr].nickname + " :Password incorrect\r\n");
 		return ;
 	}
+	// pos = find_user(allFds, splitBuff[1]);
+	// if (pos != -1)
+	// {
+	// 	cmd_error(allFds, allFds.userData[userNbr].fd, "401 " + allFds.userData[userNbr].nickname + " SQUIT " + splitBuff[1] + " :No such nick/channel\n");
+	// 	return ;
+	// }
 	allFds.userData[userNbr].op = 1;
-	allFds.userData[userNbr].mode.o = 1;
+	allFds.userData[userNbr].mode.s = 1;
 	msg = "381 " + allFds.userData[userNbr].nickname + " " + allFds.userData[userNbr].nickname + " :You are now an IRC operator\r\n";
 	send(allFds.userData[userNbr].fd, msg.c_str(), msg.size(), 0);
 }

srcs/commands/operator/squit.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/11 19:11:03 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:36:38 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:15:48 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,6 +16,10 @@
 
 void	SQUIT(std::string buffer, fdList &allFds, int userNbr)
 {
+	// (void)buffer; 
+	// (void)allFds;
+	// (void)userNbr;
+	std::cout << "squit | server end\n";
 	std::vector<std::string> splitBuff;
 	split(buffer, ' ', splitBuff);
 
@@ -34,6 +38,7 @@ void	SQUIT(std::string buffer, fdList &allFds, int userNbr)
 		cmd_error(allFds, allFds.userData[userNbr].fd, "481 " + allFds.userData[userNbr].nickname + " :Permission Denied- You're not an IRC operator\r\n");
 		return ;
 	}
+	std::cout << "squit serv= " << splitBuff[2] << std::endl;
 	if (splitBuff[1] != "irc.local")
 	{
 		cmd_error(allFds, allFds.userData[userNbr].fd, "402 " + allFds.userData[userNbr].nickname + " " + splitBuff[2] + " :No such server\r\n");
@@ -43,6 +48,7 @@ void	SQUIT(std::string buffer, fdList &allFds, int userNbr)
 	for (int pos = 0; pos < allFds.nbrUser; pos++)
 	{
 		fullMsg = ":irc.local NOTICE " + allFds.userData[pos].userName + "." + allFds.userData[pos].nickname + " :*** You have been disconnected from the server\r\n";
+		//fullMsg = ":" + allFds.userData[pos].nickname + "!" +  + "@" + allFds.userData[pos].ip + " QUIT :Server shutdown\n";
 		send(allFds.userData[pos].fd, fullMsg.c_str(), fullMsg.size(), 0);
 		if (close(allFds.userData[pos].fd) != 0)
 			ft_error("close() error");
@@ -53,5 +59,12 @@ void	SQUIT(std::string buffer, fdList &allFds, int userNbr)
 	if (close(allFds.epollFd) != 0)
 		ft_error("close() error");
 	allFds.alive = 0;
+	// if (allFds.userData[userNbr].op)
+	// 	allFds.alive = 0;
+	// else
+	// {
+	// 	std::cout << "Not op but okay i'll do it\n";
+	// 	allFds.alive = 0;
+	// }
 	return ;
 }

srcs/commands/operator/wallops.cpp

@@ -3,10 +3,10 @@
 /*                                                        :::      ::::::::   */
 /*   wallops.cpp                                        :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
-/*   By: sadjigui <sadjigui@student.42.fr>          +#+  +:+       +#+        */
+/*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/16 17:09:38 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/14 12:30:48 by sadjigui         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:16:06 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -18,6 +18,7 @@ void	WALLOPS(std::string buffer, fdList &allFds, int userNbr)
 	std::vector<std::string> splitBuff;
 	std::string msg;
 	
+	//std::cout << "privmsg bufer= --" << buffer << std::endl;
 	if (!allFds.userData[userNbr].registered) 
 	{
 		cmd_error(allFds, allFds.userData[userNbr].fd, "451 " + allFds.userData[userNbr].nickname + " WALLOPS :You have not registered\r\n");
@@ -30,9 +31,11 @@ void	WALLOPS(std::string buffer, fdList &allFds, int userNbr)
 		return ;
 	}
 	msg = ":" + allFds.userData[userNbr].nickname + " WALLOPS :" + buffer.substr(splitBuff[1].size() + std::string::npos + 1) + "\r\n";
-	for (size_t i = 0; i < allFds.userData.size(); i++)
+	//msg = "PRIVMSG " + allFds.userData[userNbr].nickname + " " + buffer.substr(splitBuff[1].size() + std::string::npos + 1);
+	for (int i = 0; i < allFds.nbrUser; i++)
 	{
 		if (allFds.userData[i].op && allFds.userData[i].mode.s)
 			send(allFds.userData[i].fd, msg.c_str(), msg.size(), 0);
+			//PRIVMSG(msg, allFds, userNbr);
 	}
 }

srcs/commands/other/names.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/16 18:14:15 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:37:30 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:26:02 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,61 +15,31 @@
 //:irc.server.net 353 user = #channel :@user1 +user2 user3
 //:irc.server.net 366 user #channel :End of /NAMES list.
 
-void	names_reply(fdList &allFds, channelData &chan, int fd, int userNbr)
+void	names_reply(fdList &allFds, channelData &chan, int fd, std::string user)
 {
 	std::string msg;
-	print_client_list(chan.opList);
+	msg = "353 " + user + " = " + chan.name + " :";
-	print_client_list(chan.verboseList);
-	msg = "353 " + allFds.userData[userNbr].nickname + " = " + chan.name + " :";
 	for (size_t i = 0; i < chan.userList.size(); i++)
 	{
-		if (chan.userList[i]->mode.i && !is_in_same(allFds, userNbr, find_user(allFds, chan.userList[i]->nickname) && !allFds.userData[userNbr].op))
+		if (chan.userList[i]->mode.o)//ischanop 
-			;
+			msg += "=" + chan.userList[i]->nickname + " ";
-		else if (find_client_list(chan.opList, chan.userList[i]) != -1 || allFds.userData[userNbr].op)
+		else if (chan.userList[i]->mode.o)//verbose
-		{
-			std::cout << "he is op!!!\n";
 			msg += "@" + chan.userList[i]->nickname + " ";
-		}
-		else if (find_client_list(chan.verboseList, chan.userList[i]) != -1)
-		{
-			std::cout << "he is verbose???\n";
-			msg += "+" + chan.userList[i]->nickname + " ";
-		}
 		else
-			msg += chan.userList[i]->nickname + " ";
+			msg += "+" + chan.userList[i]->nickname + " ";
 	}
 	msg += "\r\n";
 	std::cout << "name msg= " << msg;
 	cmd_reply(allFds, fd, msg);
-	msg = "366 " + allFds.userData[userNbr].nickname + " " + chan.name + " :End of /NAMES list\r\n";
-	cmd_reply(allFds, fd, msg);
-}
-
-void	names_loop(fdList &allFds, std::vector<std::string> splitBuff, int userNbr)
-{
-	std::vector<std::string>	splitChan;
-	int pos;
-	
-	split(splitBuff[1], ',', splitChan);
-	for (size_t i = 0; i < splitChan.size(); i++)
-	{
-		pos = find_channel(allFds, splitChan[i]);
-		if (pos != -1)
-		{
-			if ((!allFds.channelList[pos].mode.p && !allFds.channelList[pos].mode.s) 
-					|| is_joined(allFds, allFds.channelList[pos].name, userNbr) || allFds.userData[userNbr].op)
-				names_reply(allFds, allFds.channelList[pos], allFds.userData[userNbr].fd, userNbr);
-			return;
-		}
-	}
-	
-
-
 }
 
 void	NAMES(std::string buffer, fdList &allFds, int userNbr)
 {
+	(void)buffer; 
+	(void)allFds;
+	(void)userNbr;
 	std::vector<std::string> splitBuff;
+	int pos;
 	
 	if (!allFds.userData[userNbr].registered) 
 	{
@@ -82,12 +52,22 @@ void	NAMES(std::string buffer, fdList &allFds, int userNbr)
 		for (size_t i = 0; i < allFds.channelList.size(); i++)
 		{
 			if ((!allFds.channelList[i].mode.p && !allFds.channelList[i].mode.s) 
-				|| is_joined(allFds, allFds.channelList[i].name, userNbr) || allFds.userData[userNbr].op)
+				|| is_joined(allFds, allFds.channelList[i].name, userNbr))
-				names_reply(allFds, allFds.channelList[i], allFds.userData[userNbr].fd, userNbr);
+			{
+				names_reply(allFds, allFds.channelList[i], allFds.userData[userNbr].fd, allFds.userData[userNbr].nickname);
+				//print who
+			}
 		}
 		return ;
 	}
-	else
+	if ((pos = find_channel(allFds, splitBuff[1])) != -1)
-		names_loop(allFds, splitBuff, userNbr);
+	{
+		if ((!allFds.channelList[pos].mode.p && !allFds.channelList[pos].mode.s) 
+				|| is_joined(allFds, allFds.channelList[pos].name, userNbr))
+		{
+			names_reply(allFds, allFds.channelList[pos], allFds.userData[userNbr].fd, allFds.userData[userNbr].nickname);
+		}
+		return; //??
+	}
 	return ;
 }

srcs/commands/other/ping_pong.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/13 00:16:27 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:37:45 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:16:50 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -29,7 +29,14 @@ void	PONG(std::string buffer, fdList &allFds, int userNbr)
 	std::vector<std::string> splitBuff;
 	split(buffer, ' ', splitBuff);
 	msg = ":irc.local PONG irc.local :irc.local\r\n";
+	// ":irc.local PONG irc.local :irc.local"
 	send(allFds.userData[userNbr].fd, msg.c_str(), msg.size(), 0);
+	// if (splitBuff.size() < 2)
+	// {
+	// 	cmd_error(allFds, allFds.userData[userNbr].fd, "431 " + allFds.userData[userNbr].nickname + " NICK :No nickname given\n");
+	// 	//write(allFds.userData[user].fd, "ERR_NEEDMOREPARAMS", 18);
+	// 	return ;
+	// }
 	
 	return ;
 }
@@ -45,6 +52,18 @@ void	PING(std::string buffer, fdList &allFds, int userNbr)
 	std::vector<std::string> splitBuff;
 	split(buffer, ' ', splitBuff);
 	msg = ":irc.local PONG irc.local :" + splitBuff[1] + "\r\n";
+	//msg = "PONG irc.local " + splitBuff[1];
 	send(allFds.userData[userNbr].fd, msg.c_str(), msg.size(), 0);
+	//std::cout << "pong send\n";
+	//std::cout << "/r = " << (int)'\r' << "\n";
+	//std::cout << "/n = " << (int)'\n' << "\n";
+	//std::cout << "msg=" << msg << "\n";
+	// if (splitBuff.size() < 2)
+	// {
+	// 	cmd_error(allFds, allFds.userData[userNbr].fd, "431 " + allFds.userData[userNbr].nickname + " NICK :No nickname given\n");
+	// 	//write(allFds.userData[user].fd, "ERR_NEEDMOREPARAMS", 18);
+	// 	return ;
+	// }
+
 	return ;
 }

srcs/commands/other/quit.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/11 19:10:26 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:38:01 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:16:59 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,16 +16,26 @@ void	send_quit_msg(fdList &allFds, int userNbr, std::string msg)
 {
 	std::string fullMsg;
 
+	// if (msg.empty())
+	// 	fullMsg = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName + "@" + allFds.userData[userNbr].ip + " QUIT :" + joined_chan.name + "\n";
+	// else 
 	fullMsg = ":" + allFds.userData[userNbr].nickname + "!" + allFds.userData[userNbr].userName + "@" + allFds.userData[userNbr].ip + " QUIT :" + msg + "\r\n";
 	for (size_t i = 0; i < allFds.userData[userNbr].joinedChan.size(); i++)
 	{
+		//allFds.userData[userNbr].joinedChan[i]->
+		//send(joined_chan.userList[i]->fd, fullMsg.c_str(), fullMsg.size(), 0);
+
 		for (size_t j = 0; j < allFds.userData[userNbr].joinedChan[i]->userList.size(); j++)
 		{
+			//std::cout << "send nickname " << allFds.userData[userNbr].joinedChan[i]->userList[j]->nickname << std::endl;
 			if (allFds.userData[userNbr].joinedChan[i]->userList[j] != &allFds.userData[userNbr])
 			{
 				if (allFds.userData[userNbr].joinedChan[i]->userList[j]->mode.s)
 					send(allFds.userData[userNbr].joinedChan[i]->userList[j]->fd, fullMsg.c_str(), fullMsg.size(), 0);
 			}
+			//else
+			//	std::cout << "hehe je quitte\n";
+			//std::cout << "loop here\n";
 		}
 	}
 }
@@ -36,7 +46,11 @@ void	QUIT(std::string buffer, fdList &allFds, int userNbr)
 	
 	split(buffer, ' ', splitBuff);
 	if (splitBuff.size() > 2)
+	{
 		send_quit_msg(allFds, userNbr, buffer.substr(5, std::string::npos));//to test
+		//print message?
+		//:kinou2!kinou@172.17.0.1 QUIT :Quit: leaving
+	}
 	else
 		send_quit_msg(allFds, userNbr, allFds.userData[userNbr].nickname);
 	delete_user(allFds, userNbr);

srcs/commands/other/who.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/16 18:14:17 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:38:26 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:26:41 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,9 +15,22 @@
 //void	who_reply(fdList &allFds, int userNbr, int fd)
 void	who_reply(fdList &allFds, clientData &user, int fd)
 {
-	std::string msg;
+	// std::string msg;
+	// //:<server> 352 <channel> <username> <hostname> <server> <nick> H :0 <realname>
+	// //if (chan.size())
+	// msg = "352 " /*+ chan + " " */
+	// + allFds.userData[userNbr].userName + " " 
+	// + allFds.userData[userNbr].hostName + " irc.local " 
+	// +  allFds.userData[userNbr].nickname + " :0 " 
+	// + allFds.userData[userNbr].realName + "\n";
 
-	msg = "352 "
+	// cmd_reply(allFds, fd, msg);
+
+
+	std::string msg;
+	//:<server> 352 <channel> <username> <hostname> <server> <nick> H :0 <realname>
+	//if (chan.size())
+	msg = "352 " /*+ chan + " " */
 	+ user.userName + " " 
 	+ user.hostName + " irc.local " 
 	+ user.nickname + " :0 " 
@@ -42,8 +55,11 @@ void	WHO(std::string buffer, fdList &allFds, int userNbr)
 	{
 		for (int i = 0; i < allFds.nbrUser; i++)
 		{
-			if (!allFds.userData[i].mode.i || is_in_same(allFds, userNbr, i) || allFds.userData[userNbr].op)
+			if (!allFds.userData[i].mode.i || is_in_same(allFds, userNbr, i))
+			{
 				who_reply(allFds, allFds.userData[i], allFds.userData[userNbr].fd);
+				//print who
+			}
 		}
 		return ;
 	}
@@ -53,7 +69,11 @@ void	WHO(std::string buffer, fdList &allFds, int userNbr)
 		return ;
 	}
 	for (size_t i = 0; i < allFds.channelList[pos].userList.size(); i++)
+	{
 		who_reply(allFds, *allFds.channelList[pos].userList[i], allFds.userData[userNbr].fd);
-	cmd_reply(allFds, allFds.userData[userNbr].fd, allFds.userData[userNbr].nickname + " :End of WHO list\n");
+	}
+	//"<nick> :End of WHOIS list"
+	cmd_reply(allFds, allFds.userData[userNbr].fd, allFds.userData[userNbr].nickname + " :End of WHOIS list\n");
+		//std::cout << 
 	return ;
 }

srcs/commands/parse_commands.cpp

@@ -6,12 +6,20 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/06 22:01:25 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:39:13 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/09 05:38:19 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "../../includes/ft_irc.hpp"
 
+std::string ft_test()
+{
+	std::cout << "hehe je suis la" << std::endl;
+	return ("prout");
+}
+
+
+
 void parse_commands(std::string buffer, fdList &allFds, int userNbr)
 {
 	//std::string cmd = buffer;
@@ -21,21 +29,37 @@ void parse_commands(std::string buffer, fdList &allFds, int userNbr)
 	std::cout << "BUFFER: " << buffer;
 	int a = 0;
 
-	if (buffer.find(13) != std::string::npos)
+	if (buffer.find(13) != std::string::npos) //change that pls
+	{
+		//std::cout << "pos of bitch= " << buffer.find(13) << std::endl;
+		//std::cout << "size= " << buffer.size() << std::endl;
+		//if (buffer.find(13) != buffer.size() - 2)
+		//	std::cout << "BE CAREFUL CHAR 10 (line feed) not at end\n";
 		buffer.erase(buffer.find(13), 1);
+	}
+
+
+	
 	allFds.userData[userNbr].cmdBuffer += buffer;
 	if (allFds.userData[userNbr].cmdBuffer.find('\n') == std::string::npos)
 		return ;
 	allFds.userData[userNbr].cmdBuffer.erase(allFds.userData[userNbr].cmdBuffer.size() - 1);
 	split(allFds.userData[userNbr].cmdBuffer, ' ', splitBuff);
+	//std::cout << "before toupper: " << splitBuff[0] << std::endl;
 	for (size_t i = 0; i < splitBuff[0].size(); i++)
 		splitBuff[0][i] = toupper(splitBuff[0][i]);
+	//std::cout << "after toupper: " << splitBuff[0] << std::endl;
 	while (a < allFds.parsingTab.cmdNbr - 1 && splitBuff[0] != allFds.parsingTab.cmdName[a]) 
 		a++;
+	//std::cout << "after while \n";
 	if (a == allFds.parsingTab.cmdNbr - 1)
 		std::cout << "Command not found\n";
 	else
+	{
 		allFds.parsingTab.cmdPtr[a](allFds.userData[userNbr].cmdBuffer, allFds, userNbr);
+		//allFds.parsingTab.cmdPtr[a]
+		//JOIN(allFds.userData[userNbr].cmdBuffer, allFds, userNbr);
+	}
 	if (splitBuff[0] != "QUIT")
 		allFds.userData[userNbr].cmdBuffer.clear();
 }

srcs/delete_user.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/02/12 20:38:50 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:39:49 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 21:15:00 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,7 +14,11 @@
 
 void del_user_in_chan(clientData *user, channelData *chan)
 {
+	// size_t i;
 	int pos;
+	// for (i = 0; user != chan->userList[i]; i++)
+	// 	;
+	// chan->userList.erase(chan->userList.begin() + i);
 
 	if ((pos = find_client_list(chan->userList, user)) != -1)
 		chan->userList.erase(chan->userList.begin() + pos);
@@ -30,6 +34,8 @@ void del_user_in_chan(clientData *user, channelData *chan)
 		
 	if ((pos = find_client_list(chan->opList, user)) != -1)
 		chan->opList.erase(chan->opList.begin() + pos);
+
+	//chan->nbrUser--;
 }
 
 void del_chan_in_user(clientData *user, channelData *chan)
@@ -38,6 +44,7 @@ void del_chan_in_user(clientData *user, channelData *chan)
 	for (i = 0; chan != user->joinedChan[i]; i++)
 		;
 	user->joinedChan.erase(user->joinedChan.begin() + i);
+	//user->nbrUser--;
 }
 
 void delete_user(fdList &allFds, int userNbr)
@@ -45,7 +52,10 @@ void delete_user(fdList &allFds, int userNbr)
 	std::cout << "Delete user nbr " << userNbr << std::endl;
 	
 	for (size_t i = 0; i < allFds.channelList.size(); i++)//all joined chan
+	{
 		del_user_in_chan(&allFds.userData[userNbr], &allFds.channelList[i]);
+		//allFds.userData[userNbr].joinedChan[i].erase(find_user_in_chan(allFds.userData[userNbr].joinedChan[i])/*find user in chan*/)
+	}
 	close(allFds.userData[userNbr].fd);
 	
 	allFds.userData.erase(allFds.userData.begin() + userNbr);

srcs/main.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/01 17:27:33 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:39:59 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/03 22:57:10 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,6 +16,7 @@ int main(int ac, char **av)
 {
 	if (!(ac == 3))
 	{
+		//ft_error("wrong number of arguments\nFORMAT: ./ircserv <port> <password>");
 		std::cout << "wrong number of arguments\nFORMAT: ./ircserv <port> <password>\n";
 		exit(1);
 	}
@@ -24,6 +25,10 @@ int main(int ac, char **av)
 	{
 		initialize(av);
 	}
+	// catch()
+	// {
+	// 	std::cout << "Fatal error causing the end of the program :/\n";
+	// }
 	catch(std::exception &e)
 	{
 		if (errno)

srcs/new_connection.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/09 22:26:27 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:42:13 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/09 04:59:05 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -19,20 +19,38 @@ void new_connection(fdList &allFds)
 	int newFd;
 
 	std::cout << "==========NEW CLIENT========\n";
+	//std::cout << "in new adress  " << &allFds << std::endl;
+	//std::cout << "new connection !" << std::endl;
+
+	// if (MAX_EVENTS == allFds.nbrUser)
+	// {
+	// 	std::cout << "new connection refused, already full" << std::endl;
+	// 	return ;
+	// }
+
+	//int newUserFd;
+	//allFds.userFdList.push_back(newUserFd);
 	newFd = accept(allFds.serverFd, (struct sockaddr *)&addr, (socklen_t*)&addrLen);
-	if (newFd == -1)
+	//allFds.userFdList[allFds.nbrUser] = newFd;
-	{
-		std::cout << "accept error: client connexion canceled\n";
-		return ;
-	}
 	allFds.userFdList.push_back(newFd);
+	//std::cout << "newConnection | old user fd = " << newFd << std::endl;
 	if (fcntl(newFd, F_SETFL, O_NONBLOCK) == -1)
 		ft_error("fctnl() error");
+
+
+	//std::cout << "fcntl return = " << newFd;
+	//close(newFd);
+	//std::cout << "newConnection | user fd = " << allFds.userFdList[allFds.nbrUser] << std::endl;
+	
 	clientData newElement;
 	newElement.fd = newFd;
 	newElement.addr = addr;
 	newElement.ip = inet_ntoa(addr.sin_addr);
+	//newElement.op = 0; 
 	allFds.userData.push_back(newElement);
+	//allFds.userData[allFds.nbrUser].fd = allFds.userFdList[allFds.nbrUser];
+	//std::cout << "newConnection | user in data fd = " << allFds.userData[allFds.nbrUser].fd << std::endl;
+	
 	epoll_add(allFds.epollFd, allFds.userFdList[allFds.nbrUser]);
 	allFds.nbrUser++; 	
 }

srcs/server_loop.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/06 21:58:13 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:42:42 by apommier         ###   ########.fr       */
+/*   Updated: 2023/02/16 23:01:04 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,24 +14,49 @@
 
 void start_loop(fdList &allFds)
 {
+	//bool alive = true;
+	//int readChar;
 	int eventNbr;
 	int i;
+	//int userId;
 	int nbr;
 	
+	
 	allFds.alive = 1;
+	//std::cout << "serverFd: " << allFds.serverFd << std::endl;
 	while (allFds.alive)
 	{
+		//std::cout << "---------start loop-----------\n";
+		//std::cout << "\n\n\nwhile alive event loop" << std::endl;
+		//std::cout << "in loop nbr user = " << allFds.nbrUser << std::endl;
+		
 		eventNbr = epoll_wait(allFds.epollFd, allFds.events, MAX_EVENTS, 0);
+
+		//eventNbr = epoll_wait(allFds.epollFd, allFds.events, MAX_EVENTS, 5000);
+
+		//std::cout << "eventNbr = " << eventNbr << std::endl;
+		//std::cout << "eventNbr: " << eventNbr << std::endl;
+		//std::cout << "in loop adress  " << &allFds << std::endl;
 		for (i = 0; i < eventNbr ; i++)
 		{
+			
+			//std::cout << "event[i]'s fd: " << allFds.events[i].data.fd << std::endl;
+			//std::cout << "i= " << i << std::endl;
 			if (allFds.events[i].data.fd == allFds.serverFd)
+			{
 				new_connection(allFds);
+				//std::cout << "after new fd loop " << allFds.userData[i].fd << std::endl;
+			}
 			else
 			{
 				nbr = find(allFds.userFdList.begin(), allFds.userFdList.end(), allFds.events[i].data.fd) - allFds.userFdList.begin();
+				//if (!clientRequest(allFds, i))
+				// if (!clientRequest(allFds, nbr))
+				// 	alive = false;
 				clientRequest(allFds, nbr);
 			}
 		}
+		//std::cout << "---------end loop-----------\n";
 	}
 	std::cout << "dead server\n";
 

srcs/start_server.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/06 21:44:20 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:43:06 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 21:13:21 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,16 +20,24 @@
 
 void initialize(char **av)
 {
+	//int allFds.serverFd;
+	//int epollFd;
+	//int newSockFd = 0;
 	int opt = 1;
 	struct sockaddr_in addr;
+	//int addrLen = sizeof(addr);
 	fdList allFds;
 
-	allFds.nbrUser = 0;
+	//allFds.userData.reserve(MAX_EVENTS);
+	//allFds.channelList.reserve(MAX_CHAN);
 	allFds.password = av[2];
 	std::cout << "pass= " << av[2] << std::endl;
+	//allFds.nbrUser = 0;
 	allFds.serverFd = socket(AF_INET, SOCK_STREAM, 0);
 	if (allFds.serverFd == -1)
 		ft_error("socket() error");
+	// if (setsockopt(allFds.serverFd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)))
+	// 	ft_error("setsockopt() error");
 	if (setsockopt(allFds.serverFd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)))
 		ft_error("setsockopt() error");
 
@@ -44,10 +52,23 @@ void initialize(char **av)
 	if (listen(allFds.serverFd, 10) == -1)
 		ft_error("listen() error");
 		
+	// newSockFd = accept(allFds.serverFd, (struct sockaddr *)&addr, (socklen_t*)&addrLen);
+	// if (newSockFd == -1)
+	// 	ft_error("accept() error");
+	
+	// char buffer[1024];
+	// int nbrRead;
+	// while (strncmp("/quit", buffer, 5))
+	// {
+	// 	nbrRead = read()
+	// }
 	time_t timer;
 	time(&timer);
 	allFds.creation_date = ctime(&timer);
 	allFds.epollFd = epoll_start();
+	//allFds.userData
 	epoll_add(allFds.epollFd, allFds.serverFd);
 	start_loop(allFds);
+	
+	//send(newSockFd, "hello", 5, 0);
 }

srcs/utils.cpp

@@ -6,7 +6,7 @@
 /*   By: apommier <apommier@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2022/12/06 21:46:41 by apommier          #+#    #+#             */
-/*   Updated: 2023/03/13 16:44:11 by apommier         ###   ########.fr       */
+/*   Updated: 2023/03/10 22:14:58 by apommier         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,6 +16,13 @@ void ft_error(std::string str)
 {
 	std::cerr << str << std::endl;
 	throw std::exception();
+	// if (errno)
+	// {
+	// 	std::cerr << "errno: " << strerror(errno) << std::endl;
+	// 	throw std::exception();
+	// 	//exit(errno);
+	// }
+	//exit(1);
 }
 
 void close_fd(int fd)
@@ -26,21 +33,29 @@ void close_fd(int fd)
 
 void ft_putstr_fd(int fd, std::string str)
 {
+	// write(fd, str.c_str(), str.size());
+	// write(fd, "\n", 1);
 	str += "\r\n";
 	send(fd, str.c_str(), str.size(), 0);
 }
 
 void cmd_error(fdList &allFds, int fd, std::string error)
 {
-	(void) allFds;
+	(void)allFds; //to delete
 	error = ":irc.local " + error;
+	//write(fd, ":irc.local ", 11);
+	//write(fd, error.c_str(), error.size());
 	send(fd, error.c_str(), error.size(), 0);
 }
 
 void cmd_reply(fdList &allFds, int fd, std::string error)
 {
-	(void) allFds;
+	
+	(void)allFds; //to delete
 	error = ":irc.local " + error;
+	//std::cout << cmd_reply= --- << error << "---";
+	//write(fd, ":irc.local ", 11);
+	//write(fd, error.c_str(), error.size());
 	send(fd, error.c_str(), error.size(), 0);
 }
 
@@ -74,23 +89,3 @@ int find_client_list(std::vector<clientData *> &list, clientData *client)
 	}
 	return (-1);
 }
-
-int print_client_list(std::vector<clientData *> &list)
-{
-	int size = list.size();
-	std::cout << "=PRINT LIST=\n";
-	for (int i = 0; i < size; i++)
-	{
-		std::cout << i << "= " << list[i]->nickname << std::endl;
-	}
-	return (-1);
-}
-
-std::string	int_to_str(int i)
-{
-	std::string s;
-	std::stringstream out;
-	out << i;
-	s = out.str();
-	return (s);
-}