Version Fonctionnelle : STEP 1 Terminée

.gitignore

@@ -0,0 +1,2 @@
+serveur
+client

Client.c

@@ -0,0 +1,78 @@
+/* librairie standard ... */
+/* déclaration des types de base */
+#include <sys/types.h>
+/* constantes relatives aux domaines, types et protocoles */
+#include <sys/socket.h>
+/* constantes et structures propres au domaine INTERNET */
+#include <netinet/in.h>
+/* structures retournées par les fonctions de gestion de la base de
+   données du réseau */
+#include <netdb.h>
+/* pour les entrées/sorties */
+#include <stdio.h>
+/* la lib standard */
+#include <stdlib.h>
+/* pour le fork */
+#include <unistd.h>
+/* pour memcpy */
+#include <string.h>
+
+int main (int argc, char * argv[]) {
+  
+	if (argc != 3) {
+		printf("ERREUR : Usage : ./client AdresseServeur N°Port\n");
+		exit(2);
+	}
+
+  int sock = socket(AF_INET, SOCK_STREAM, 0);
+  if (sock == -1) {
+    printf("ERREUR lors de la création du socket\n");
+    exit(1);
+  } 
+
+	// On cree l'adresse du socket target
+	struct sockaddr_in addr_target;
+
+	addr_target.sin_family = AF_INET;
+	addr_target.sin_port = atoi(argv[2]);
+	struct hostent * hoststruct = gethostbyname(argv[1]);
+      
+	if (hoststruct == NULL){
+	  printf("ERREUR lors de la recherche de l'adresse IP du target\n");
+	  exit(1);
+	}
+
+	memcpy((char *)&(addr_target.sin_addr.s_addr), hoststruct->h_addr, hoststruct->h_length);
+
+	int retour_connexion;
+	//On fait de demande de connextion au socket target
+	retour_connexion = connect(sock, (struct sockaddr *)&addr_target, sizeof(struct sockaddr_in));
+	if (retour_connexion == -1){
+	  printf("ERREUR lors de la demande de connexion\n");
+	  exit(1);
+	}
+
+	//On envoie les messages
+	/*for (cmpt_message_envoye = 1; cmpt_message_envoye <= nb_message; cmpt_message_envoye++){
+	  // On construit le message à envoyer
+	  construire_message(message_envoie,(96 + (cmpt_message_envoye % 26)), longueur_message, cmpt_message_envoye);
+	  //On envoie les messages
+	  nb_carac_envoye = send(sock, message_envoie, longueur_message, 0);
+	
+	  if (nb_carac_envoye == -1){
+	    printf("ERREUR lors de l'envoi du message numéro %d\n", cmpt_message_envoye);
+	    exit(1);
+	  } else{
+	    printf("CLIENT EMMETEUR : Envoi n°%d (%d) [", cmpt_message_envoye, nb_carac_envoye);
+	    afficher_message(message_envoie, longueur_message);
+	    printf("]\n");
+	  }
+	
+	}*/
+
+	close(sock);
+  return 0;
+}
+
+
+

ReadMe.md

@@ -0,0 +1,50 @@
+
+Projet d'Initiation à la Recherche (PIR) | 4A-IR-SI | INSA Toulouse
+
+NOM DU PIR
+
+Membres : (Noms ecrit de mémoire, check orthographe)
+	- Léonie Gallois
+	- Elies Tali
+	- Yohan Simard
+	- Paul Faure
+	- Nahom Bellay
+	- Jean Remi Hok
+
+Tuteurs : 
+	- Didier LeBotlan
+	- Eric AlataS
+
+Programmes SERVEUR et CLIENT, principe général : 
+ 
+	- Le serveur : En écoute sur un port passé en paramètre, des qu'une connexion arrive, il fork, traite la connexion dans le fils, le père se remet en attente
+	- Gestion de la connexion : Attends une chaine de caractère du client, et, en fonction de son contenu effectue les actions adéquates
+	- Chaine attendues : 
+			* Nombre de connexions : Le serveur renverra le nombre de connexion qu'il y a eu depuis le début de son lancement
+			* Heure								 : Le serveur renverra l'heure actuelle
+			* Reset								 : Le serveur remettra le nombre de connexions a 0 et renverra un message indiquant que le nombre de connexions est réinitialisé
+			* Chaine inconnue      : Le serveur renverra un message d'erreur 
+
+	- Le client : Demande a l'utilisateur de saisir une chaine, puis, affiche la réponse du serveur
+
+	- Failles : 
+			* Le serveur copie la chaine reçue avec strcpy -> risque de buffer Overflow
+			* Le serveur fork, l'attaquant peut accumuler de la connaissance
+
+Etapes de dévellopement : 
+
+	- Step 1 : FAIT
+			* Le serveur  : Gere le nombre de connexions, à chaque connexions, il l'affiche juste.
+			* Le client   : Se connecte et ferme la connexion aussitôt.
+			* Utilité     : Test de l'établissement des connexions. 
+	- Step 2 : A FAIRE
+			* Le serveur  : Gere le nombre de connexions, à chaque connexions, dans le fils, il appelle une fonction d'affichage.
+			* La fonction : Reçoit la nombre de connexion, l'affiche, ainsi que son adresse mémoire.
+			* Le client   : Se connecte et ferme la connexion aussitôt.
+			* Utilité     : Verification que les adresses ne changent pas dans la pile d'un fork à l'autre. 
+	- Step 3 : A FAIRE
+			* Le serveur  : Gere le nombre de connexions, à chaque connexions, dans le fils, récupere la chaine, appelle une fonction de traitement.
+			* La fonction : Copie la chaine et appelle une autre fonction de traitement.
+			* Le client   : Se connecte, demande a l'utilisateur de saisir la chaine, affiche la réponse, et ferme la connexion.
+			* Utilité     : Test du serveur dans son fonctionnement normal. 
+	- Step 4 : A DEFINIR

Serveur.c

@@ -0,0 +1,84 @@
+/* déclaration des types de base */
+#include <sys/types.h>
+/* constantes relatives aux domaines, types et protocoles */
+#include <sys/socket.h>
+/* constantes et structures propres au domaine INTERNET */
+#include <netinet/in.h>
+/* structures retournées par les fonctions de gestion de la base de
+   données du réseau */
+#include <netdb.h>
+/* pour les entrées/sorties */
+#include <stdio.h>
+/* la lib standard */
+#include <stdlib.h>
+/* pour le fork */
+#include <unistd.h>
+
+
+int main (int argc, char * argv[])
+{ 
+	if (argc != 2) {
+		printf("ERREUR : Usage : ./serveur N°Port\n");
+		exit(2);
+	}
+
+  // On crée le socket local
+  int sock = socket(AF_INET, SOCK_STREAM, 0);
+  if (sock == -1) {
+    printf("ERREUR lors de la création du socket\n");
+    exit(1);
+  } 
+
+	// On cree l'adresse du socket local
+	struct sockaddr_in addr_local;
+	int binder;
+
+	addr_local.sin_family = AF_INET;
+	addr_local.sin_port = atoi(argv[1]);
+	addr_local.sin_addr.s_addr = INADDR_ANY;
+
+	//On bind l'adresse du socket créee avec le socket local
+	binder = bind(sock,(struct sockaddr *) &addr_local, sizeof(struct sockaddr_in));
+	if (binder == -1){
+	  printf("ERREUR lors du bind du socket\n");
+	  exit(1);
+	}
+
+	//Initialisation file d'attente
+	listen(sock, 100);
+
+	// Variable de stockage de l'addresse emmeteur
+	struct sockaddr_in addr_em;
+	unsigned int longueur_addr_em = sizeof(struct sockaddr_in);
+
+	
+	// On se met en état d'acceptation de connexion (et on crée un socket en passant)
+	int pid = 1;
+	int nb_connexions = 0;	  
+	while (pid != 0){
+	  
+	  int sock_connexion = accept(sock, (struct sockaddr *)&addr_em, &longueur_addr_em);
+		nb_connexions++;
+	  pid = fork();
+
+	  if (pid == -1){
+			printf("ERREUR lors du fork\n");
+			exit(1);
+	  } else if (pid == 0) {
+			if (sock_connexion == -1) {
+	      printf("ERREUR lors de l'acceptation de la connexion\n");
+	      exit(1);
+	    } else {
+				if (nb_connexions == 1) {
+					printf("Nouvelle connexion, 1ere connexion\n");
+				} else if (nb_connexions == 2) {
+					printf("Nouvelle connexion, 2nd connexion\n");
+				} else {
+					printf("Nouvelle connexion, %deme connexion\n", nb_connexions);
+				} 
+			}
+		}
+	}	    
+  return 0;
+}
+

makefile

@@ -0,0 +1,27 @@
+default: all
+
+all: serveur client
+
+serveur: Serveur.c
+	@echo "######################################"
+	@echo "####### Compilation du SERVEUR #######"
+	@echo "######################################"
+	@echo ""
+	gcc -Wall Serveur.c -o serveur
+	@echo ""
+	@echo ""
+
+client: Client.c
+	@echo "######################################"
+	@echo "####### Compilation du CLIENT  #######"
+	@echo "######################################"
+	@echo ""
+	gcc -Wall Client.c -o client
+	@echo ""
+	@echo ""
+
+edit:
+	pluma Serveur.c Client.c &
+
+clean:
+	@rm client serveur