https://github.com/raveriss/ft_irc
Projet de développement d’un serveur IRC en C++98, suivant les standards du protocole IRC. Le serveur supporte plusieurs connexions simultanées, des opérations non bloquantes, et permet aux clients de rejoindre des canaux, d’envoyer des messages privés, et de gérer des opérateurs de canaux.
https://github.com/raveriss/ft_irc
42-paris 42-school 42school cpp98 ft-irc internet internet-relay-chat irc networking non-blocking-io server sockets
Last synced: 4 months ago
JSON representation
Projet de développement d’un serveur IRC en C++98, suivant les standards du protocole IRC. Le serveur supporte plusieurs connexions simultanées, des opérations non bloquantes, et permet aux clients de rejoindre des canaux, d’envoyer des messages privés, et de gérer des opérateurs de canaux.
- Host: GitHub
- URL: https://github.com/raveriss/ft_irc
- Owner: raveriss
- Created: 2024-10-09T15:08:06.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2024-11-30T22:52:06.000Z (over 1 year ago)
- Last Synced: 2025-11-07T22:02:49.688Z (8 months ago)
- Topics: 42-paris, 42-school, 42school, cpp98, ft-irc, internet, internet-relay-chat, irc, networking, non-blocking-io, server, sockets
- Language: C++
- Homepage: https://www.linkedin.com/in/rafael-verissimo-8b382b20b/
- Size: 4.27 MB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# ft_irc - École 42 | Paris
###
## Description
Le projet **`ft_irc`** consiste à développer un serveur IRC en respectant le standard IRC tout en utilisant le langage **`C++98`**. Le serveur doit gérer plusieurs connexions simultanées et fonctionner en mode non bloquant pour permettre une communication fluide entre les clients.
Vous devez tester votre serveur à l'aide d'un vrai client IRC pour garantir la compatibilité avec le protocole standard.
## Objectifs
- Reproduire le fonctionnement d'un serveur **`IRC`** en `C++98`.
- Gérer plusieurs clients simultanément sans blocage.
- Implémenter les principales commandes IRC comme `NICK`, `USER`, `JOIN`, `PRIVMSG`, etc.
- Fournir un système d'authentification via un mot de passe à la connexion.
- Supporter les opérateurs de canal et les commandes associées comme `KICK`, `INVITE`, `TOPIC`, et `MODE`.
## Fonctionnalités
- **Communication `TCP`/`IP`** : Utilisation des sockets pour la communication entre le serveur et les clients via le protocole **`TCP`/`IP`** (`v4` ou `v6`).
- **Gestion des canaux** : Le serveur doit permettre la création et la gestion de canaux `IRC`, avec la possibilité d'envoyer des messages privés ou dans des canaux.
- **Non-bloquant** : Toutes les opérations d'entrée/sortie (E/S) sont non bloquantes afin de ne jamais empêcher la gestion simultanée des connexions multiples.
- **Sécurité** : Utilisation d'un mot de passe pour sécuriser l'accès au serveur. Chaque client doit fournir le bon mot de passe pour pouvoir se connecter.
- **Support multi-clients** : Le serveur peut gérer plusieurs connexions simultanément sans aucun forking ou thread supplémentaire.
## Structure du Projet
```bash
.
├── incs
│ ├── Bot.hpp
│ ├── Channel.hpp
│ ├── Client.hpp
│ ├── IrcMessageBuilder.hpp
│ ├── IrcNumericReplies.hpp
│ └── Server.hpp
├── Makefile
├── README.md
└── srcs
├── Bot.cpp
├── Channel.cpp
├── Client.cpp
├── IrcMessageBuilder.cpp
├── main.cpp
└── Server.cpp
```
## Exemple de commandes IRC supportées
- **`NICK`** : Changer le pseudonyme du client
- **`USER`** : S'authentifier sur le serveur
- **`JOIN`** : Rejoindre un canal
- **`PRIVMSG`** : Envoyer un message privé ou un message dans un canal
- **`KICK`** : Éjecter un client d'un canal (opérateurs uniquement)
- **`INVITE`** : Inviter un client à rejoindre un canal
- **`TOPIC`** : Changer ou afficher le sujet d'un canal
- **`MODE`** : Modifier les permissions d'un canal (opérateurs uniquement)
## Bonus
- **Bot IRC** : Possibilité d'ajouter un petit bot qui interagit avec les utilisateurs.
- **Transfert de fichiers** : Support de l'envoi de fichiers entre clients.
## Compilation
Utilisez le **`Makefile`** pour compiler le projet avec les options de compilation requises. Le projet doit se compiler en utilisant `C++98` avec les flags `-Wall -Wextra -Werror`.
**Commandes disponibles :**
```bash
make # Compile le projet
make clean # Supprime les fichiers objets
make fclean # Supprime les fichiers objets et les binaires
make re # Recompile le projet
```
## Lancer le serveur :
```bash
./ircserv
```
- **Arguments** :
- `` : Le numéro de `port` sur lequel le serveur écoutera.
- `` : Le mot de passe que les clients devront fournir pour se connecter.
## Aperçu du Serveur
Voici un aperçu de l'interface graphique du serveur `ft_irc` lors de son lancement :
## Gestion des Adresses `IP`
- **Afficher les Adresses `IP` de l’Hôte :**
```bash
hostname -I
```
- **Afficher l’Adresse `IPv4` de l’Interface `enp3s0f0` :**
```bash
ip -o -4 addr show enp3s0f0 | awk '{print $4}' | cut -d/ -f1
```
**Explication des Commandes :**
- `ip -o -4 addr show enp3s0f0` : Affiche les informations d’adresse `IPv4` pour l’interface `enp3s0f0` en format compact.
- `awk '{print $4}'` : Sélectionne la colonne contenant l’adresse `IP` avec le masque de sous-réseau.
- `cut -d/ -f1` : Supprime le masque de sous-réseau pour ne garder que l’adresse `IP` pure.
- **Extraction de l’Adresse `IP` Principale :**
```bash
hostname -I | awk '{print $1}'
```
## Se Connecter à un Serveur `IRC`
Cette section décrit les différentes méthodes pour se connecter à un serveur `IRC` en fonction de l'outil utilisé.
### 1. Connexion avec `nc` (`netcat`)
Utilisez `nc` pour établir une connexion basique au serveur `IRC`. C'est utile pour des tests rapides :
```bash
nc
```
Envoi de commandes `IRC` : Une fois connecté, entrez vos commandes `IRC` directement dans le terminal (par exemple, `PASS`, `NICK`, `USER`, etc.).
### 2. Connexion avec `irssi`
- **Méthode A** : Connexion simple
Lancer `irssi` :
```bash
irssi
```
Une fois dans l'interface d'`irssi`, utilisez la commande suivante :
```irssi
/connect
```
- **Méthode B** : Connexion avec paramètres (`port`, `nickname`, `password`)
```bash
irssi -c -p -n -w
```
**Comparaison des outils :**
`nc` (`netcat`) : Idéal pour des tests basiques et vérifier les échanges bruts avec le serveur.
`irssi` : Offre une interface interactive, utile pour tester des fonctionnalités avancées comme la gestion des canaux ou les commandes administratives.
## Diagnostic et Debug
### Outils de Débogage et Diagnostic
- **Vérification des Connexions Actives sur le Port `` avec `lsof` :**
```bash
lsof -i :
```
- **Forcer la Fermeture des Processus Actifs sur le Port `` :**
```bash
kill -9 $(lsof -t -i :)
```
- **Fuites Mémoire et Vérification des Descripteurs Actifs pour `ircserv` via `Valgrind` :**
```bash
valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --track-fds=yes ./ircserv
```
## Utilisation d’`Irssi`
- **Ouvrir le Fichier de Configuration d'`Irssi` avec `VS Code` :**
```bash
code ~/.irssi/config
```
- **Pour Utiliser `RAWLOG` avec votre Serveur `IRC` :**
Dans `irssi` :
```irssi
/RAWLOG OPEN ~/debug.log
```
- **Passer d'une conversation privée à la page d'accueil d'`Irssi` :**
- Appuyez sur `Alt + 1` ou `Esc` suivi de `1` pour retourner à la fenêtre 1, qui est souvent la page d'accueil ou le canal principal.
- Appuyez sur `Alt + flèche gauche` ou `Alt + flèche droite` pour naviguer entre les fenêtres.
Vous pouvez également utiliser `Ctrl + P` (fenêtre précédente) ou `Ctrl + N` (fenêtre suivante).
- Tapez `/window goto 1` dans n'importe quelle fenêtre pour revenir à la fenêtre 1.
- **Adresse `IP` pour les transferts DCC**
- **Observation** :
Votre configuration indique `hostname = "127.0.0.1"` dans les paramètres du core. L'adresse `127.0.0.1` est l'adresse de bouclage (*localhost*) et n'est pas accessible depuis d'autres machines sur le réseau.
- **Solution** :
Définissez votre adresse `IP` externe ou locale correcte en utilisant la commande suivante dans `Irssi` :
```irssi
/set dcc_own_ip votre.adresse.ip
```
Remplacez votre.adresse.ip par votre adresse IP réelle sur le réseau.
- **Résultat** : Cette commande ajoutera automatiquement l'entrée suivante dans votre fichier de configuration `~/.irssi/config` :
```
"irc/dcc" = { dcc_own_ip = ""; };
};
```
## Envoi de fichier.
### Avec `irssi` :
- **Envoyer un Fichier avec `DCC` :**
```irssi
/dcc send Pol /mnt/nfs/homes/raveriss/Desktop/Sender/test.txt
```
- **Recevoir un Fichier avec `DCC` :**
```irssi
/dcc get Raf test.txt
```
### Avec `nc` :
- **1. Sur le client expéditeur (`Raf`) :**
Ouvrez un terminal et placez-vous dans le répertoire du fichier :
```bash
cd /mnt/nfs/homes/raveriss/Desktop/Sender/
```
Lancez `netcat` en écoute sur un port dédié, par exemple `12345` :
```bash
nc -l 12345 < test.txt
```
- **2. Sur le client récepteur (`Pol`) :**
Lancez la commande suivante pour vous connecter à `Raf` et recevoir le fichier :
```bash
nc 12345 > test.txt
```
- `` : Adresse `IP` de `Raf`.
- `12345` : `Port` fourni par `Raf`.
## Tester la suspention d'un client dans un channel
### Avec `nc` :
- **1. Quand un client est dans un channel contenant plusieurs autres clients, faire un `Ctrl + Z`.**
Ce message devrait apparaitre :
```bash
[]+ Stopped nc
```
Cela signifie que ce client est maintenant suspendu.
- **2. Envoyez maintenant plusieurs `PRIVMSG` dans le channel avec plusieurs clients qui y sont presents.**
- **3. Effectuez la commande suivante avec le client suspendu :**
```bash
fg %
```
Remplacez `` par le numéro affiché entre crochets dans le message `Stopped`.
Si votre projet `IRC` fonctionne correctement, apres cette commande les messages ecrits pendant qu'il etait suspendu devraient apparaitre dans le terminal.
---
## Contributeurs
- [acatusse](https://github.com/0x2Anessie)
- [lgoure](https://github.com/lukas94kdl)
- [raveriss](https://github.com/raveriss)
## Ressources Utilisées
- [Documentation officielle de l'IRC](https://tools.ietf.org/html/rfc2812)
- [Documentation des sockets en C++](https://www.boost.org/doc/libs/1_76_0/doc/html/boost_asio.html)
- [Tutoriel sur les sockets Unix](https://beej.us/guide/bgnet/)