From 5f5c8a7eafff92125f5cff38dc108f3bfd8af029 Mon Sep 17 00:00:00 2001 From: xdrm-brackets Date: Mon, 14 Dec 2015 21:48:19 +0100 Subject: [PATCH] Commit initial --- SEQUENTIAL/backup/client.c | 64 ++++ SEQUENTIAL/backup/proxy_aure.c | 336 ++++++++++++++++++ SEQUENTIAL/backup/serveur.c | 117 ++++++ SEQUENTIAL/proxy_ftp.c | 215 +++++++++++ SEQUENTIAL/proxy_ftp.h | 39 ++ SEQUENTIAL/test | Bin 0 -> 18741 bytes SEQUENTIAL/thread/SEQUENTIAL/backup/client.c | 64 ++++ .../thread/SEQUENTIAL/backup/proxy_aure.c | 336 ++++++++++++++++++ SEQUENTIAL/thread/SEQUENTIAL/backup/serveur.c | 117 ++++++ SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.c | 215 +++++++++++ SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.h | 39 ++ SEQUENTIAL/thread/SEQUENTIAL/test | Bin 0 -> 18741 bytes SEQUENTIAL/thread/backup/client.c | 64 ++++ SEQUENTIAL/thread/backup/proxy_aure.c | 336 ++++++++++++++++++ SEQUENTIAL/thread/backup/serveur.c | 117 ++++++ SEQUENTIAL/thread/main.c | 55 +++ SEQUENTIAL/thread/proxy_ftp.c | 215 +++++++++++ SEQUENTIAL/thread/proxy_ftp.h | 39 ++ SEQUENTIAL/thread/test | Bin 0 -> 18741 bytes SEQUENTIAL/thread/thread/main.c | 55 +++ SEQUENTIAL/thread/thread/test | Bin 0 -> 8915 bytes backup/client.c | 64 ++++ backup/proxy_aure.c | 336 ++++++++++++++++++ backup/serveur.c | 117 ++++++ dep/client.c | 193 ++++++++++ dep/client.h | 17 + dep/server.c | 283 +++++++++++++++ dep/server.h | 29 ++ dep/utility.c | 151 ++++++++ dep/utility.h | 55 +++ proxy_ftp.c | 146 ++++++++ proxy_ftp.h | 84 +++++ test | Bin 0 -> 18600 bytes thread/main.c | 55 +++ thread/test | Bin 0 -> 8915 bytes 35 files changed, 3953 insertions(+) create mode 100644 SEQUENTIAL/backup/client.c create mode 100644 SEQUENTIAL/backup/proxy_aure.c create mode 100644 SEQUENTIAL/backup/serveur.c create mode 100644 SEQUENTIAL/proxy_ftp.c create mode 100644 SEQUENTIAL/proxy_ftp.h create mode 100755 SEQUENTIAL/test create mode 100644 SEQUENTIAL/thread/SEQUENTIAL/backup/client.c create mode 100644 SEQUENTIAL/thread/SEQUENTIAL/backup/proxy_aure.c create mode 100644 SEQUENTIAL/thread/SEQUENTIAL/backup/serveur.c create mode 100644 SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.c create mode 100644 SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.h create mode 100755 SEQUENTIAL/thread/SEQUENTIAL/test create mode 100644 SEQUENTIAL/thread/backup/client.c create mode 100644 SEQUENTIAL/thread/backup/proxy_aure.c create mode 100644 SEQUENTIAL/thread/backup/serveur.c create mode 100644 SEQUENTIAL/thread/main.c create mode 100644 SEQUENTIAL/thread/proxy_ftp.c create mode 100644 SEQUENTIAL/thread/proxy_ftp.h create mode 100755 SEQUENTIAL/thread/test create mode 100644 SEQUENTIAL/thread/thread/main.c create mode 100755 SEQUENTIAL/thread/thread/test create mode 100644 backup/client.c create mode 100644 backup/proxy_aure.c create mode 100644 backup/serveur.c create mode 100644 dep/client.c create mode 100644 dep/client.h create mode 100644 dep/server.c create mode 100644 dep/server.h create mode 100644 dep/utility.c create mode 100644 dep/utility.h create mode 100644 proxy_ftp.c create mode 100644 proxy_ftp.h create mode 100755 test create mode 100644 thread/main.c create mode 100755 thread/test diff --git a/SEQUENTIAL/backup/client.c b/SEQUENTIAL/backup/client.c new file mode 100644 index 0000000..efd0a9f --- /dev/null +++ b/SEQUENTIAL/backup/client.c @@ -0,0 +1,64 @@ +#include +#include +#include +#include +#include +#include +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 +#define MAXBUFFERLEN 1024 +int main(int argc, char* argv[]){ + int descSock; // Descripteur de la socket + int ecode; // Retour des fonctions + struct addrinfo *res; // Résultat de la focntion getaddrinfo + struct addrinfo hints = { // Cette structure permet de contrôler l'exécution de la fonction getaddrinfo + 0, + AF_INET, //seule les adresses IPv4 seront présentées par la fonctiongetaddrinfo + SOCK_STREAM, + 0, + 0, + NULL, + NULL, + NULL + }; + char serverName[MAXHOSTLEN]; // Nom de la machine serveur + char serverPort[MAXPORTLEN]; // Numéro de port + char buffer[MAXBUFFERLEN]; // buffer stockant les messages échangés entre le client et le serveur + //On teste les valeurs rentrées par l'utilisateur + if (argc != 3){ perror("Mauvaise utilisation de la commande: \n"); exit(1);} + if (strlen(argv[1]) >= MAXHOSTLEN){ perror("Le nom de la machine serveur est trop long\n"); exit(2);} + if (strlen(argv[2]) >= MAXPORTLEN){ perror("Le numero de port du serveur est trop long\n"); exit(2);} + strncpy(serverName, argv[1], MAXHOSTLEN); + serverName[MAXHOSTLEN-1] = '\0'; + strncpy(serverPort, argv[2], MAXPORTLEN); + serverPort[MAXPORTLEN-1] = '\0'; + //Création de la socket IPv4/TCP + descSock = socket(AF_INET, SOCK_STREAM, 0); + if (descSock == -1) { + perror("Erreur creation socket"); + exit(4); + } + //Récupération des informations sur le serveur + ecode = getaddrinfo(serverName,serverPort,&hints,&res); + if (ecode){ + fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecode)); + exit(3); + } + //Connexion au serveur + ecode = connect(descSock, res->ai_addr, res->ai_addrlen); + if (ecode == -1) { + close(descSock); + freeaddrinfo(res); + perror("Erreur connect"); + exit(5); + } + freeaddrinfo(res); + //Echange de donneés avec le serveur + ecode = read(descSock, buffer, MAXBUFFERLEN); + if (ecode == -1) {perror("Problème de lecture\n"); exit(6);} + buffer[ecode] = '\0'; + printf("MESSAGE RECU DU SERVEUR: \"%s\".\n",buffer); + //Fermeture de la socket + close(descSock); +} + diff --git a/SEQUENTIAL/backup/proxy_aure.c b/SEQUENTIAL/backup/proxy_aure.c new file mode 100644 index 0000000..999e131 --- /dev/null +++ b/SEQUENTIAL/backup/proxy_aure.c @@ -0,0 +1,336 @@ +// Bibliothéques +// ============================================== + +#include +#include +#include +#include +#include + + +// Constantes +// ============================================== + +#define SERVADDR "127.0.0.1" // Définition de l'adresse IP d'écoute +#define SERVPORT "4444" // Définition du port d'écoute, si 0 port choisi dynamiquement +#define LISTENLEN 2 // Taille du tampon de demandes de connexions, MAX 2 +#define MAXBUFFERLEN 1024 +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 + + +// PROCEDURES +// ============================================== + +void decoupeLogin( char *entreeUtilisateur, char *login, char *server ); +void waitingForUser(int *socket,char *buffer,int *n); +void waitingForServer(int *socket,char *buffer,int *n); + + +// MAIN +// ============================================== + +int main( int argc, char *argv[] ) { + + // Variables [ SERVEUR ] >> [ PROXY ] - [ PROXY ] >> [ SERVEUR ] + // ============================================== + + int sockServeur; // Descripteur pour le socket + int fncRet; // Stock le retour des fonctions + struct addrinfo *resBIS; // Résultat de la focntion getaddrinfo + struct addrinfo hintsBIS = {0, AF_INET, SOCK_STREAM, 0, 0, NULL, NULL, NULL}; // Filtra pour le getaddrinfo + char bufferFTP[MAXBUFFERLEN]; + + // Variables [ CLIENT ] >> [ PROXY ] - [ PROXY ] >> [ CLIENT ] + // ============================================== + + char serverAddr[MAXHOSTLEN]; // Adresse du serveur + char serverPort[MAXPORTLEN]; // Port du server + char buffer[MAXBUFFERLEN]; // Tampon pour écrire sur le socket + char bufferRcv[MAXBUFFERLEN]; // Tampon pour écrire sur le socket + int descSockRDV; // Descripteur de socket de rendez-vous + int ecode; // Code retour des fonctions + int descSockCOM; // Descripteur de socket de communication + int n = 0; + int lenRCV = 0; + + + struct addrinfo hints; // Filtre pour la fonction get_addr_info + struct addrinfo *res; // Resultat get_addr_info + struct sockaddr_storage myinfo; // Informations sur la connexion de RDV + struct sockaddr_storage from; // Informations sur le client connecté + + + char entreeUtilisateur[40]; // login@server + char login[20]; // Isoler le login + char serveur[20]; // Isoler le serveur + + + socklen_t len = sizeof( struct sockaddr_storage ); // Variable utilisée pour stocker les longueurs des structures de socket + + pid_t pid; + + // Initialisation de la socket de RDV IPv4/TCP + + descSockRDV = socket( AF_INET, SOCK_STREAM, 0 ); + + // Mise à zéro de la variable hints,entreeUtilisateur,loggin.. + + memset( &hints, 0, sizeof( hints ) ); + memset( entreeUtilisateur, 0, sizeof( entreeUtilisateur ) ); + memset( login, 0, sizeof( login ) ); + memset( serveur, 0, sizeof( serveur ) ); + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + // Initailisation de la variable hints + + hints.ai_flags = AI_PASSIVE; // mode serveur, nous allons utiliser la fonction bind + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_family = AF_INET; // IPv4 + + // Récupération des informations du serveur > Machine locale + + ecode = getaddrinfo( SERVADDR, SERVPORT, &hints, &res ); + + // Publication de la socket + + ecode = bind( descSockRDV, res->ai_addr, res->ai_addrlen ); + + ecode = listen( descSockRDV, LISTENLEN ); + + // Attente connexion du client + // Lorsque demande de connexion, creation d'un processus fils et d'un socket de communication avec le client, MAX 2 attentes + + while( 1 == 1 ) { + + descSockCOM = accept( descSockRDV, ( struct sockaddr * ) &from, &len ); + + if( ( pid= fork() ) == 0) { + + close( descSockRDV ); // On ferme le socketRDV on s'occupe seulement de gérer le socket actuel + + strcpy( buffer, "220 Bienvenue sur le proxyFTP de aurehacks\r\n" ); // Echange de données avec le client connecté + + send( descSockCOM, buffer, strlen( buffer ), 0 ); // Ecriture sur le socket + + while(1 == 1) { // Gestion des commandes + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // Gestion de l'authentification + // ============================================== + + if( strstr( bufferRcv,"USER") ) { + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + + decoupeLogin(bufferRcv,login,serveur); // On isole le loggin ainsi que l'IP/URL du serveur + + strcat(buffer,login); // On formate le login + + sockServeur = socket(AF_INET, SOCK_STREAM, 0); + + getaddrinfo(serveur,"21",&hints,&res); + + connect(sockServeur, res->ai_addr, res->ai_addrlen); + + + + // [1] Message de Bienvenue + // ============================================== + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + + // [2] Envoi de "USER login" + // ============================================== + + send( sockServeur, buffer, strlen( buffer ), 0 ); + send( sockServeur, "\r\n", 2, 0 ); + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + // [3] Réception du "331 password required" et transmission au client + // ============================================== + + strcpy( bufferFTP, "331 required password\r\n" ); // Cas special SINON ON EN DIRECT send( descSockCOM, strcat(bufferFTP,"\r\n"), strlen( bufferFTP ), 0 ); + + send( descSockCOM, bufferFTP, strlen( bufferFTP ), 0 ); + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // ============================================== + + + + // [4] Réception du "PASS mdp" (mot de passe du client) et transmission au serveur + // ============================================== + + send( sockServeur, bufferRcv, strlen( bufferRcv ), 0 ); + send( sockServeur, "\r\n", 2, 0 ); + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + + + // [5] Réception du "220 logged in" et transmission au client + // ============================================== + + strcpy( bufferFTP, "220 Logged IN !\r\n" ); // Cas special SINON ON EN DIRECT send( descSockCOM, strcat(bufferFTP,"\r\n"), strlen( bufferFTP ), 0 ); + + send( descSockCOM, bufferFTP, strlen( bufferFTP ), 0 ); + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // ============================================== + + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + + // Gestion du mode actif + // ============================================== + + if( strncmp( bufferRcv,"PORT", 4 ) ) { + + n = 0; + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + // Gestion du mode passif + // ============================================== + + if( strncmp( bufferRcv,"PASSV", 5 ) ) { + + n = 0; + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + // Gestion de la fermeture de session + // ============================================== + + + if( strncmp( bufferRcv,"QUIT", 4 ) ) { + + break; // On quitte la boucle lorsque que l'on reçoit la commande "QUIT" + } + + } + + freeaddrinfo(res); + + close( descSockCOM ); + close( sockServeur ); + + // Fin du fils + + exit(0); + } + } + + close( descSockRDV ); + + return 0; +} + +// decoupeLogin +// ============================================== + +void decoupeLogin( char *entreeUtilisateur, char *login, char *server ) { + + int i,j = 0; + + for( i=0; i +#include +#include +#include +#include +#define SERVADDR "127.0.0.1" // Définition de l'adresse IP d'écoute +#define SERVPORT "0" // Définition du port d'écoute, si 0 port choisi dynamiquement +#define LISTENLEN 1 // Taille du tampon de demande de connexion +#define MAXBUFFERLEN 1024 +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 + + +int main(){ + int ecode; // Code retour des fonctions + char serverAddr[MAXHOSTLEN]; // Adresse du serveur + char serverPort[MAXPORTLEN]; // Port du server + int descSockRDV; // Descripteur de socket de rendez-vous + int descSockCOM; // Descripteur de socket de communication + struct addrinfo hints; // Contrôle la fonction getaddrinfo + struct addrinfo *res; // Contient le résultat de la fonction getaddrinfo + struct sockaddr_storage myinfo; // Informations sur la connexion de RDV + struct sockaddr_storage from; // Informations sur le client connecté + socklen_t len; // Variable utilisée pour stocker les + // longueurs des structures de socket + char buffer[MAXBUFFERLEN]; // Tampon de communication entre le client et le serveur + // Initialisation de la socket de RDV IPv4/TCP + descSockRDV = socket(AF_INET, SOCK_STREAM, 0); + if (descSockRDV == -1) { + perror("Erreur création socket RDV\n"); + exit(2); + } + // Publication de la socket au niveau du système + // Assignation d'une adresse IP et un numéro de port + // Mise à zéro de hints + memset(&hints, 0, sizeof(hints)); + // Initailisation de hints + hints.ai_flags = AI_PASSIVE; // mode serveur, nous allons utiliser la fonction bind + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_family = AF_INET; // seules les adresses IPv4 seront présentées par + // la fonction getaddrinfo + + // Récupération des informations du serveur + ecode = getaddrinfo(SERVADDR, SERVPORT, &hints, &res); + if (ecode) { + fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecode)); + exit(1); + } + // Publication de la socket + ecode = bind(descSockRDV, res->ai_addr, res->ai_addrlen); + if (ecode == -1) { + perror("Erreur liaison de la socket de RDV"); + exit(3); + } + // Nous n'avons plus besoin de cette liste chainée addrinfo + freeaddrinfo(res); + // Récuppération du nom de la machine et du numéro de port pour affichage à l'écran + + + + + + + + + + len=sizeof(struct sockaddr_storage); + ecode=getsockname(descSockRDV, (struct sockaddr *) &myinfo, &len); + if (ecode == -1) + { + perror("SERVEUR: getsockname"); + exit(4); + } + ecode = getnameinfo((struct sockaddr*)&myinfo, sizeof(myinfo), serverAddr,MAXHOSTLEN, + serverPort, MAXPORTLEN, NI_NUMERICHOST | NI_NUMERICSERV); + if (ecode != 0) { + fprintf(stderr, "error in getnameinfo: %s\n", gai_strerror(ecode)); + exit(4); + } + printf("L'adresse d'ecoute est: %s\n", serverAddr); + printf("Le port d'ecoute est: %s\n", serverPort); + + + + + + // Definition de la taille du tampon contenant les demandes de connexion + ecode = listen(descSockRDV, LISTENLEN); + if (ecode == -1) { + perror("Erreur initialisation buffer d'écoute"); + exit(5); + } + while( 1 ){ + + + + len = sizeof(struct sockaddr_storage); + // Attente connexion du client + // Lorsque demande de connexion, creation d'une socket de communication avec le client + descSockCOM = accept(descSockRDV, (struct sockaddr *) &from, &len); + if (descSockCOM == -1){ + perror("Erreur accept\n"); + exit(6); + } + // Echange de données avec le client connecté + strcpy(buffer, "BLABLABLA\n"); + + write(descSockCOM, buffer, strlen(buffer)); + //Fermeture de la connexion + close(descSockCOM); + + } + close(descSockRDV); +} + + + diff --git a/SEQUENTIAL/proxy_ftp.c b/SEQUENTIAL/proxy_ftp.c new file mode 100644 index 0000000..ce414b7 --- /dev/null +++ b/SEQUENTIAL/proxy_ftp.c @@ -0,0 +1,215 @@ +#include "proxy_ftp.h" + +// DECLARATIONS +static pthread_t userServer; +static short unsigned int userServerState = 1; +static char remoteAssignedPort[maxPortLen] = {'\0'}; + +/* headers */ +static void* testClient(char* host, char* port); +static void* testServer(); +static void* testClientFTP(); + + + + + + + + + + + +/*****************/ +/* CORPS DU PROG */ +/*****************/ +int main(int argc, char* argv[]){ + + /* client */ + if( argc > 2 && strcmp(argv[1],"c") == 0 ) + testClient("localhost", argv[2]); + + /* server */ + else if( argc > 1 && strcmp(argv[1], "s") == 0 ) + testServer(); + + /* clientFTP */ + else if( argc > 1 && strcmp(argv[1], "f") == 0 ) + testClientFTP(); + + /* client + server (multithread) */ + else if( argc > 1 && strcmp(argv[1], "both") == 0 ){ + + pthread_create(&userServer, NULL, &testServer, (void*) NULL); + + // on attends d'avoir le port + while( strlen(remoteAssignedPort) == 0 ); + + // on lance le client en boucle + while( strlen(remoteAssignedPort) != 0 ) + testClient("localhost", remoteAssignedPort); + + pthread_join(userServer, (void*) NULL); + pthread_exit((void*) userServer); + + } + + return EXIT_SUCCESS; +} + + + + + + + + + + + +static void* testClientFTP(){ + CLIENT_FTPREQUEST(FTP_HOST, FTP_PORT); + return; + + // char request[maxBuffLen]; + // char* response; + + // while( 1 ){ + // // on vide les buffers + // memset(&request, '\0', sizeof(request)); + // memset(&response, '\0', sizeof(response)); + + // printf("> "); + // read_stdin(request, maxBuffLen); + // // on supprime le dernier retour chariot + // // request[strlen(request)-1] == '\0'; + + + + // CLIENT_REQUEST(FTP_HOST, FTP_PORT, request, &response); + + // if( strlen(response) > 0 ) + // printf("%s\n", response); + + // response = NULL; + // } + + // return; +} + + +static void* testClient(char* host, char* port){ + char request[maxBuffLen]; + char* response; + + // on vide les buffers + memset(&request, '\0', sizeof(request)); + memset(&response, '\0', sizeof(response)); + + printf("> "); + read_stdin(request, maxBuffLen); + // on supprime le dernier retour chariot + // request[strlen(request)-1] == '\0'; + + + + // CLIENT_REQUEST(remoteHost, remotePort, "GET / HTTP/1.0\r\n\r\n", &response); + CLIENT_REQUEST(host, port, request, &response); + + if( strlen(response) > 0 ) + printf("%s\n", response); + + response = NULL; + + return; +} + + + + +static void* testServer(){ + int SOCKET; // contiendra la connection en cours + char BUFFER[maxBuffLen]; // contiendra le BUFFER + struct sockaddr_storage clientInfo; // contiendra les infos client + char repeat; // sert à sortir de la boucle + int nbReceived, nbSend; // contiendra les nb reçu && envoyé + socklen_t len = sizeof(struct sockaddr_storage); + + // retour de @DROP_SERVER + char* serverPort; // contiendra le port + int LISTENSOCK; // contiendra la socket d'écoute + + + /* [0] On lance @DROP_SERVER + ==========================================================*/ + DROP_SERVER(remoteHost, &serverPort, &LISTENSOCK); + + printf("Port: %s\n", serverPort); + strcpy(remoteAssignedPort, serverPort);// PORT GLOBAL + + while( userServerState ){ + + /* [1] Attente d'une demande de connection, puis création d'une socket + ============================================================================*/ + SOCKET = accept(LISTENSOCK, (struct sockaddr *) &clientInfo, &len); + + if( DEBUGMOD ) printf("SOCKET: %d\n", SOCKET); + + /* [2] On récupère les données reçues + ============================================================================*/ + nbReceived = read(SOCKET, BUFFER, sizeof(BUFFER)-1); + + if( DEBUGMOD ) printf("Recu: %d\n", nbReceived); + if( DEBUGMOD ) printf("Message: %s\n", BUFFER); + + /* [3] Redirection vers le serveur FTP + ============================================================================*/ + // on redirige la réponse vers le serveur FTP distant + char* ftp_response; + CLIENT_REQUEST(FTP_HOST, FTP_PORT, BUFFER, &ftp_response); + // printf("===FTP===\n%s\n", ftp_response); + + /* [4] On analyse et renvoie la réponse à l'utilisateur + ============================================================================*/ + // formatBuffer(ftp_response); + // MANAGE_RESPONSE(&SOCKET, ftp_response); + + // on réponds au client + formatBuffer(ftp_response); + write(SOCKET, ftp_response, strlen(ftp_response)-1); + + + /* [5] On ferme la SOCKET et vide les buffers + ============================================================================*/ + close(SOCKET); + memset(&BUFFER, '\0', sizeof(BUFFER)); // on vide le buffer + ftp_response = NULL; + + + } + + close(LISTENSOCK); + strcpy(remoteAssignedPort, "\0"); +} + + +/* +* DROP_SERVER +* INIT_CLIENT +* +* while(){ +* accept(); +* send +* } +* +* EXIT_CLIENT +* HALT_SERVER +* +* +* +* +* +* +* +* +*/ \ No newline at end of file diff --git a/SEQUENTIAL/proxy_ftp.h b/SEQUENTIAL/proxy_ftp.h new file mode 100644 index 0000000..0ff6983 --- /dev/null +++ b/SEQUENTIAL/proxy_ftp.h @@ -0,0 +1,39 @@ +/* global */ +#include +#include +#include +#include + +/* sys */ +#include +#include + +/* socket */ +#include +#include // getaddrinfo, getnameinfo +#include + +/* basis */ +#define TRUE 1 +#define FALSE 0 + + +/* debug */ +// #define DEBUGMOD FALSE // TRUE = débugmode activé +#define DEBUGMOD TRUE // TRUE = débugmode activé + +/* vars */ +#define remoteHost "localhost" +#define remotePort "80" +#define maxBuffLen 4096 +#define maxListLen 2 +#define maxHostLen 64 +#define maxPortLen 6 + +#define FTP_HOST "31.170.164.47" +#define FTP_PORT "21" + +/* local dependencies */ +#include "dep/utility.c" +#include "dep/client.c" +#include "dep/server.c" diff --git a/SEQUENTIAL/test b/SEQUENTIAL/test new file mode 100755 index 0000000000000000000000000000000000000000..798442f9ab5aa6c00ac2f83845a0b5036fa68373 GIT binary patch literal 18741 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 literal 0 HcmV?d00001 diff --git a/SEQUENTIAL/thread/SEQUENTIAL/backup/client.c b/SEQUENTIAL/thread/SEQUENTIAL/backup/client.c new file mode 100644 index 0000000..efd0a9f --- /dev/null +++ b/SEQUENTIAL/thread/SEQUENTIAL/backup/client.c @@ -0,0 +1,64 @@ +#include +#include +#include +#include +#include +#include +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 +#define MAXBUFFERLEN 1024 +int main(int argc, char* argv[]){ + int descSock; // Descripteur de la socket + int ecode; // Retour des fonctions + struct addrinfo *res; // Résultat de la focntion getaddrinfo + struct addrinfo hints = { // Cette structure permet de contrôler l'exécution de la fonction getaddrinfo + 0, + AF_INET, //seule les adresses IPv4 seront présentées par la fonctiongetaddrinfo + SOCK_STREAM, + 0, + 0, + NULL, + NULL, + NULL + }; + char serverName[MAXHOSTLEN]; // Nom de la machine serveur + char serverPort[MAXPORTLEN]; // Numéro de port + char buffer[MAXBUFFERLEN]; // buffer stockant les messages échangés entre le client et le serveur + //On teste les valeurs rentrées par l'utilisateur + if (argc != 3){ perror("Mauvaise utilisation de la commande: \n"); exit(1);} + if (strlen(argv[1]) >= MAXHOSTLEN){ perror("Le nom de la machine serveur est trop long\n"); exit(2);} + if (strlen(argv[2]) >= MAXPORTLEN){ perror("Le numero de port du serveur est trop long\n"); exit(2);} + strncpy(serverName, argv[1], MAXHOSTLEN); + serverName[MAXHOSTLEN-1] = '\0'; + strncpy(serverPort, argv[2], MAXPORTLEN); + serverPort[MAXPORTLEN-1] = '\0'; + //Création de la socket IPv4/TCP + descSock = socket(AF_INET, SOCK_STREAM, 0); + if (descSock == -1) { + perror("Erreur creation socket"); + exit(4); + } + //Récupération des informations sur le serveur + ecode = getaddrinfo(serverName,serverPort,&hints,&res); + if (ecode){ + fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecode)); + exit(3); + } + //Connexion au serveur + ecode = connect(descSock, res->ai_addr, res->ai_addrlen); + if (ecode == -1) { + close(descSock); + freeaddrinfo(res); + perror("Erreur connect"); + exit(5); + } + freeaddrinfo(res); + //Echange de donneés avec le serveur + ecode = read(descSock, buffer, MAXBUFFERLEN); + if (ecode == -1) {perror("Problème de lecture\n"); exit(6);} + buffer[ecode] = '\0'; + printf("MESSAGE RECU DU SERVEUR: \"%s\".\n",buffer); + //Fermeture de la socket + close(descSock); +} + diff --git a/SEQUENTIAL/thread/SEQUENTIAL/backup/proxy_aure.c b/SEQUENTIAL/thread/SEQUENTIAL/backup/proxy_aure.c new file mode 100644 index 0000000..999e131 --- /dev/null +++ b/SEQUENTIAL/thread/SEQUENTIAL/backup/proxy_aure.c @@ -0,0 +1,336 @@ +// Bibliothéques +// ============================================== + +#include +#include +#include +#include +#include + + +// Constantes +// ============================================== + +#define SERVADDR "127.0.0.1" // Définition de l'adresse IP d'écoute +#define SERVPORT "4444" // Définition du port d'écoute, si 0 port choisi dynamiquement +#define LISTENLEN 2 // Taille du tampon de demandes de connexions, MAX 2 +#define MAXBUFFERLEN 1024 +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 + + +// PROCEDURES +// ============================================== + +void decoupeLogin( char *entreeUtilisateur, char *login, char *server ); +void waitingForUser(int *socket,char *buffer,int *n); +void waitingForServer(int *socket,char *buffer,int *n); + + +// MAIN +// ============================================== + +int main( int argc, char *argv[] ) { + + // Variables [ SERVEUR ] >> [ PROXY ] - [ PROXY ] >> [ SERVEUR ] + // ============================================== + + int sockServeur; // Descripteur pour le socket + int fncRet; // Stock le retour des fonctions + struct addrinfo *resBIS; // Résultat de la focntion getaddrinfo + struct addrinfo hintsBIS = {0, AF_INET, SOCK_STREAM, 0, 0, NULL, NULL, NULL}; // Filtra pour le getaddrinfo + char bufferFTP[MAXBUFFERLEN]; + + // Variables [ CLIENT ] >> [ PROXY ] - [ PROXY ] >> [ CLIENT ] + // ============================================== + + char serverAddr[MAXHOSTLEN]; // Adresse du serveur + char serverPort[MAXPORTLEN]; // Port du server + char buffer[MAXBUFFERLEN]; // Tampon pour écrire sur le socket + char bufferRcv[MAXBUFFERLEN]; // Tampon pour écrire sur le socket + int descSockRDV; // Descripteur de socket de rendez-vous + int ecode; // Code retour des fonctions + int descSockCOM; // Descripteur de socket de communication + int n = 0; + int lenRCV = 0; + + + struct addrinfo hints; // Filtre pour la fonction get_addr_info + struct addrinfo *res; // Resultat get_addr_info + struct sockaddr_storage myinfo; // Informations sur la connexion de RDV + struct sockaddr_storage from; // Informations sur le client connecté + + + char entreeUtilisateur[40]; // login@server + char login[20]; // Isoler le login + char serveur[20]; // Isoler le serveur + + + socklen_t len = sizeof( struct sockaddr_storage ); // Variable utilisée pour stocker les longueurs des structures de socket + + pid_t pid; + + // Initialisation de la socket de RDV IPv4/TCP + + descSockRDV = socket( AF_INET, SOCK_STREAM, 0 ); + + // Mise à zéro de la variable hints,entreeUtilisateur,loggin.. + + memset( &hints, 0, sizeof( hints ) ); + memset( entreeUtilisateur, 0, sizeof( entreeUtilisateur ) ); + memset( login, 0, sizeof( login ) ); + memset( serveur, 0, sizeof( serveur ) ); + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + // Initailisation de la variable hints + + hints.ai_flags = AI_PASSIVE; // mode serveur, nous allons utiliser la fonction bind + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_family = AF_INET; // IPv4 + + // Récupération des informations du serveur > Machine locale + + ecode = getaddrinfo( SERVADDR, SERVPORT, &hints, &res ); + + // Publication de la socket + + ecode = bind( descSockRDV, res->ai_addr, res->ai_addrlen ); + + ecode = listen( descSockRDV, LISTENLEN ); + + // Attente connexion du client + // Lorsque demande de connexion, creation d'un processus fils et d'un socket de communication avec le client, MAX 2 attentes + + while( 1 == 1 ) { + + descSockCOM = accept( descSockRDV, ( struct sockaddr * ) &from, &len ); + + if( ( pid= fork() ) == 0) { + + close( descSockRDV ); // On ferme le socketRDV on s'occupe seulement de gérer le socket actuel + + strcpy( buffer, "220 Bienvenue sur le proxyFTP de aurehacks\r\n" ); // Echange de données avec le client connecté + + send( descSockCOM, buffer, strlen( buffer ), 0 ); // Ecriture sur le socket + + while(1 == 1) { // Gestion des commandes + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // Gestion de l'authentification + // ============================================== + + if( strstr( bufferRcv,"USER") ) { + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + + decoupeLogin(bufferRcv,login,serveur); // On isole le loggin ainsi que l'IP/URL du serveur + + strcat(buffer,login); // On formate le login + + sockServeur = socket(AF_INET, SOCK_STREAM, 0); + + getaddrinfo(serveur,"21",&hints,&res); + + connect(sockServeur, res->ai_addr, res->ai_addrlen); + + + + // [1] Message de Bienvenue + // ============================================== + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + + // [2] Envoi de "USER login" + // ============================================== + + send( sockServeur, buffer, strlen( buffer ), 0 ); + send( sockServeur, "\r\n", 2, 0 ); + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + // [3] Réception du "331 password required" et transmission au client + // ============================================== + + strcpy( bufferFTP, "331 required password\r\n" ); // Cas special SINON ON EN DIRECT send( descSockCOM, strcat(bufferFTP,"\r\n"), strlen( bufferFTP ), 0 ); + + send( descSockCOM, bufferFTP, strlen( bufferFTP ), 0 ); + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // ============================================== + + + + // [4] Réception du "PASS mdp" (mot de passe du client) et transmission au serveur + // ============================================== + + send( sockServeur, bufferRcv, strlen( bufferRcv ), 0 ); + send( sockServeur, "\r\n", 2, 0 ); + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + + + // [5] Réception du "220 logged in" et transmission au client + // ============================================== + + strcpy( bufferFTP, "220 Logged IN !\r\n" ); // Cas special SINON ON EN DIRECT send( descSockCOM, strcat(bufferFTP,"\r\n"), strlen( bufferFTP ), 0 ); + + send( descSockCOM, bufferFTP, strlen( bufferFTP ), 0 ); + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // ============================================== + + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + + // Gestion du mode actif + // ============================================== + + if( strncmp( bufferRcv,"PORT", 4 ) ) { + + n = 0; + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + // Gestion du mode passif + // ============================================== + + if( strncmp( bufferRcv,"PASSV", 5 ) ) { + + n = 0; + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + // Gestion de la fermeture de session + // ============================================== + + + if( strncmp( bufferRcv,"QUIT", 4 ) ) { + + break; // On quitte la boucle lorsque que l'on reçoit la commande "QUIT" + } + + } + + freeaddrinfo(res); + + close( descSockCOM ); + close( sockServeur ); + + // Fin du fils + + exit(0); + } + } + + close( descSockRDV ); + + return 0; +} + +// decoupeLogin +// ============================================== + +void decoupeLogin( char *entreeUtilisateur, char *login, char *server ) { + + int i,j = 0; + + for( i=0; i +#include +#include +#include +#include +#define SERVADDR "127.0.0.1" // Définition de l'adresse IP d'écoute +#define SERVPORT "0" // Définition du port d'écoute, si 0 port choisi dynamiquement +#define LISTENLEN 1 // Taille du tampon de demande de connexion +#define MAXBUFFERLEN 1024 +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 + + +int main(){ + int ecode; // Code retour des fonctions + char serverAddr[MAXHOSTLEN]; // Adresse du serveur + char serverPort[MAXPORTLEN]; // Port du server + int descSockRDV; // Descripteur de socket de rendez-vous + int descSockCOM; // Descripteur de socket de communication + struct addrinfo hints; // Contrôle la fonction getaddrinfo + struct addrinfo *res; // Contient le résultat de la fonction getaddrinfo + struct sockaddr_storage myinfo; // Informations sur la connexion de RDV + struct sockaddr_storage from; // Informations sur le client connecté + socklen_t len; // Variable utilisée pour stocker les + // longueurs des structures de socket + char buffer[MAXBUFFERLEN]; // Tampon de communication entre le client et le serveur + // Initialisation de la socket de RDV IPv4/TCP + descSockRDV = socket(AF_INET, SOCK_STREAM, 0); + if (descSockRDV == -1) { + perror("Erreur création socket RDV\n"); + exit(2); + } + // Publication de la socket au niveau du système + // Assignation d'une adresse IP et un numéro de port + // Mise à zéro de hints + memset(&hints, 0, sizeof(hints)); + // Initailisation de hints + hints.ai_flags = AI_PASSIVE; // mode serveur, nous allons utiliser la fonction bind + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_family = AF_INET; // seules les adresses IPv4 seront présentées par + // la fonction getaddrinfo + + // Récupération des informations du serveur + ecode = getaddrinfo(SERVADDR, SERVPORT, &hints, &res); + if (ecode) { + fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecode)); + exit(1); + } + // Publication de la socket + ecode = bind(descSockRDV, res->ai_addr, res->ai_addrlen); + if (ecode == -1) { + perror("Erreur liaison de la socket de RDV"); + exit(3); + } + // Nous n'avons plus besoin de cette liste chainée addrinfo + freeaddrinfo(res); + // Récuppération du nom de la machine et du numéro de port pour affichage à l'écran + + + + + + + + + + len=sizeof(struct sockaddr_storage); + ecode=getsockname(descSockRDV, (struct sockaddr *) &myinfo, &len); + if (ecode == -1) + { + perror("SERVEUR: getsockname"); + exit(4); + } + ecode = getnameinfo((struct sockaddr*)&myinfo, sizeof(myinfo), serverAddr,MAXHOSTLEN, + serverPort, MAXPORTLEN, NI_NUMERICHOST | NI_NUMERICSERV); + if (ecode != 0) { + fprintf(stderr, "error in getnameinfo: %s\n", gai_strerror(ecode)); + exit(4); + } + printf("L'adresse d'ecoute est: %s\n", serverAddr); + printf("Le port d'ecoute est: %s\n", serverPort); + + + + + + // Definition de la taille du tampon contenant les demandes de connexion + ecode = listen(descSockRDV, LISTENLEN); + if (ecode == -1) { + perror("Erreur initialisation buffer d'écoute"); + exit(5); + } + while( 1 ){ + + + + len = sizeof(struct sockaddr_storage); + // Attente connexion du client + // Lorsque demande de connexion, creation d'une socket de communication avec le client + descSockCOM = accept(descSockRDV, (struct sockaddr *) &from, &len); + if (descSockCOM == -1){ + perror("Erreur accept\n"); + exit(6); + } + // Echange de données avec le client connecté + strcpy(buffer, "BLABLABLA\n"); + + write(descSockCOM, buffer, strlen(buffer)); + //Fermeture de la connexion + close(descSockCOM); + + } + close(descSockRDV); +} + + + diff --git a/SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.c b/SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.c new file mode 100644 index 0000000..ce414b7 --- /dev/null +++ b/SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.c @@ -0,0 +1,215 @@ +#include "proxy_ftp.h" + +// DECLARATIONS +static pthread_t userServer; +static short unsigned int userServerState = 1; +static char remoteAssignedPort[maxPortLen] = {'\0'}; + +/* headers */ +static void* testClient(char* host, char* port); +static void* testServer(); +static void* testClientFTP(); + + + + + + + + + + + +/*****************/ +/* CORPS DU PROG */ +/*****************/ +int main(int argc, char* argv[]){ + + /* client */ + if( argc > 2 && strcmp(argv[1],"c") == 0 ) + testClient("localhost", argv[2]); + + /* server */ + else if( argc > 1 && strcmp(argv[1], "s") == 0 ) + testServer(); + + /* clientFTP */ + else if( argc > 1 && strcmp(argv[1], "f") == 0 ) + testClientFTP(); + + /* client + server (multithread) */ + else if( argc > 1 && strcmp(argv[1], "both") == 0 ){ + + pthread_create(&userServer, NULL, &testServer, (void*) NULL); + + // on attends d'avoir le port + while( strlen(remoteAssignedPort) == 0 ); + + // on lance le client en boucle + while( strlen(remoteAssignedPort) != 0 ) + testClient("localhost", remoteAssignedPort); + + pthread_join(userServer, (void*) NULL); + pthread_exit((void*) userServer); + + } + + return EXIT_SUCCESS; +} + + + + + + + + + + + +static void* testClientFTP(){ + CLIENT_FTPREQUEST(FTP_HOST, FTP_PORT); + return; + + // char request[maxBuffLen]; + // char* response; + + // while( 1 ){ + // // on vide les buffers + // memset(&request, '\0', sizeof(request)); + // memset(&response, '\0', sizeof(response)); + + // printf("> "); + // read_stdin(request, maxBuffLen); + // // on supprime le dernier retour chariot + // // request[strlen(request)-1] == '\0'; + + + + // CLIENT_REQUEST(FTP_HOST, FTP_PORT, request, &response); + + // if( strlen(response) > 0 ) + // printf("%s\n", response); + + // response = NULL; + // } + + // return; +} + + +static void* testClient(char* host, char* port){ + char request[maxBuffLen]; + char* response; + + // on vide les buffers + memset(&request, '\0', sizeof(request)); + memset(&response, '\0', sizeof(response)); + + printf("> "); + read_stdin(request, maxBuffLen); + // on supprime le dernier retour chariot + // request[strlen(request)-1] == '\0'; + + + + // CLIENT_REQUEST(remoteHost, remotePort, "GET / HTTP/1.0\r\n\r\n", &response); + CLIENT_REQUEST(host, port, request, &response); + + if( strlen(response) > 0 ) + printf("%s\n", response); + + response = NULL; + + return; +} + + + + +static void* testServer(){ + int SOCKET; // contiendra la connection en cours + char BUFFER[maxBuffLen]; // contiendra le BUFFER + struct sockaddr_storage clientInfo; // contiendra les infos client + char repeat; // sert à sortir de la boucle + int nbReceived, nbSend; // contiendra les nb reçu && envoyé + socklen_t len = sizeof(struct sockaddr_storage); + + // retour de @DROP_SERVER + char* serverPort; // contiendra le port + int LISTENSOCK; // contiendra la socket d'écoute + + + /* [0] On lance @DROP_SERVER + ==========================================================*/ + DROP_SERVER(remoteHost, &serverPort, &LISTENSOCK); + + printf("Port: %s\n", serverPort); + strcpy(remoteAssignedPort, serverPort);// PORT GLOBAL + + while( userServerState ){ + + /* [1] Attente d'une demande de connection, puis création d'une socket + ============================================================================*/ + SOCKET = accept(LISTENSOCK, (struct sockaddr *) &clientInfo, &len); + + if( DEBUGMOD ) printf("SOCKET: %d\n", SOCKET); + + /* [2] On récupère les données reçues + ============================================================================*/ + nbReceived = read(SOCKET, BUFFER, sizeof(BUFFER)-1); + + if( DEBUGMOD ) printf("Recu: %d\n", nbReceived); + if( DEBUGMOD ) printf("Message: %s\n", BUFFER); + + /* [3] Redirection vers le serveur FTP + ============================================================================*/ + // on redirige la réponse vers le serveur FTP distant + char* ftp_response; + CLIENT_REQUEST(FTP_HOST, FTP_PORT, BUFFER, &ftp_response); + // printf("===FTP===\n%s\n", ftp_response); + + /* [4] On analyse et renvoie la réponse à l'utilisateur + ============================================================================*/ + // formatBuffer(ftp_response); + // MANAGE_RESPONSE(&SOCKET, ftp_response); + + // on réponds au client + formatBuffer(ftp_response); + write(SOCKET, ftp_response, strlen(ftp_response)-1); + + + /* [5] On ferme la SOCKET et vide les buffers + ============================================================================*/ + close(SOCKET); + memset(&BUFFER, '\0', sizeof(BUFFER)); // on vide le buffer + ftp_response = NULL; + + + } + + close(LISTENSOCK); + strcpy(remoteAssignedPort, "\0"); +} + + +/* +* DROP_SERVER +* INIT_CLIENT +* +* while(){ +* accept(); +* send +* } +* +* EXIT_CLIENT +* HALT_SERVER +* +* +* +* +* +* +* +* +*/ \ No newline at end of file diff --git a/SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.h b/SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.h new file mode 100644 index 0000000..0ff6983 --- /dev/null +++ b/SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.h @@ -0,0 +1,39 @@ +/* global */ +#include +#include +#include +#include + +/* sys */ +#include +#include + +/* socket */ +#include +#include // getaddrinfo, getnameinfo +#include + +/* basis */ +#define TRUE 1 +#define FALSE 0 + + +/* debug */ +// #define DEBUGMOD FALSE // TRUE = débugmode activé +#define DEBUGMOD TRUE // TRUE = débugmode activé + +/* vars */ +#define remoteHost "localhost" +#define remotePort "80" +#define maxBuffLen 4096 +#define maxListLen 2 +#define maxHostLen 64 +#define maxPortLen 6 + +#define FTP_HOST "31.170.164.47" +#define FTP_PORT "21" + +/* local dependencies */ +#include "dep/utility.c" +#include "dep/client.c" +#include "dep/server.c" diff --git a/SEQUENTIAL/thread/SEQUENTIAL/test b/SEQUENTIAL/thread/SEQUENTIAL/test new file mode 100755 index 0000000000000000000000000000000000000000..798442f9ab5aa6c00ac2f83845a0b5036fa68373 GIT binary patch literal 18741 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 literal 0 HcmV?d00001 diff --git a/SEQUENTIAL/thread/backup/client.c b/SEQUENTIAL/thread/backup/client.c new file mode 100644 index 0000000..efd0a9f --- /dev/null +++ b/SEQUENTIAL/thread/backup/client.c @@ -0,0 +1,64 @@ +#include +#include +#include +#include +#include +#include +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 +#define MAXBUFFERLEN 1024 +int main(int argc, char* argv[]){ + int descSock; // Descripteur de la socket + int ecode; // Retour des fonctions + struct addrinfo *res; // Résultat de la focntion getaddrinfo + struct addrinfo hints = { // Cette structure permet de contrôler l'exécution de la fonction getaddrinfo + 0, + AF_INET, //seule les adresses IPv4 seront présentées par la fonctiongetaddrinfo + SOCK_STREAM, + 0, + 0, + NULL, + NULL, + NULL + }; + char serverName[MAXHOSTLEN]; // Nom de la machine serveur + char serverPort[MAXPORTLEN]; // Numéro de port + char buffer[MAXBUFFERLEN]; // buffer stockant les messages échangés entre le client et le serveur + //On teste les valeurs rentrées par l'utilisateur + if (argc != 3){ perror("Mauvaise utilisation de la commande: \n"); exit(1);} + if (strlen(argv[1]) >= MAXHOSTLEN){ perror("Le nom de la machine serveur est trop long\n"); exit(2);} + if (strlen(argv[2]) >= MAXPORTLEN){ perror("Le numero de port du serveur est trop long\n"); exit(2);} + strncpy(serverName, argv[1], MAXHOSTLEN); + serverName[MAXHOSTLEN-1] = '\0'; + strncpy(serverPort, argv[2], MAXPORTLEN); + serverPort[MAXPORTLEN-1] = '\0'; + //Création de la socket IPv4/TCP + descSock = socket(AF_INET, SOCK_STREAM, 0); + if (descSock == -1) { + perror("Erreur creation socket"); + exit(4); + } + //Récupération des informations sur le serveur + ecode = getaddrinfo(serverName,serverPort,&hints,&res); + if (ecode){ + fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecode)); + exit(3); + } + //Connexion au serveur + ecode = connect(descSock, res->ai_addr, res->ai_addrlen); + if (ecode == -1) { + close(descSock); + freeaddrinfo(res); + perror("Erreur connect"); + exit(5); + } + freeaddrinfo(res); + //Echange de donneés avec le serveur + ecode = read(descSock, buffer, MAXBUFFERLEN); + if (ecode == -1) {perror("Problème de lecture\n"); exit(6);} + buffer[ecode] = '\0'; + printf("MESSAGE RECU DU SERVEUR: \"%s\".\n",buffer); + //Fermeture de la socket + close(descSock); +} + diff --git a/SEQUENTIAL/thread/backup/proxy_aure.c b/SEQUENTIAL/thread/backup/proxy_aure.c new file mode 100644 index 0000000..999e131 --- /dev/null +++ b/SEQUENTIAL/thread/backup/proxy_aure.c @@ -0,0 +1,336 @@ +// Bibliothéques +// ============================================== + +#include +#include +#include +#include +#include + + +// Constantes +// ============================================== + +#define SERVADDR "127.0.0.1" // Définition de l'adresse IP d'écoute +#define SERVPORT "4444" // Définition du port d'écoute, si 0 port choisi dynamiquement +#define LISTENLEN 2 // Taille du tampon de demandes de connexions, MAX 2 +#define MAXBUFFERLEN 1024 +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 + + +// PROCEDURES +// ============================================== + +void decoupeLogin( char *entreeUtilisateur, char *login, char *server ); +void waitingForUser(int *socket,char *buffer,int *n); +void waitingForServer(int *socket,char *buffer,int *n); + + +// MAIN +// ============================================== + +int main( int argc, char *argv[] ) { + + // Variables [ SERVEUR ] >> [ PROXY ] - [ PROXY ] >> [ SERVEUR ] + // ============================================== + + int sockServeur; // Descripteur pour le socket + int fncRet; // Stock le retour des fonctions + struct addrinfo *resBIS; // Résultat de la focntion getaddrinfo + struct addrinfo hintsBIS = {0, AF_INET, SOCK_STREAM, 0, 0, NULL, NULL, NULL}; // Filtra pour le getaddrinfo + char bufferFTP[MAXBUFFERLEN]; + + // Variables [ CLIENT ] >> [ PROXY ] - [ PROXY ] >> [ CLIENT ] + // ============================================== + + char serverAddr[MAXHOSTLEN]; // Adresse du serveur + char serverPort[MAXPORTLEN]; // Port du server + char buffer[MAXBUFFERLEN]; // Tampon pour écrire sur le socket + char bufferRcv[MAXBUFFERLEN]; // Tampon pour écrire sur le socket + int descSockRDV; // Descripteur de socket de rendez-vous + int ecode; // Code retour des fonctions + int descSockCOM; // Descripteur de socket de communication + int n = 0; + int lenRCV = 0; + + + struct addrinfo hints; // Filtre pour la fonction get_addr_info + struct addrinfo *res; // Resultat get_addr_info + struct sockaddr_storage myinfo; // Informations sur la connexion de RDV + struct sockaddr_storage from; // Informations sur le client connecté + + + char entreeUtilisateur[40]; // login@server + char login[20]; // Isoler le login + char serveur[20]; // Isoler le serveur + + + socklen_t len = sizeof( struct sockaddr_storage ); // Variable utilisée pour stocker les longueurs des structures de socket + + pid_t pid; + + // Initialisation de la socket de RDV IPv4/TCP + + descSockRDV = socket( AF_INET, SOCK_STREAM, 0 ); + + // Mise à zéro de la variable hints,entreeUtilisateur,loggin.. + + memset( &hints, 0, sizeof( hints ) ); + memset( entreeUtilisateur, 0, sizeof( entreeUtilisateur ) ); + memset( login, 0, sizeof( login ) ); + memset( serveur, 0, sizeof( serveur ) ); + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + // Initailisation de la variable hints + + hints.ai_flags = AI_PASSIVE; // mode serveur, nous allons utiliser la fonction bind + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_family = AF_INET; // IPv4 + + // Récupération des informations du serveur > Machine locale + + ecode = getaddrinfo( SERVADDR, SERVPORT, &hints, &res ); + + // Publication de la socket + + ecode = bind( descSockRDV, res->ai_addr, res->ai_addrlen ); + + ecode = listen( descSockRDV, LISTENLEN ); + + // Attente connexion du client + // Lorsque demande de connexion, creation d'un processus fils et d'un socket de communication avec le client, MAX 2 attentes + + while( 1 == 1 ) { + + descSockCOM = accept( descSockRDV, ( struct sockaddr * ) &from, &len ); + + if( ( pid= fork() ) == 0) { + + close( descSockRDV ); // On ferme le socketRDV on s'occupe seulement de gérer le socket actuel + + strcpy( buffer, "220 Bienvenue sur le proxyFTP de aurehacks\r\n" ); // Echange de données avec le client connecté + + send( descSockCOM, buffer, strlen( buffer ), 0 ); // Ecriture sur le socket + + while(1 == 1) { // Gestion des commandes + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // Gestion de l'authentification + // ============================================== + + if( strstr( bufferRcv,"USER") ) { + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + + decoupeLogin(bufferRcv,login,serveur); // On isole le loggin ainsi que l'IP/URL du serveur + + strcat(buffer,login); // On formate le login + + sockServeur = socket(AF_INET, SOCK_STREAM, 0); + + getaddrinfo(serveur,"21",&hints,&res); + + connect(sockServeur, res->ai_addr, res->ai_addrlen); + + + + // [1] Message de Bienvenue + // ============================================== + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + + // [2] Envoi de "USER login" + // ============================================== + + send( sockServeur, buffer, strlen( buffer ), 0 ); + send( sockServeur, "\r\n", 2, 0 ); + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + // [3] Réception du "331 password required" et transmission au client + // ============================================== + + strcpy( bufferFTP, "331 required password\r\n" ); // Cas special SINON ON EN DIRECT send( descSockCOM, strcat(bufferFTP,"\r\n"), strlen( bufferFTP ), 0 ); + + send( descSockCOM, bufferFTP, strlen( bufferFTP ), 0 ); + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // ============================================== + + + + // [4] Réception du "PASS mdp" (mot de passe du client) et transmission au serveur + // ============================================== + + send( sockServeur, bufferRcv, strlen( bufferRcv ), 0 ); + send( sockServeur, "\r\n", 2, 0 ); + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + + + // [5] Réception du "220 logged in" et transmission au client + // ============================================== + + strcpy( bufferFTP, "220 Logged IN !\r\n" ); // Cas special SINON ON EN DIRECT send( descSockCOM, strcat(bufferFTP,"\r\n"), strlen( bufferFTP ), 0 ); + + send( descSockCOM, bufferFTP, strlen( bufferFTP ), 0 ); + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // ============================================== + + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + + // Gestion du mode actif + // ============================================== + + if( strncmp( bufferRcv,"PORT", 4 ) ) { + + n = 0; + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + // Gestion du mode passif + // ============================================== + + if( strncmp( bufferRcv,"PASSV", 5 ) ) { + + n = 0; + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + // Gestion de la fermeture de session + // ============================================== + + + if( strncmp( bufferRcv,"QUIT", 4 ) ) { + + break; // On quitte la boucle lorsque que l'on reçoit la commande "QUIT" + } + + } + + freeaddrinfo(res); + + close( descSockCOM ); + close( sockServeur ); + + // Fin du fils + + exit(0); + } + } + + close( descSockRDV ); + + return 0; +} + +// decoupeLogin +// ============================================== + +void decoupeLogin( char *entreeUtilisateur, char *login, char *server ) { + + int i,j = 0; + + for( i=0; i +#include +#include +#include +#include +#define SERVADDR "127.0.0.1" // Définition de l'adresse IP d'écoute +#define SERVPORT "0" // Définition du port d'écoute, si 0 port choisi dynamiquement +#define LISTENLEN 1 // Taille du tampon de demande de connexion +#define MAXBUFFERLEN 1024 +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 + + +int main(){ + int ecode; // Code retour des fonctions + char serverAddr[MAXHOSTLEN]; // Adresse du serveur + char serverPort[MAXPORTLEN]; // Port du server + int descSockRDV; // Descripteur de socket de rendez-vous + int descSockCOM; // Descripteur de socket de communication + struct addrinfo hints; // Contrôle la fonction getaddrinfo + struct addrinfo *res; // Contient le résultat de la fonction getaddrinfo + struct sockaddr_storage myinfo; // Informations sur la connexion de RDV + struct sockaddr_storage from; // Informations sur le client connecté + socklen_t len; // Variable utilisée pour stocker les + // longueurs des structures de socket + char buffer[MAXBUFFERLEN]; // Tampon de communication entre le client et le serveur + // Initialisation de la socket de RDV IPv4/TCP + descSockRDV = socket(AF_INET, SOCK_STREAM, 0); + if (descSockRDV == -1) { + perror("Erreur création socket RDV\n"); + exit(2); + } + // Publication de la socket au niveau du système + // Assignation d'une adresse IP et un numéro de port + // Mise à zéro de hints + memset(&hints, 0, sizeof(hints)); + // Initailisation de hints + hints.ai_flags = AI_PASSIVE; // mode serveur, nous allons utiliser la fonction bind + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_family = AF_INET; // seules les adresses IPv4 seront présentées par + // la fonction getaddrinfo + + // Récupération des informations du serveur + ecode = getaddrinfo(SERVADDR, SERVPORT, &hints, &res); + if (ecode) { + fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecode)); + exit(1); + } + // Publication de la socket + ecode = bind(descSockRDV, res->ai_addr, res->ai_addrlen); + if (ecode == -1) { + perror("Erreur liaison de la socket de RDV"); + exit(3); + } + // Nous n'avons plus besoin de cette liste chainée addrinfo + freeaddrinfo(res); + // Récuppération du nom de la machine et du numéro de port pour affichage à l'écran + + + + + + + + + + len=sizeof(struct sockaddr_storage); + ecode=getsockname(descSockRDV, (struct sockaddr *) &myinfo, &len); + if (ecode == -1) + { + perror("SERVEUR: getsockname"); + exit(4); + } + ecode = getnameinfo((struct sockaddr*)&myinfo, sizeof(myinfo), serverAddr,MAXHOSTLEN, + serverPort, MAXPORTLEN, NI_NUMERICHOST | NI_NUMERICSERV); + if (ecode != 0) { + fprintf(stderr, "error in getnameinfo: %s\n", gai_strerror(ecode)); + exit(4); + } + printf("L'adresse d'ecoute est: %s\n", serverAddr); + printf("Le port d'ecoute est: %s\n", serverPort); + + + + + + // Definition de la taille du tampon contenant les demandes de connexion + ecode = listen(descSockRDV, LISTENLEN); + if (ecode == -1) { + perror("Erreur initialisation buffer d'écoute"); + exit(5); + } + while( 1 ){ + + + + len = sizeof(struct sockaddr_storage); + // Attente connexion du client + // Lorsque demande de connexion, creation d'une socket de communication avec le client + descSockCOM = accept(descSockRDV, (struct sockaddr *) &from, &len); + if (descSockCOM == -1){ + perror("Erreur accept\n"); + exit(6); + } + // Echange de données avec le client connecté + strcpy(buffer, "BLABLABLA\n"); + + write(descSockCOM, buffer, strlen(buffer)); + //Fermeture de la connexion + close(descSockCOM); + + } + close(descSockRDV); +} + + + diff --git a/SEQUENTIAL/thread/main.c b/SEQUENTIAL/thread/main.c new file mode 100644 index 0000000..989d7b7 --- /dev/null +++ b/SEQUENTIAL/thread/main.c @@ -0,0 +1,55 @@ +#include +#include +#include +#include + +static void* action1(); +static void* action2(); + + +pthread_t thread1, thread2; +static int bool1 = 1; +static int bool2 = 1; + + + +int main(int argc, char* argv []){ + + pthread_create(&thread1, NULL, &action1, (void*) NULL); + pthread_create(&thread2, NULL, &action2, (void*) NULL); + + printf("THREADS CREATED\n===============\n"); + + sleep(3); + bool1 = 0; + sleep(3); + bool2 = 0; + + + + + return EXIT_SUCCESS; +} + + + + + + +static void* action1(){ + while( bool1 ){ + printf("[THREAD] 1\n"); + sleep(1); + } + + pthread_exit((void*) thread1); +} + +static void* action2(){ + while( bool2 ){ + printf("[THREAD] 2\n"); + sleep(1); + } + + pthread_exit((void*) thread2); +} \ No newline at end of file diff --git a/SEQUENTIAL/thread/proxy_ftp.c b/SEQUENTIAL/thread/proxy_ftp.c new file mode 100644 index 0000000..ce414b7 --- /dev/null +++ b/SEQUENTIAL/thread/proxy_ftp.c @@ -0,0 +1,215 @@ +#include "proxy_ftp.h" + +// DECLARATIONS +static pthread_t userServer; +static short unsigned int userServerState = 1; +static char remoteAssignedPort[maxPortLen] = {'\0'}; + +/* headers */ +static void* testClient(char* host, char* port); +static void* testServer(); +static void* testClientFTP(); + + + + + + + + + + + +/*****************/ +/* CORPS DU PROG */ +/*****************/ +int main(int argc, char* argv[]){ + + /* client */ + if( argc > 2 && strcmp(argv[1],"c") == 0 ) + testClient("localhost", argv[2]); + + /* server */ + else if( argc > 1 && strcmp(argv[1], "s") == 0 ) + testServer(); + + /* clientFTP */ + else if( argc > 1 && strcmp(argv[1], "f") == 0 ) + testClientFTP(); + + /* client + server (multithread) */ + else if( argc > 1 && strcmp(argv[1], "both") == 0 ){ + + pthread_create(&userServer, NULL, &testServer, (void*) NULL); + + // on attends d'avoir le port + while( strlen(remoteAssignedPort) == 0 ); + + // on lance le client en boucle + while( strlen(remoteAssignedPort) != 0 ) + testClient("localhost", remoteAssignedPort); + + pthread_join(userServer, (void*) NULL); + pthread_exit((void*) userServer); + + } + + return EXIT_SUCCESS; +} + + + + + + + + + + + +static void* testClientFTP(){ + CLIENT_FTPREQUEST(FTP_HOST, FTP_PORT); + return; + + // char request[maxBuffLen]; + // char* response; + + // while( 1 ){ + // // on vide les buffers + // memset(&request, '\0', sizeof(request)); + // memset(&response, '\0', sizeof(response)); + + // printf("> "); + // read_stdin(request, maxBuffLen); + // // on supprime le dernier retour chariot + // // request[strlen(request)-1] == '\0'; + + + + // CLIENT_REQUEST(FTP_HOST, FTP_PORT, request, &response); + + // if( strlen(response) > 0 ) + // printf("%s\n", response); + + // response = NULL; + // } + + // return; +} + + +static void* testClient(char* host, char* port){ + char request[maxBuffLen]; + char* response; + + // on vide les buffers + memset(&request, '\0', sizeof(request)); + memset(&response, '\0', sizeof(response)); + + printf("> "); + read_stdin(request, maxBuffLen); + // on supprime le dernier retour chariot + // request[strlen(request)-1] == '\0'; + + + + // CLIENT_REQUEST(remoteHost, remotePort, "GET / HTTP/1.0\r\n\r\n", &response); + CLIENT_REQUEST(host, port, request, &response); + + if( strlen(response) > 0 ) + printf("%s\n", response); + + response = NULL; + + return; +} + + + + +static void* testServer(){ + int SOCKET; // contiendra la connection en cours + char BUFFER[maxBuffLen]; // contiendra le BUFFER + struct sockaddr_storage clientInfo; // contiendra les infos client + char repeat; // sert à sortir de la boucle + int nbReceived, nbSend; // contiendra les nb reçu && envoyé + socklen_t len = sizeof(struct sockaddr_storage); + + // retour de @DROP_SERVER + char* serverPort; // contiendra le port + int LISTENSOCK; // contiendra la socket d'écoute + + + /* [0] On lance @DROP_SERVER + ==========================================================*/ + DROP_SERVER(remoteHost, &serverPort, &LISTENSOCK); + + printf("Port: %s\n", serverPort); + strcpy(remoteAssignedPort, serverPort);// PORT GLOBAL + + while( userServerState ){ + + /* [1] Attente d'une demande de connection, puis création d'une socket + ============================================================================*/ + SOCKET = accept(LISTENSOCK, (struct sockaddr *) &clientInfo, &len); + + if( DEBUGMOD ) printf("SOCKET: %d\n", SOCKET); + + /* [2] On récupère les données reçues + ============================================================================*/ + nbReceived = read(SOCKET, BUFFER, sizeof(BUFFER)-1); + + if( DEBUGMOD ) printf("Recu: %d\n", nbReceived); + if( DEBUGMOD ) printf("Message: %s\n", BUFFER); + + /* [3] Redirection vers le serveur FTP + ============================================================================*/ + // on redirige la réponse vers le serveur FTP distant + char* ftp_response; + CLIENT_REQUEST(FTP_HOST, FTP_PORT, BUFFER, &ftp_response); + // printf("===FTP===\n%s\n", ftp_response); + + /* [4] On analyse et renvoie la réponse à l'utilisateur + ============================================================================*/ + // formatBuffer(ftp_response); + // MANAGE_RESPONSE(&SOCKET, ftp_response); + + // on réponds au client + formatBuffer(ftp_response); + write(SOCKET, ftp_response, strlen(ftp_response)-1); + + + /* [5] On ferme la SOCKET et vide les buffers + ============================================================================*/ + close(SOCKET); + memset(&BUFFER, '\0', sizeof(BUFFER)); // on vide le buffer + ftp_response = NULL; + + + } + + close(LISTENSOCK); + strcpy(remoteAssignedPort, "\0"); +} + + +/* +* DROP_SERVER +* INIT_CLIENT +* +* while(){ +* accept(); +* send +* } +* +* EXIT_CLIENT +* HALT_SERVER +* +* +* +* +* +* +* +* +*/ \ No newline at end of file diff --git a/SEQUENTIAL/thread/proxy_ftp.h b/SEQUENTIAL/thread/proxy_ftp.h new file mode 100644 index 0000000..0ff6983 --- /dev/null +++ b/SEQUENTIAL/thread/proxy_ftp.h @@ -0,0 +1,39 @@ +/* global */ +#include +#include +#include +#include + +/* sys */ +#include +#include + +/* socket */ +#include +#include // getaddrinfo, getnameinfo +#include + +/* basis */ +#define TRUE 1 +#define FALSE 0 + + +/* debug */ +// #define DEBUGMOD FALSE // TRUE = débugmode activé +#define DEBUGMOD TRUE // TRUE = débugmode activé + +/* vars */ +#define remoteHost "localhost" +#define remotePort "80" +#define maxBuffLen 4096 +#define maxListLen 2 +#define maxHostLen 64 +#define maxPortLen 6 + +#define FTP_HOST "31.170.164.47" +#define FTP_PORT "21" + +/* local dependencies */ +#include "dep/utility.c" +#include "dep/client.c" +#include "dep/server.c" diff --git a/SEQUENTIAL/thread/test b/SEQUENTIAL/thread/test new file mode 100755 index 0000000000000000000000000000000000000000..798442f9ab5aa6c00ac2f83845a0b5036fa68373 GIT binary patch literal 18741 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 literal 0 HcmV?d00001 diff --git a/SEQUENTIAL/thread/thread/main.c b/SEQUENTIAL/thread/thread/main.c new file mode 100644 index 0000000..989d7b7 --- /dev/null +++ b/SEQUENTIAL/thread/thread/main.c @@ -0,0 +1,55 @@ +#include +#include +#include +#include + +static void* action1(); +static void* action2(); + + +pthread_t thread1, thread2; +static int bool1 = 1; +static int bool2 = 1; + + + +int main(int argc, char* argv []){ + + pthread_create(&thread1, NULL, &action1, (void*) NULL); + pthread_create(&thread2, NULL, &action2, (void*) NULL); + + printf("THREADS CREATED\n===============\n"); + + sleep(3); + bool1 = 0; + sleep(3); + bool2 = 0; + + + + + return EXIT_SUCCESS; +} + + + + + + +static void* action1(){ + while( bool1 ){ + printf("[THREAD] 1\n"); + sleep(1); + } + + pthread_exit((void*) thread1); +} + +static void* action2(){ + while( bool2 ){ + printf("[THREAD] 2\n"); + sleep(1); + } + + pthread_exit((void*) thread2); +} \ No newline at end of file diff --git a/SEQUENTIAL/thread/thread/test b/SEQUENTIAL/thread/thread/test new file mode 100755 index 0000000000000000000000000000000000000000..c7942b766b1ad43e859aaa6d08ba969c9cd9d39e GIT binary patch literal 8915 zcmeHMeQaCR6~DHd#4XfuSs5v1)M6kNq?jgzVnBuGe6%l+l&*Dw4Z^b%yN#J+NA@$M zOt5Zg(X3Kdv1tROvHrm}_JM>Z4Q2eXw(CZPwm%BfHYCQBp@9;hQYH!u2=IRAzH{v7 z7iUA0_Sd+U@44r9KJLf6_uTjH{p!HbR=>}uB>B}1inxUqLqkrk)XW;qG8R)Sm7y+H z>s2d|7W@q@A?lQbF0yN(LDma^uE0O$cYv7R&;_9vIj|BcEhI|y)sw+RhhDVGVTCFc z(E!;|TUAK2ph>5|G|BClVk&mTl3fSeb+EqBS#Fq6=^yot{t5P%@EhQWH;AZyo!2Sp zQrhvlou=|pc62mo5Dea-%h`PacDjFB`#)!4R@uq*EjKPo#)Bz$S6!LQj&AO`GMDbm zW%K2!&Z*eu&doj1QX$%{`%V5yciZ;ex~AGVf}{Se#h>N?$rrZ0a{S@TPygbPpFQ5& zx$VsGb%BSzPqy+$@e`+UXr9+Zo2GB13H~);&Ga8y27dy01b=V313)uBoxmerW$^K3 z@CSi6^P@1{llFKqlS>Ns7WCy( zrBbHk=r`47w^n8>W+3tucofkvk&N}?Mxzi?mqnP1*Lfs!M}WAb|q;&jWQ*Y`#@!$I&yza zzSy25wOahq46=@JQWx8hlf9&f3#a-eZFJ$X21&Nbg}dWT%!Rwxo8iLIkyyUordh&jC&GApm&>mNBe1An?hXGe~as5;xe zVLxFr#EJfi#Q^lp%CF56Z{BG7PMa?-mSOxHDVhggvd@l~mFFG%*VumlmKRn=Fdf$H zhUMG?XvoO(Ezbh-y>pVr$DH1Bdm9w&i)&3-yZcxeQ5pKx()X{eigIi&nTLeQ*+lq zz;@pvyMKPvV7F1*JyEy&5!+Rvw7X==`*i=tNbQS z;5$a*cg9EJcg3xfd+L?GgL$pzJWp{SZy*VC=RmxFSELUlG0?wiOJh=ZI0_??u6nT> z-SDjsT#sp}Xg$wAruC5IAVB*KCEtBJ zm2WESTYqj_@QAN1OgOz`%)$2+q`;}UzEYP$PWmSFCrLLH-Wuw-sr{ULgZtHu7hZqG zRhM2uFzHac??+qp^1neI163lYG7{O7-TTYP$@i1^N6_aC zsOk-czv&+cbvzsx2t^LB7zk~AsKpFzda%_D#irYaLq;wXi-$JFLmPWTk={@T^m{`= zy$`<)a}$1?=uFN&O`ndyrz7zHFapoC8oHZDm`a~HY}VePgr|2lO6NL6C0h(#TFra{ z`xT{iI!A_`nbLZlD}~Uf(}lvboZ=lNk-z(KwLtu%euGHuoA0TB!^^wZjNjo`L5Gsw z%0bW39Nq_+p3hVWZRa{+tEVKfkM%;m)aez5E(t!vytG^DTgm#uBfRSV zOtC(;Ce2H|3(SwQoX!8|M80Fa6@7=F>kpYe%k+7se`5LuQ?EVE7y57O>$@(parbCB zZEyR?%!8A52j@GlhH)7|06gl$}!1%(%6un3~8~<7wCm=U7;&VllPPv5@lJ zV^D+l)I@d+RTtn8Syb2JcpNR2RCKH`F_FpJ-m(5~cv_G2d}RK`{06xCd5o+_4I(35 zcltb-HvGjt;Wxn5&pRTTt7j|fMP2Gb?zXr6hQ@7nc&X;}B6ea7QKni#`vFu<9t=OEpQ}HG*8i->eva#(WBVS@g7?;c9QJf1TH8l?AD44PufCW6J#5=u_CdA} z@;R$l-^;%YTWX@zPbUDB!k^IoRp`>(6MNYQ<(zkx`!DlT>X-TR25jB+%X!oybqY!J z9j?v`{uTsod&Tb|a^Pi(Aycsvde&oavc1U-lyxd@#7_7RP#{eDPscWtlAqAN3SDad zCNgp*u^)C}ROI2TQ96&6y4|WzbNxXvV4;WAeq`;q?PL7nxxf$Za}d&ABmI|gq4n9U z{*4g`kbdfM?ycX^YMuwsx|rWsA`BqfCYs^_WjDoF)ZTyH&H{KFo@uJzs$?H()NfO= zzck`OCHqDrzEa74(1@?9z5h1i=hWhNBYv)uxZH@ZuH7#+;vpq*v=MJt5+57!aP3~C z5nrPuo;Bh)S(iBF5(Ly|l*AtwjQOz^@g(VnbUC2T$9+&U{Ig2pfZHfQUk|drU4j6< zPGsG>VAQ(~>#&)B@2=>qs}<@Wv>Y1}?YX`t?Wg78SF2T|)o9RhWtrZpfn#`+qJ+Mp1 z=Mt^IbY8`PpND?YsXiqMW2VM6)R3itM;Z`^*{|`X^YhR$e!d4hjQQ-Hw@+&QrR(}9 zz}H~@&>1`>iO)Y@#{Y}#-@9J^3Ou4cG-hXjukm-N9qeDE9}tc=4~Zu-e^z3kXxwIb zK4jQnoyNtwPOkzUM*F8c{^>rO{K)&HSlr0^-toDa_37S)(gB_0j2n1_%WjeePUA*b z6qID#a)hJ5UjKBT9nqSN*(1O)tCpl6XuL^0A1m4=yNr|mG2Hgu)VI?b8r+qzELFdP zwCo9Mj4mNdO70n5kY%L{*4|uUG?lZ`cA;3ZQspUyFWSjm#?GXpo3Fj*DtK<9WYM>^ z^QCOz>$kX1Ip5al^2EeGn7BBLKFJ$Y>3R}P9xW7dT{`bpsWBU0_+3o9;bH5}`0#)= zu)QDsaXKgE27hT~^?z}De0Z=AS}uvc2vyd$p<8<6L)I-@x9%E9Sc!P=&;Ys9cco*c zvhIfGe$_DCSEc{%N|#OnocmRM6YDX|=tBah2IrEvOKPs)(t2zxmrKw6EgnOuV2!8p zX}U}vyag4fvw5pr%3uiU9ikzqb%<_{JvC(VQ0Kw1aDc&O=f=3n6}8iHdLX#Xmd8QY S+%laSF1htxw5LYhqJII3W+HU} literal 0 HcmV?d00001 diff --git a/backup/client.c b/backup/client.c new file mode 100644 index 0000000..efd0a9f --- /dev/null +++ b/backup/client.c @@ -0,0 +1,64 @@ +#include +#include +#include +#include +#include +#include +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 +#define MAXBUFFERLEN 1024 +int main(int argc, char* argv[]){ + int descSock; // Descripteur de la socket + int ecode; // Retour des fonctions + struct addrinfo *res; // Résultat de la focntion getaddrinfo + struct addrinfo hints = { // Cette structure permet de contrôler l'exécution de la fonction getaddrinfo + 0, + AF_INET, //seule les adresses IPv4 seront présentées par la fonctiongetaddrinfo + SOCK_STREAM, + 0, + 0, + NULL, + NULL, + NULL + }; + char serverName[MAXHOSTLEN]; // Nom de la machine serveur + char serverPort[MAXPORTLEN]; // Numéro de port + char buffer[MAXBUFFERLEN]; // buffer stockant les messages échangés entre le client et le serveur + //On teste les valeurs rentrées par l'utilisateur + if (argc != 3){ perror("Mauvaise utilisation de la commande: \n"); exit(1);} + if (strlen(argv[1]) >= MAXHOSTLEN){ perror("Le nom de la machine serveur est trop long\n"); exit(2);} + if (strlen(argv[2]) >= MAXPORTLEN){ perror("Le numero de port du serveur est trop long\n"); exit(2);} + strncpy(serverName, argv[1], MAXHOSTLEN); + serverName[MAXHOSTLEN-1] = '\0'; + strncpy(serverPort, argv[2], MAXPORTLEN); + serverPort[MAXPORTLEN-1] = '\0'; + //Création de la socket IPv4/TCP + descSock = socket(AF_INET, SOCK_STREAM, 0); + if (descSock == -1) { + perror("Erreur creation socket"); + exit(4); + } + //Récupération des informations sur le serveur + ecode = getaddrinfo(serverName,serverPort,&hints,&res); + if (ecode){ + fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecode)); + exit(3); + } + //Connexion au serveur + ecode = connect(descSock, res->ai_addr, res->ai_addrlen); + if (ecode == -1) { + close(descSock); + freeaddrinfo(res); + perror("Erreur connect"); + exit(5); + } + freeaddrinfo(res); + //Echange de donneés avec le serveur + ecode = read(descSock, buffer, MAXBUFFERLEN); + if (ecode == -1) {perror("Problème de lecture\n"); exit(6);} + buffer[ecode] = '\0'; + printf("MESSAGE RECU DU SERVEUR: \"%s\".\n",buffer); + //Fermeture de la socket + close(descSock); +} + diff --git a/backup/proxy_aure.c b/backup/proxy_aure.c new file mode 100644 index 0000000..999e131 --- /dev/null +++ b/backup/proxy_aure.c @@ -0,0 +1,336 @@ +// Bibliothéques +// ============================================== + +#include +#include +#include +#include +#include + + +// Constantes +// ============================================== + +#define SERVADDR "127.0.0.1" // Définition de l'adresse IP d'écoute +#define SERVPORT "4444" // Définition du port d'écoute, si 0 port choisi dynamiquement +#define LISTENLEN 2 // Taille du tampon de demandes de connexions, MAX 2 +#define MAXBUFFERLEN 1024 +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 + + +// PROCEDURES +// ============================================== + +void decoupeLogin( char *entreeUtilisateur, char *login, char *server ); +void waitingForUser(int *socket,char *buffer,int *n); +void waitingForServer(int *socket,char *buffer,int *n); + + +// MAIN +// ============================================== + +int main( int argc, char *argv[] ) { + + // Variables [ SERVEUR ] >> [ PROXY ] - [ PROXY ] >> [ SERVEUR ] + // ============================================== + + int sockServeur; // Descripteur pour le socket + int fncRet; // Stock le retour des fonctions + struct addrinfo *resBIS; // Résultat de la focntion getaddrinfo + struct addrinfo hintsBIS = {0, AF_INET, SOCK_STREAM, 0, 0, NULL, NULL, NULL}; // Filtra pour le getaddrinfo + char bufferFTP[MAXBUFFERLEN]; + + // Variables [ CLIENT ] >> [ PROXY ] - [ PROXY ] >> [ CLIENT ] + // ============================================== + + char serverAddr[MAXHOSTLEN]; // Adresse du serveur + char serverPort[MAXPORTLEN]; // Port du server + char buffer[MAXBUFFERLEN]; // Tampon pour écrire sur le socket + char bufferRcv[MAXBUFFERLEN]; // Tampon pour écrire sur le socket + int descSockRDV; // Descripteur de socket de rendez-vous + int ecode; // Code retour des fonctions + int descSockCOM; // Descripteur de socket de communication + int n = 0; + int lenRCV = 0; + + + struct addrinfo hints; // Filtre pour la fonction get_addr_info + struct addrinfo *res; // Resultat get_addr_info + struct sockaddr_storage myinfo; // Informations sur la connexion de RDV + struct sockaddr_storage from; // Informations sur le client connecté + + + char entreeUtilisateur[40]; // login@server + char login[20]; // Isoler le login + char serveur[20]; // Isoler le serveur + + + socklen_t len = sizeof( struct sockaddr_storage ); // Variable utilisée pour stocker les longueurs des structures de socket + + pid_t pid; + + // Initialisation de la socket de RDV IPv4/TCP + + descSockRDV = socket( AF_INET, SOCK_STREAM, 0 ); + + // Mise à zéro de la variable hints,entreeUtilisateur,loggin.. + + memset( &hints, 0, sizeof( hints ) ); + memset( entreeUtilisateur, 0, sizeof( entreeUtilisateur ) ); + memset( login, 0, sizeof( login ) ); + memset( serveur, 0, sizeof( serveur ) ); + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + // Initailisation de la variable hints + + hints.ai_flags = AI_PASSIVE; // mode serveur, nous allons utiliser la fonction bind + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_family = AF_INET; // IPv4 + + // Récupération des informations du serveur > Machine locale + + ecode = getaddrinfo( SERVADDR, SERVPORT, &hints, &res ); + + // Publication de la socket + + ecode = bind( descSockRDV, res->ai_addr, res->ai_addrlen ); + + ecode = listen( descSockRDV, LISTENLEN ); + + // Attente connexion du client + // Lorsque demande de connexion, creation d'un processus fils et d'un socket de communication avec le client, MAX 2 attentes + + while( 1 == 1 ) { + + descSockCOM = accept( descSockRDV, ( struct sockaddr * ) &from, &len ); + + if( ( pid= fork() ) == 0) { + + close( descSockRDV ); // On ferme le socketRDV on s'occupe seulement de gérer le socket actuel + + strcpy( buffer, "220 Bienvenue sur le proxyFTP de aurehacks\r\n" ); // Echange de données avec le client connecté + + send( descSockCOM, buffer, strlen( buffer ), 0 ); // Ecriture sur le socket + + while(1 == 1) { // Gestion des commandes + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // Gestion de l'authentification + // ============================================== + + if( strstr( bufferRcv,"USER") ) { + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + + decoupeLogin(bufferRcv,login,serveur); // On isole le loggin ainsi que l'IP/URL du serveur + + strcat(buffer,login); // On formate le login + + sockServeur = socket(AF_INET, SOCK_STREAM, 0); + + getaddrinfo(serveur,"21",&hints,&res); + + connect(sockServeur, res->ai_addr, res->ai_addrlen); + + + + // [1] Message de Bienvenue + // ============================================== + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + + // [2] Envoi de "USER login" + // ============================================== + + send( sockServeur, buffer, strlen( buffer ), 0 ); + send( sockServeur, "\r\n", 2, 0 ); + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + // [3] Réception du "331 password required" et transmission au client + // ============================================== + + strcpy( bufferFTP, "331 required password\r\n" ); // Cas special SINON ON EN DIRECT send( descSockCOM, strcat(bufferFTP,"\r\n"), strlen( bufferFTP ), 0 ); + + send( descSockCOM, bufferFTP, strlen( bufferFTP ), 0 ); + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // ============================================== + + + + // [4] Réception du "PASS mdp" (mot de passe du client) et transmission au serveur + // ============================================== + + send( sockServeur, bufferRcv, strlen( bufferRcv ), 0 ); + send( sockServeur, "\r\n", 2, 0 ); + + waitingForServer(&sockServeur,bufferFTP,&n); + + // ============================================== + + + + + // [5] Réception du "220 logged in" et transmission au client + // ============================================== + + strcpy( bufferFTP, "220 Logged IN !\r\n" ); // Cas special SINON ON EN DIRECT send( descSockCOM, strcat(bufferFTP,"\r\n"), strlen( bufferFTP ), 0 ); + + send( descSockCOM, bufferFTP, strlen( bufferFTP ), 0 ); + + waitingForUser(&descSockCOM,bufferRcv,&n); + + // ============================================== + + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + + // Gestion du mode actif + // ============================================== + + if( strncmp( bufferRcv,"PORT", 4 ) ) { + + n = 0; + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + // Gestion du mode passif + // ============================================== + + if( strncmp( bufferRcv,"PASSV", 5 ) ) { + + n = 0; + + // On clean les buffers + + memset( buffer, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferRcv, 0, sizeof( MAXBUFFERLEN ) ); + memset( bufferFTP, 0, sizeof( MAXBUFFERLEN ) ); + + + } + + // Gestion de la fermeture de session + // ============================================== + + + if( strncmp( bufferRcv,"QUIT", 4 ) ) { + + break; // On quitte la boucle lorsque que l'on reçoit la commande "QUIT" + } + + } + + freeaddrinfo(res); + + close( descSockCOM ); + close( sockServeur ); + + // Fin du fils + + exit(0); + } + } + + close( descSockRDV ); + + return 0; +} + +// decoupeLogin +// ============================================== + +void decoupeLogin( char *entreeUtilisateur, char *login, char *server ) { + + int i,j = 0; + + for( i=0; i +#include +#include +#include +#include +#define SERVADDR "127.0.0.1" // Définition de l'adresse IP d'écoute +#define SERVPORT "0" // Définition du port d'écoute, si 0 port choisi dynamiquement +#define LISTENLEN 1 // Taille du tampon de demande de connexion +#define MAXBUFFERLEN 1024 +#define MAXHOSTLEN 64 +#define MAXPORTLEN 6 + + +int main(){ + int ecode; // Code retour des fonctions + char serverAddr[MAXHOSTLEN]; // Adresse du serveur + char serverPort[MAXPORTLEN]; // Port du server + int descSockRDV; // Descripteur de socket de rendez-vous + int descSockCOM; // Descripteur de socket de communication + struct addrinfo hints; // Contrôle la fonction getaddrinfo + struct addrinfo *res; // Contient le résultat de la fonction getaddrinfo + struct sockaddr_storage myinfo; // Informations sur la connexion de RDV + struct sockaddr_storage from; // Informations sur le client connecté + socklen_t len; // Variable utilisée pour stocker les + // longueurs des structures de socket + char buffer[MAXBUFFERLEN]; // Tampon de communication entre le client et le serveur + // Initialisation de la socket de RDV IPv4/TCP + descSockRDV = socket(AF_INET, SOCK_STREAM, 0); + if (descSockRDV == -1) { + perror("Erreur création socket RDV\n"); + exit(2); + } + // Publication de la socket au niveau du système + // Assignation d'une adresse IP et un numéro de port + // Mise à zéro de hints + memset(&hints, 0, sizeof(hints)); + // Initailisation de hints + hints.ai_flags = AI_PASSIVE; // mode serveur, nous allons utiliser la fonction bind + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_family = AF_INET; // seules les adresses IPv4 seront présentées par + // la fonction getaddrinfo + + // Récupération des informations du serveur + ecode = getaddrinfo(SERVADDR, SERVPORT, &hints, &res); + if (ecode) { + fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecode)); + exit(1); + } + // Publication de la socket + ecode = bind(descSockRDV, res->ai_addr, res->ai_addrlen); + if (ecode == -1) { + perror("Erreur liaison de la socket de RDV"); + exit(3); + } + // Nous n'avons plus besoin de cette liste chainée addrinfo + freeaddrinfo(res); + // Récuppération du nom de la machine et du numéro de port pour affichage à l'écran + + + + + + + + + + len=sizeof(struct sockaddr_storage); + ecode=getsockname(descSockRDV, (struct sockaddr *) &myinfo, &len); + if (ecode == -1) + { + perror("SERVEUR: getsockname"); + exit(4); + } + ecode = getnameinfo((struct sockaddr*)&myinfo, sizeof(myinfo), serverAddr,MAXHOSTLEN, + serverPort, MAXPORTLEN, NI_NUMERICHOST | NI_NUMERICSERV); + if (ecode != 0) { + fprintf(stderr, "error in getnameinfo: %s\n", gai_strerror(ecode)); + exit(4); + } + printf("L'adresse d'ecoute est: %s\n", serverAddr); + printf("Le port d'ecoute est: %s\n", serverPort); + + + + + + // Definition de la taille du tampon contenant les demandes de connexion + ecode = listen(descSockRDV, LISTENLEN); + if (ecode == -1) { + perror("Erreur initialisation buffer d'écoute"); + exit(5); + } + while( 1 ){ + + + + len = sizeof(struct sockaddr_storage); + // Attente connexion du client + // Lorsque demande de connexion, creation d'une socket de communication avec le client + descSockCOM = accept(descSockRDV, (struct sockaddr *) &from, &len); + if (descSockCOM == -1){ + perror("Erreur accept\n"); + exit(6); + } + // Echange de données avec le client connecté + strcpy(buffer, "BLABLABLA\n"); + + write(descSockCOM, buffer, strlen(buffer)); + //Fermeture de la connexion + close(descSockCOM); + + } + close(descSockRDV); +} + + + diff --git a/dep/client.c b/dep/client.c new file mode 100644 index 0000000..7e05772 --- /dev/null +++ b/dep/client.c @@ -0,0 +1,193 @@ +#include "client.h" + + + + + + + +void CLIENT_REQUEST(char* serverHost, char* serverPort, char* pRequest, char** pAnswer){ + if( DEBUGMOD ) printf("====== CLIENT_REQUEST(%s, %s, %s, %s) ======\n\n", serverHost, serverPort, pRequest, *pAnswer); + + struct addrinfo hints; // contiendra le filtre/format + struct addrinfo* addrinfo; // contiendra les infos + int SOCKET, CONNECT; // file_desc(s) + char BUFFER[maxBuffLen]; // BUFFER de communication + // char pAnswer[maxBuffLen] = {0}; // on vide la réponse (contiendra la réponse du serveur) + + /* [1] On définit le filtre/format + =======================================================*/ + memset(&hints, 0, sizeof(struct addrinfo)); // on vide le filtre + hints.ai_family = AF_UNSPEC; // Allow IPv4 ou IPv6 + hints.ai_socktype = SOCK_STREAM; // TCP (SOCK_DGRAM = UDP) + hints.ai_flags = 0; // non spécifié + hints.ai_protocol = 0; // non spécifié + + if( DEBUGMOD ) printf("============HINTS===========\n"); + if( DEBUGMOD ) printf( "AI_FLAGS = %d\n", hints.ai_flags ); // int + if( DEBUGMOD ) printf( "AI_FAMILY = %d\n", hints.ai_family ); // int + if( DEBUGMOD ) printf( "AI_SOCKTYPE = %d\n", hints.ai_socktype ); // int + if( DEBUGMOD ) printf( "AI_PROTOCOL = %d\n", hints.ai_protocol ); // int + if( DEBUGMOD ) printf( "AI_ADDRLEN = %d\n", hints.ai_addrlen ); // int + if( DEBUGMOD ) printf("\n"); + + + /* [2] On récupère les infos + =======================================================*/ + getaddrinfo(serverHost, serverPort, &hints, &addrinfo); + + if( DEBUGMOD ) printf("=============RES============\n"); + if( DEBUGMOD ) printf( "AI_FLAGS = %d\n", addrinfo->ai_flags ); // int + if( DEBUGMOD ) printf( "AI_FAMILY = %d\n", addrinfo->ai_family ); // int + if( DEBUGMOD ) printf( "AI_SOCKTYPE = %d\n", addrinfo->ai_socktype ); // int + if( DEBUGMOD ) printf( "AI_PROTOCOL = %d\n", addrinfo->ai_protocol ); // int + if( DEBUGMOD ) printf( "AI_ADDRLEN = %d\n", addrinfo->ai_addrlen ); // int + if( DEBUGMOD ) printf("\n"); + + /* [3] Création de la socket + =======================================================*/ + SOCKET = socket(addrinfo->ai_family, addrinfo->ai_socktype, 0); + + if( DEBUGMOD ) printf("SOCKET = %d\n", SOCKET); + + // si erreur + if( SOCKET == -1 ) return; + + /* [4] On établit la connection + =======================================================*/ + CONNECT = connect( + SOCKET, + addrinfo->ai_addr, + addrinfo->ai_addrlen + ); + + if( DEBUGMOD ) printf("CONNECT = %d\n", CONNECT); + + // si erreur + if( CONNECT == -1 ) return; + + // on a plus besoin des infos de l'adresse + freeaddrinfo(addrinfo); + + + /* [5] On écrit sur la socket + =======================================================*/ + int nbSend = swrite(&SOCKET, pRequest); + + if( DEBUGMOD ) printf("nbSend: %d\n", nbSend); + if( DEBUGMOD ) printf("Message: %s\n", pRequest); + + // si pas tout envoyé + if( strlen(pRequest) != nbSend ) return; + + /* [6] On lit la réponse + =======================================================*/ + // memset(BUFFER, '\0', sizeof(BUFFER)); // on vide le buffer + int nbRecup = sread(&SOCKET, BUFFER); + + *pAnswer = malloc( sizeof(BUFFER) ); + strcpy(*pAnswer, BUFFER); + + if( DEBUGMOD ) printf("nbReceived: %d\n", nbRecup); + if( DEBUGMOD ) printf("Message: %s\n", *pAnswer); + + + /* [7] On ferme la connection + =======================================================*/ + int closeState = close(SOCKET); + + // if( closeState == -1 ) return; +} + + + + +void CONNECT_CLIENT(char* serverHost, char* serverPort, int* pSocket){ + if( DEBUGMOD ) printf("====== INIT_CLIENT(%s, %s, %d) ======\n\n", serverHost, serverPort, *pSocket); + + struct addrinfo hints; // contiendra le filtre/format + struct addrinfo* addrinfo; // contiendra les infos + int CONNECT; // file_desc(s) + char BUFFER[maxBuffLen]; // BUFFER de communication + // char pAnswer[maxBuffLen] = {0}; // on vide la réponse (contiendra la réponse du serveur) + + /* [1] On définit le filtre/format + =======================================================*/ + memset(&hints, 0, sizeof(struct addrinfo)); // on vide le filtre + hints.ai_family = AF_UNSPEC; // Allow IPv4 ou IPv6 + hints.ai_socktype = SOCK_STREAM; // TCP (SOCK_DGRAM = UDP) + hints.ai_flags = 0; // non spécifié + hints.ai_protocol = 0; // non spécifié + + if( DEBUGMOD ) printf("============HINTS===========\n"); + if( DEBUGMOD ) printf( "AI_FLAGS = %d\n", hints.ai_flags ); // int + if( DEBUGMOD ) printf( "AI_FAMILY = %d\n", hints.ai_family ); // int + if( DEBUGMOD ) printf( "AI_SOCKTYPE = %d\n", hints.ai_socktype ); // int + if( DEBUGMOD ) printf( "AI_PROTOCOL = %d\n", hints.ai_protocol ); // int + if( DEBUGMOD ) printf( "AI_ADDRLEN = %d\n", hints.ai_addrlen ); // int + if( DEBUGMOD ) printf("\n"); + + + /* [2] On récupère les infos + =======================================================*/ + getaddrinfo(serverHost, serverPort, &hints, &addrinfo); + + if( DEBUGMOD ) printf("=============RES============\n"); + if( DEBUGMOD ) printf( "AI_FLAGS = %d\n", addrinfo->ai_flags ); // int + if( DEBUGMOD ) printf( "AI_FAMILY = %d\n", addrinfo->ai_family ); // int + if( DEBUGMOD ) printf( "AI_SOCKTYPE = %d\n", addrinfo->ai_socktype ); // int + if( DEBUGMOD ) printf( "AI_PROTOCOL = %d\n", addrinfo->ai_protocol ); // int + if( DEBUGMOD ) printf( "AI_ADDRLEN = %d\n", addrinfo->ai_addrlen ); // int + if( DEBUGMOD ) printf("\n"); + + /* [3] Création de la socket + =======================================================*/ + *pSocket = socket(addrinfo->ai_family, addrinfo->ai_socktype, 0); + + if( DEBUGMOD ) printf("SOCKET = %d\n", *pSocket); + + // si erreur + if( *pSocket == -1 ) return; + + /* [4] On établit la connection + =======================================================*/ + CONNECT = connect( + *pSocket, + addrinfo->ai_addr, + addrinfo->ai_addrlen + ); + + if( DEBUGMOD ) printf("CONNECT = %d\n", CONNECT); + + // si erreur + if( CONNECT == -1 ) return; + + // on a plus besoin des infos de l'adresse + freeaddrinfo(addrinfo); +} + + + +void CLIENT_SEND(int* pSocket, char* pRequest, char** pAnswer){ + char BUFFER[maxBuffLen] = {'\0'}; + + /* [5] On écrit sur la socket + =======================================================*/ + int nbSend = swrite(pSocket, pRequest); + + if( DEBUGMOD ) printf("nbSend: %d\n", nbSend); + if( DEBUGMOD ) printf("Message: %s\n", pRequest); + + // si pas tout envoyé + if( strlen(pRequest) != nbSend ) return; + + /* [6] On lit la réponse + =======================================================*/ + int nbRecup = sread(pSocket, BUFFER); + + *pAnswer = malloc( sizeof(BUFFER) ); + strcpy(*pAnswer, BUFFER); + + if( DEBUGMOD ) printf("nbReceived: %d\n", nbRecup); + if( DEBUGMOD ) printf("Message: %s\n", *pAnswer); +} \ No newline at end of file diff --git a/dep/client.h b/dep/client.h new file mode 100644 index 0000000..7b87ec1 --- /dev/null +++ b/dep/client.h @@ -0,0 +1,17 @@ +/* Envoi d'une requête à un serveur et réception de la réponse +* +* @serverHost Nom de l'hôte distant (server) +* @serverPort Numéro du port distant (server) +* @pRequest Requête à envoyer au serveur +* +* @pAnswer Pointeur sur le à remplir => contiendra la réponse du serveur +* +*/ +void CLIENT_REQUEST(char* serverHost, char* serverPort, char* pRequest, char** pAnswer); + + + +void CONNECT_CLIENT(char* serverHost, char* serverPort, int* pSocket); + + +void CLIENT_SEND(int* pSocket, char* pRequest, char** pAnswer); \ No newline at end of file diff --git a/dep/server.c b/dep/server.c new file mode 100644 index 0000000..57391f3 --- /dev/null +++ b/dep/server.c @@ -0,0 +1,283 @@ +#include "server.h" + + + + + + + +void DROP_SERVER(char* serverHost, char** givenPort, int* listenSocket){ + if( DEBUGMOD ) printf("====== DROP_SERVER(%s, %s, %d) ======\n\n", serverHost, *givenPort, *listenSocket); + + // FONCTIONNEMENT + struct addrinfo hints; // contiendra le filtre/format + struct addrinfo* addrinfo; // contiendra les infos du serveur + int SOCKET, BIND, LISTEN; // file_desc(s) + + // INFOS + struct sockaddr_storage serverInfo; // contiendra les informations du server + socklen_t sockaddr_len = sizeof(struct sockaddr_storage); + char infoHost[maxHostLen]; // contiendra l'adresse du server + char infoPort[maxPortLen]; // contiendra le port du server + + /* [1] On définit le filtre/format + =======================================================*/ + memset(&hints, 0, sizeof(struct addrinfo)); // on vide le filtre + hints.ai_family = AF_UNSPEC; // Allow IPv4 ou IPv6 + hints.ai_socktype = SOCK_STREAM; // TCP (SOCK_DGRAM = UDP) + hints.ai_flags = AI_PASSIVE; // mode SERVER + hints.ai_protocol = 0; // non spécifié + + if( DEBUGMOD ) printf("============HINTS===========\n"); + if( DEBUGMOD ) printf( "AI_FLAGS = %d\n", hints.ai_flags ); // int + if( DEBUGMOD ) printf( "AI_FAMILY = %d\n", hints.ai_family ); // int + if( DEBUGMOD ) printf( "AI_SOCKTYPE = %d\n", hints.ai_socktype ); // int + if( DEBUGMOD ) printf( "AI_PROTOCOL = %d\n", hints.ai_protocol ); // int + if( DEBUGMOD ) printf( "AI_ADDRLEN = %d\n", hints.ai_addrlen ); // int + if( DEBUGMOD ) printf("\n"); + + + /* [2] On récupère les infos + =======================================================*/ + if( strlen(*givenPort) == 0 ) // si pas défini, port dynamique + getaddrinfo(serverHost, 0, &hints, &addrinfo); + else // sinon manuel + getaddrinfo(serverHost, *givenPort, &hints, &addrinfo); + // Remarque: port=0 donc va être défini dynamiquement + + if( DEBUGMOD ) printf("=============RES============\n"); + if( DEBUGMOD ) printf( "AI_FLAGS = %d\n", addrinfo->ai_flags ); // int + if( DEBUGMOD ) printf( "AI_FAMILY = %d\n", addrinfo->ai_family ); // int + if( DEBUGMOD ) printf( "AI_SOCKTYPE = %d\n", addrinfo->ai_socktype ); // int + if( DEBUGMOD ) printf( "AI_PROTOCOL = %d\n", addrinfo->ai_protocol ); // int + if( DEBUGMOD ) printf( "AI_ADDRLEN = %d\n", addrinfo->ai_addrlen ); // int + if( DEBUGMOD ) printf("\n"); + + /* [3] Création de la socket + =======================================================*/ + + SOCKET = socket(addrinfo->ai_family, addrinfo->ai_socktype, 0); + + if( DEBUGMOD ) printf("SOCKET = %d\n", SOCKET); + + // si erreur + if( SOCKET == -1 ) return; + + /* [4] On publie la SOCKET + =======================================================*/ + BIND = bind( + SOCKET, + addrinfo->ai_addr, + addrinfo->ai_addrlen + ); + + if( DEBUGMOD ) printf("BIND = %d\n", BIND); + + // si erreur + if( BIND == -1 ) return; + + /* [5] On récupère les informations du serveur (host/port) + =======================================================*/ + int getInfo = getsockname(SOCKET, (struct sockaddr *) &serverInfo, &sockaddr_len); + + if( getInfo == -1 ) return; + + getInfo = getnameinfo( // on récupère le host et le port + (struct sockaddr *) &serverInfo, + sizeof(serverInfo), + infoHost, maxHostLen, + infoPort, maxPortLen, + NI_NUMERICHOST | NI_NUMERICSERV + ); + + if( getInfo == -1 ) return; + + if( DEBUGMOD ) printf("Server host: %s\n", infoHost); + if( DEBUGMOD ) printf("Server port: %s\n", infoPort); + + + // on a plus besoin des infos de l'adresse + freeaddrinfo(addrinfo); + + + /* [6] On met la socket sur écoute + =======================================================*/ + LISTEN = listen(SOCKET, maxListLen); + + if( DEBUGMOD ) printf("LISTEN = %d\n", LISTEN); + + // si erreur + if( LISTEN == -1 ) return; + + /* [7] On envoie les données par référence + =======================================================*/ + // port + *givenPort = malloc( sizeof(infoPort) ); + strcpy(*givenPort, infoPort); + + // socket d'écoute + *listenSocket = SOCKET; +} + + + + + + +// CMD: CLIENT (SRV) PROXY (CLT) FTP +// DTA: CLIENT (CLT) PROXY (CLT) FTP +// +// +// +// [1] Ecoute sur port p de localhost +// [2-n] Si commande, envoi à FTP +// Puis Reception de FTP, envoi à CLIENT + + +void MANAGE_REQUEST(int* SOCKET, char* pRequest){ + if( DEBUGMOD ) printf("====== MANAGE_REQUEST(%d, %s) ======\n\n", *SOCKET, pRequest); + + char answer[maxBuffLen]; // contiendra la réponse + int nbSend; // contiendra le nombre de données envoyées + char rCommand[10]; // contiendra les commandes (1ère partie) + char rContent[maxBuffLen]; // contiendra le contenu associé à la commande (2ème partie) + + // on vide les buffers + memset(&rCommand, '\0', sizeof(rCommand)); + memset(&rContent, '\0', sizeof(rContent)); + memset(&answer, '\0', sizeof(answer)); + + + /* [1] On découpe la requête en 2 parties + ================================================*/ + splitFtpRequest(pRequest, rCommand, rContent); + // strcpy(answer, strcat(rCommand, rContent) ); + + /* [2] Selection en fonction de @rCommand + ================================================*/ + + /* (1) Erreur de syntaxe + --------------------------------------------*/ + if( strcmp(rCommand, "ERROR") == 0 ) + strcpy(answer, "666 Tu t'es chié!!\n"); + + /* (2) Connection (username) + --------------------------------------------*/ + else if( strcmp(rCommand, "USER") == 0 ) + strcpy(answer, "331 C'est donc ça ton blase!\n"); + + + /* (n) Commande inconnue + --------------------------------------------*/ + else + strcpy(answer, "??? Connè pô!\n"); + + + /* [3] Envoi de la réponse + ================================================*/ + formatBuffer(answer); + nbSend = write(*SOCKET, answer, strlen(answer)); + + /* [4] Fermeture de la SOCKET + ================================================*/ + // close(*SOCKET); +} + + + +void MANAGE_RESPONSE(int* SOCKET, char** pAnswer){ + if( DEBUGMOD ) printf("====== MANAGE_RESPONSE(%d, %s) ======\n\n", *SOCKET, *pAnswer); + + char answer[maxBuffLen]; // contiendra la réponse + char ftpCode[4]; // contiendra le code FTP (1ère partie) + char ftpText[maxBuffLen]; // contiendra le texte associé à la commande (2ème partie) + + // on vide les buffers + memset(&ftpCode, '\0', sizeof(ftpCode)); + memset(&ftpText, '\0', sizeof(ftpText)); + memset(&answer, '\0', sizeof(answer)); + + + /* [1] On découpe la requête en 2 parties + ================================================*/ + splitFtpResponse(*pAnswer, ftpCode, ftpText); + + /* [2] Selection en fonction de @ftpCode + ================================================*/ + + // /* (1) Demande d'username + // --------------------------------------------*/ + // if( strcmp(ftpCode, "220") == 0 ) + // strcpy(answer, USER_MSG); + + + /* (2) Demande d'username + --------------------------------------------*/ + if( strcmp(ftpCode, "220") == 0 ) + strcpy(answer, WLCM_MSG); + + + /* (3) username OK -> demande MDP + --------------------------------------------*/ + else if( strcmp(ftpCode, "331") == 0 ) + strcpy(answer, USER_MSG); + + /* (3) Bon mdp -> connection + --------------------------------------------*/ + else if( strcmp(ftpCode, "230") == 0 ) + strcpy(answer, PASS_BON_MSG); + + + + /* (4) Mauvais mdp -> connection + --------------------------------------------*/ + else if( strcmp(ftpCode, "530") == 0 ) + strcpy(answer, PASS_BAD_MSG); + + /* (5) Info SYST + --------------------------------------------*/ + // else if( strcmp(ftpCode, "215") == 0 ) + // strcpy(answer, "bla\n"); + + /* (6) LOGOUT => EXIT + --------------------------------------------*/ + else if( strcmp(ftpCode, "221") == 0 ) + strcpy(answer, EXIT_MSG); + + + + /* (n) Commande inconnue + --------------------------------------------*/ + else + strcpy(answer, *pAnswer); + + + /* [3] Retour de la réponse + ================================================*/ + strcpy(*pAnswer, answer); +} + + + + + +int WAIT_CLIENT(int* pSocket, char* pBuffer){ + memset(pBuffer, 0, maxBuffLen); // on vide le buffer + + int nbRead = 0; + + do{ + nbRead = sread(pSocket, pBuffer); + + // si on est déconnecté, on ferme la SOCKET + if( nbRead == -1 ){ + printf("Client déconnecté!\n"); + return -1; + } + + }while( pBuffer[nbRead-1] != '\n' && pBuffer[nbRead-2] != '\r' ); + + + // on retourne -1 si erreur, SINON 0 + return nbRead; +} \ No newline at end of file diff --git a/dep/server.h b/dep/server.h new file mode 100644 index 0000000..f3256a0 --- /dev/null +++ b/dep/server.h @@ -0,0 +1,29 @@ +/* Créé et met un serveur sur écoute +* +* @serverHost Nom de l'hôte local (localhost) +* +* @givenPort Pointeur sur le à remplir => contiendra le port donné par le système +* @listenSocket Pointeur sur le à remplir => contiendra un pointeur sur la socket d'écoute +* +*/ +void DROP_SERVER(char* serverHost, char** givenPort, int* listenSocket); + + + +/* Gestion de la réponse au client +* +* @SOCKET Pointeur sur la SOCKET concernée +* @pRequest Requête reçue et à traiter +* +*/ +void MANAGE_REQUEST(int* SOCKET, char* pRequest); + + + + +void MANAGE_RESPONSE(int* SOCKET, char** pAnswer); + + + + +int WAIT_CLIENT(int* pSocket, char* pBuffer); \ No newline at end of file diff --git a/dep/utility.c b/dep/utility.c new file mode 100644 index 0000000..8ab4610 --- /dev/null +++ b/dep/utility.c @@ -0,0 +1,151 @@ +#include "utility.h" + +void splitFtpRequest(char* pRequest, char* pCommand, char* pContent){ + /* [1] Vérification du format + ===========================================*/ + int firstSpaceIndex = indexOf(pRequest, ' '); + + if( firstSpaceIndex != 3 && firstSpaceIndex != 4){ // contient aucun espace en position 3 ou 4, on quitte + strcpy(pCommand, "ERROR"); + strcpy(pContent, ""); + return; + } + + + /* [2] Séparation des 2 parties + ===========================================*/ + int i; + + for( i = 0 ; i < strlen(pRequest) || pRequest[i] != '\0' ; i++ ){ + + if( i < firstSpaceIndex ) // première partie (pCommand) + strcpy( pCommand, strcat(pCommand, (char[2]) { (char) pRequest[i], '\0' }) ); + if( i > firstSpaceIndex ) // seconde partie (pContent) + strcpy( pContent, strcat(pContent, (char[2]) { (char) pRequest[i], '\0' }) ); + } + + +} + + + + +void splitFtpResponse(char* pAnswer, char* ftpCode, char* ftpText){ + /* [1] Vérification du format + ===========================================*/ + int codeLength = 3; // taille du code + + /* [2] Séparation des 2 parties + ===========================================*/ + int i; + + for( i = 0 ; i < strlen(pAnswer) || pAnswer[i] != '\0' ; i++ ){ + + if( i < codeLength ) // première partie (ftpCode) + strcpy( ftpCode, strcat(ftpCode, (char[2]) { (char) pAnswer[i], '\0' }) ); + if( i > codeLength ) // seconde partie (ftpText) + strcpy( ftpText, strcat(ftpText, (char[2]) { (char) pAnswer[i], '\0' }) ); + } + + +} + + + + + +int indexOf(char* haystack, char needle){ + int i; + + for( i = 0 ; i < strlen(haystack) || haystack[i] != '\0' ; i++ ) + if( haystack[i] == needle ) // si on trouve le caractère + return i; + + return -1; + +} + +void formatBuffer(char* pBuffer){ + if( DEBUGMOD ) printf( "BUFLEN (bef): %lu\n", strlen(pBuffer) ); + if( DEBUGMOD ) printf( "BUFFER: (%s)\n", pBuffer ); + + /* [1] On retire les "\n" et "\r" de la fin de la chaine + ============================================================*/ + int i; + + for( i = strlen(pBuffer)-1 ; i >= 0 || pBuffer[i] != '\0' ; i-- ) + if( pBuffer[i] == '\n' || pBuffer[i] == '\r' ) // si c'est un retour chariot + pBuffer[i] = '\0'; // on efface + else + break; + + // on ferme ensuite la chaîne + pBuffer[i] = '\0'; + + /* [2] On ajoute "\r\n" à la fin + ============================================================*/ + strcpy(pBuffer, strcat(pBuffer, "\r\n")); + + if( DEBUGMOD ) printf( "BUFLEN (aft): %lu\n", strlen(pBuffer) ); +} + + + +void read_stdin(char* pBuffer, unsigned long pLength){ + fgets(pBuffer, pLength, stdin); // on lit l'entrée standard + + int i; + // on supprimes les retours à la ligne de la fin + for( i = strlen(pBuffer)-1 ; i >= 0 || pBuffer[i] != '\0' ; i-- ) + if( pBuffer[i] == '\n' || pBuffer[i] == '\r' ) // si c'est un retour chariot + pBuffer[i] = '\0'; // on efface + else + break; + + strcpy(pBuffer, strcat(pBuffer, "\r\n")); +} + + +int swrite(int* pSocket, char* pBuffer){ + if( *pSocket == -1 ) return -1; // si SOCKET fermée, on retourne une erreur + + return write(*pSocket, pBuffer, strlen(pBuffer), MSG_DONTROUTE); +} + + +int sread(int* pSocket, char* pBuffer){ + if( *pSocket == -1 ) return -1; // si SOCKET fermée, on retourne une erreur + + + // on vide le buffer avant de lire + memset(pBuffer, '\0', maxBuffLen); + int nbRead = read(*pSocket, pBuffer, maxBuffLen); + + + // si on est déconnecté, on ferme la SOCKET + if( nbRead == 0 ){ + close(*pSocket); + return -1; // on retourne une erreur + } + + return nbRead; +} + + + +void xPrint(char* pPattern, char* pBuffer){ + char tmpBuffer[maxBuffLen]; + strcpy(tmpBuffer, pBuffer); + + + int i; + + // on supprimes les retours à la ligne de la fin + for( i = strlen(tmpBuffer)-1 ; i >= 0 || tmpBuffer[i] != '\0' ; i-- ) + if( tmpBuffer[i] == '\n' || tmpBuffer[i] == '\r' ) // si c'est un retour chariot + tmpBuffer[i] = '\0'; // on efface + else + break; + + printf(pPattern, tmpBuffer); +} \ No newline at end of file diff --git a/dep/utility.h b/dep/utility.h new file mode 100644 index 0000000..fa2f562 --- /dev/null +++ b/dep/utility.h @@ -0,0 +1,55 @@ +/* Découpe la requête FTP en 2 parties +* +* @pRequest La requête en question +* +* @pCommand Remplissage: commande (1ère partie) +* @pContant Remplissage: contenu (2ème partie) +* +* +*/ +void splitFtpRequest(char* pRequest, char* pCommand, char* pContent); + +/* Découpe la réponse FTP en 2 parties +* +* @pAnswer La réponse en question +* +* @ftpCode Remplissage: code FTP (1ère partie) +* @ftpText Remplissage: text associé (2ème partie) +* +* +*/ +void splitFtpResponse(char* pAnswer, char* ftpCode, char* ftpText); + + +/* Retourne le rang d'un caractère dans une string +* +* @haystack La chaîne dans laquelle rechercher +* @needle Le caractère recherché +* +* @return position Retourne l'index de @needle dans @haystack ou -1 si ne trouve pas +* +*/ +int indexOf(char* haystack, char needle); + + + +/* Formatte un buffer pour être envoyé +* +* @pBuffer Buffer en question +* +*/ +void formatBuffer(char *pBuffer); + + +void read_stdin(char* pBuffer, unsigned long pLength); + + + +/* read/write socket */ +int swrite(int* pSocket, char* pBuffer); +int sread(int* pSocket, char* pBuffer); + + + + +void xPrint(char* pPattern, char* pBuffer); \ No newline at end of file diff --git a/proxy_ftp.c b/proxy_ftp.c new file mode 100644 index 0000000..972e914 --- /dev/null +++ b/proxy_ftp.c @@ -0,0 +1,146 @@ +#include "proxy_ftp.h" + +// DECLARATIONS +static pthread_t userServer; +static short unsigned int userServerState = 1; +static char remoteAssignedPort[maxPortLen] = {'\0'}; + +/* headers */ +static void* testServer(); + + + + + + + + + + +/*****************/ +/* CORPS DU PROG */ +/*****************/ +int main(int argc, char* argv[]){ + + testServer(); + + return EXIT_SUCCESS; +} + + + + + + + + + + + + + +static void* testServer(){ + int USER_SOCKET; // contiendra le BUS DE COMMANDE utilisateur + int FTP_SOCKET; // contiendra le BUS DE COMMANDE FTP + int DUSER_SOCKET; // contiendra le BUS DE DONNES utilisateur + int DFTP_SOCKET; // contiendra le BUS DE DONNEES FTP + + char BUFFER[maxBuffLen]; // contiendra le BUFFER + struct sockaddr_storage clientInfo; // contiendra les infos client + char repeat; // sert à sortir de la boucle + int nbReceived, nbSend; // contiendra les nb reçu && envoyé + socklen_t len = sizeof(struct sockaddr_storage); + + // retour de @DROP_SERVER + char* serverPort; // contiendra le port + int LISTENSOCK; // contiendra la socket d'écoute + char* ftp_response; + + /* [0] On lance @DROP_SERVER + ==========================================================*/ + serverPort = malloc(4*sizeof(char)); + strcpy(serverPort, "4444"); + DROP_SERVER(remoteHost, &serverPort, &LISTENSOCK); + CONNECT_CLIENT(FTP_HOST, FTP_PORT, &FTP_SOCKET); + + printf("Port: %s\n", serverPort); + strcpy(remoteAssignedPort, serverPort);// PORT GLOBAL + + /* [1] Attente d'une demande de connection, puis création d'une socket + ============================================================================*/ + USER_SOCKET = accept(LISTENSOCK, (struct sockaddr *) &clientInfo, &len); + + /* [2] On envoie la séquence d'initialisation + ============================================================================*/ + strcpy(BUFFER, ""); + CLIENT_SEND(&FTP_SOCKET, BUFFER, &ftp_response); + MANAGE_RESPONSE(&USER_SOCKET, &ftp_response); + swrite(&USER_SOCKET, ftp_response); + + xPrint("P->F: %s\n\n", BUFFER); + xPrint("F->P: %s\n", ftp_response); + + /* BOUCLE DE COMMANDES */ + while( USER_SOCKET != -1 && FTP_SOCKET != -1 ){ + + /* [3] On récupère les données reçues (+attente) + ============================================================================*/ + if( WAIT_CLIENT(&USER_SOCKET, BUFFER) == -1 ) break; + xPrint("C->P: %s\n", BUFFER); + + if( DEBUGMOD ) printf("Recu: %d\n", nbReceived); + if( DEBUGMOD ) printf("C->P: %s\n", BUFFER); + + + /* [4] Redirection vers le serveur FTP + ============================================================================*/ + CLIENT_SEND(&FTP_SOCKET, BUFFER, &ftp_response); + // printf("U22: %d\n", USER_SOCKET); + xPrint("P->F: %s\n\n", BUFFER); + xPrint("F->P: %s\n", ftp_response); + + + /* [5] On analyse et renvoie la réponse à l'utilisateur + ============================================================================*/ + // on analyse + MANAGE_RESPONSE(&USER_SOCKET, &ftp_response); + + // on réponds au client + if( swrite(&USER_SOCKET, ftp_response) == -1 ) break; + printf("P->C: %s\n", ftp_response); + + + + /* [6] On vide les buffers + ============================================================================*/ + memset(BUFFER, '\0', sizeof(BUFFER)); // on vide le buffer + ftp_response = NULL; + } + + close(USER_SOCKET); + close(FTP_SOCKET); + close(LISTENSOCK); + strcpy(remoteAssignedPort, "\0"); +} + + +/* +* DROP_SERVER +* INIT_CLIENT +* +* while(){ +* accept(); +* client_send() +* } +* +* EXIT_CLIENT +* HALT_SERVER +* +* +* +* +* +* +* +* +*/ \ No newline at end of file diff --git a/proxy_ftp.h b/proxy_ftp.h new file mode 100644 index 0000000..5b059e3 --- /dev/null +++ b/proxy_ftp.h @@ -0,0 +1,84 @@ +/* global */ +#include +#include +#include +#include + +/* sys */ +#include +#include + +/* socket */ +#include +#include // getaddrinfo, getnameinfo +#include + +/* basis */ +#define TRUE 1 +#define FALSE 0 + + +/* debug */ +#define DEBUGMOD FALSE // TRUE = débugmode activé +// #define DEBUGMOD TRUE // TRUE = débugmode activé + +/* vars */ +#define remoteHost "localhost" +#define remotePort "80" +#define maxBuffLen 4096 +#define maxListLen 2 +#define maxHostLen 64 +#define maxPortLen 6 + +#define FTP_HOST "31.170.164.47" +// #define FTP_HOST "localhost" +#define FTP_PORT "21" +// u712664263 + + +/* MESSAGES */ +// 220-\n +// 220- +----------------------------+\n +// 220- | Bienvenue sur PROXY FCP!!! |\n +// 220- +----------------------------+\n +// 220-\n +// 220-\n +// 220- (FCP=File Club Protocol)\n +// 220-\n +// 220-\n +// 220- Qui est tu ?!\n +// 220-\n +// 220\n +#define WLCM_MSG "220-\n220- +----------------------------+\n220- | Bienvenue sur PROXY FCP!!! |\n220- +----------------------------+\n220-\n220-\n220- (FCP=File Club Protocol)\n220-\n220-\n220- Qui est tu ?!\n220-\n220\n" + +#define CON_MSG "220 Connecté au serveur\n" +#define USER_MSG "331 Tu connais la procédure.. Donne moi le mot de passe ?\n" +// 230- Bienvenue au FILE CLUB!\n\n +// 230- Les règles du File Club sont:\n +// 230- ====================================\n +// 230- 1. Il est interdit de parler du File Club.\n +// 230- 2. Il est interdit de parler du File Club.\n +// 230- 3. Si quelqu'un dit stop ou s'évanouit, le transfert s'arrête.\n +// 230- 4. Seulement deux fichiers par transfert.\n +// 230- 5. Un transfert à la fois.\n +// 230- 6. Pas de '.log', pas de '.txt'.\n +// 230- 7. Le transfert dure aussi longtemps qu'il doit durer.\n +// 230- 8. Si c'est votre premier soir au File Club, vous devez transférer.\n +// 230\n +#define PASS_BON_MSG "230- Bienvenue au FILE CLUB!\n230-\n230- Les règles du File Club sont:\n230- ====================================\n230- 1. Il est interdit de parler du File Club.\n230- 2. Il est interdit de parler du File Club.\n230- 3. Si quelqu'un dit stop ou s'évanouit, le transfert s'arrête.\n230- 4. Seulement deux fichiers par transfert.\n230- 5. Un transfert à la fois.\n230- 6. Pas de '.log', pas de '.txt'.\n230- 7. Le transfert dure aussi longtemps qu'il doit durer.\n230- 8. Si c'est votre premier soir au File Club, vous devez transférer.\n230\n" +#define PASS_BAD_MSG "530- Mauvais mot de passe! Dégage!\n530\n" +// 221-\n +// 221- Fermeture des portes!\n +// 221- Tout le monde dehors!!\n +// 221- Et n'oublie pas la PREMIERE REGLE!!\n +// 221\n +#define EXIT_MSG "221-\n221- Fermeture des portes!\n221- Tout le monde dehors!!\n221- Et n'oublie pas la PREMIERE REGLE!!\n221\n" + + + +//Je suis le canal biliaire irrité de Jack. + +/* local dependencies */ +#include "dep/utility.c" +#include "dep/client.c" +#include "dep/server.c" diff --git a/test b/test new file mode 100755 index 0000000000000000000000000000000000000000..f95e8599d1ff603a1495cc18ad1e301b63918fdf GIT binary patch literal 18600 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 literal 0 HcmV?d00001 diff --git a/thread/main.c b/thread/main.c new file mode 100644 index 0000000..989d7b7 --- /dev/null +++ b/thread/main.c @@ -0,0 +1,55 @@ +#include +#include +#include +#include + +static void* action1(); +static void* action2(); + + +pthread_t thread1, thread2; +static int bool1 = 1; +static int bool2 = 1; + + + +int main(int argc, char* argv []){ + + pthread_create(&thread1, NULL, &action1, (void*) NULL); + pthread_create(&thread2, NULL, &action2, (void*) NULL); + + printf("THREADS CREATED\n===============\n"); + + sleep(3); + bool1 = 0; + sleep(3); + bool2 = 0; + + + + + return EXIT_SUCCESS; +} + + + + + + +static void* action1(){ + while( bool1 ){ + printf("[THREAD] 1\n"); + sleep(1); + } + + pthread_exit((void*) thread1); +} + +static void* action2(){ + while( bool2 ){ + printf("[THREAD] 2\n"); + sleep(1); + } + + pthread_exit((void*) thread2); +} \ No newline at end of file diff --git a/thread/test b/thread/test new file mode 100755 index 0000000000000000000000000000000000000000..c7942b766b1ad43e859aaa6d08ba969c9cd9d39e GIT binary patch literal 8915 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 S+%laSF1htxw5LYhqJII3W+HU} literal 0 HcmV?d00001