dut
/
proxy-ftp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Récupère le résultat du LS + reste à l'afficher et bien le rediriger

This commit is contained in:
xdrm-brackets 2015-12-15 11:00:58 +01:00
parent c534ef1682
commit bf2f7248da
25 changed files with 24 additions and 2431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
SEQUENTIAL/backup/client.c
View File

@ -1,64 +0,0 @@
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#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: <nom serveur> <numero de port>\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);
}

336
SEQUENTIAL/backup/proxy_aure.c
View File

@ -1,336 +0,0 @@
// Bibliothéques
// ==============================================
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
// 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<strlen( entreeUtilisateur ); i++) {
if( entreeUtilisateur[i] != '@' )
login[i] = entreeUtilisateur[i];
if( entreeUtilisateur[i] == '@' ) {
i++;
while( entreeUtilisateur[i] != '\0' ) {
server[j] = entreeUtilisateur[i];
i++;
j++;
}
}
}
}
void waitingForUser(int *socket,char *buffer,int *n) {
*n = 0;
while(1 == 1) { // Gestion du buffer
recv( *socket, buffer+( *n ), 1, 0 );
if( buffer[*n] == '\n' && buffer[( *n )-1] == '\r') {
buffer[*n] = '\0';
buffer[( *n )-1] = '\0';
break;
}
( *n )++;
}
}
void waitingForServer(int *socket,char *buffer,int *n) {
*n = 0;
while(1 == 1) { // Gestion du buffer
recv( *socket, buffer+( *n ), 1, 0 );
if( buffer[*n] == '\n' && buffer[( *n )-1] == '\r') {
buffer[*n] = '\0';
buffer[( *n )-1] = '\0';
break;
}
( *n )++;
}
}

117
SEQUENTIAL/backup/serveur.c
View File

@ -1,117 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#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);
}

215
SEQUENTIAL/proxy_ftp.c
View File

@ -1,215 +0,0 @@
#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
*
*
*
*
*
*
*
*
*/

39
SEQUENTIAL/proxy_ftp.h
View File

@ -1,39 +0,0 @@
/* global */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
/* sys */
#include <sys/types.h>
#include <sys/socket.h>
/* socket */
#include <netinet/in.h>
#include <netdb.h> // getaddrinfo, getnameinfo
#include <arpa/inet.h>
/* basis */
#define TRUE 1
#define FALSE 0
/* debug */
// #define DEBUGMOD FALSE // <Boolean> TRUE = débugmode activé
#define DEBUGMOD TRUE // <Boolean> 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"

BIN
SEQUENTIAL/test
View File

Binary file not shown.

64
SEQUENTIAL/thread/SEQUENTIAL/backup/client.c
View File

@ -1,64 +0,0 @@
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#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: <nom serveur> <numero de port>\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);
}

336
SEQUENTIAL/thread/SEQUENTIAL/backup/proxy_aure.c
View File

@ -1,336 +0,0 @@
// Bibliothéques
// ==============================================
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
// 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<strlen( entreeUtilisateur ); i++) {
if( entreeUtilisateur[i] != '@' )
login[i] = entreeUtilisateur[i];
if( entreeUtilisateur[i] == '@' ) {
i++;
while( entreeUtilisateur[i] != '\0' ) {
server[j] = entreeUtilisateur[i];
i++;
j++;
}
}
}
}
void waitingForUser(int *socket,char *buffer,int *n) {
*n = 0;
while(1 == 1) { // Gestion du buffer
recv( *socket, buffer+( *n ), 1, 0 );
if( buffer[*n] == '\n' && buffer[( *n )-1] == '\r') {
buffer[*n] = '\0';
buffer[( *n )-1] = '\0';
break;
}
( *n )++;
}
}
void waitingForServer(int *socket,char *buffer,int *n) {
*n = 0;
while(1 == 1) { // Gestion du buffer
recv( *socket, buffer+( *n ), 1, 0 );
if( buffer[*n] == '\n' && buffer[( *n )-1] == '\r') {
buffer[*n] = '\0';
buffer[( *n )-1] = '\0';
break;
}
( *n )++;
}
}

117
SEQUENTIAL/thread/SEQUENTIAL/backup/serveur.c
View File

@ -1,117 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#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);
}

215
SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.c
View File

@ -1,215 +0,0 @@
#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
*
*
*
*
*
*
*
*
*/

39
SEQUENTIAL/thread/SEQUENTIAL/proxy_ftp.h
View File

@ -1,39 +0,0 @@
/* global */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
/* sys */
#include <sys/types.h>
#include <sys/socket.h>
/* socket */
#include <netinet/in.h>
#include <netdb.h> // getaddrinfo, getnameinfo
#include <arpa/inet.h>
/* basis */
#define TRUE 1
#define FALSE 0
/* debug */
// #define DEBUGMOD FALSE // <Boolean> TRUE = débugmode activé
#define DEBUGMOD TRUE // <Boolean> 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"

BIN
SEQUENTIAL/thread/SEQUENTIAL/test
View File

Binary file not shown.

64
SEQUENTIAL/thread/backup/client.c
View File

@ -1,64 +0,0 @@
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#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: <nom serveur> <numero de port>\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);
}

336
SEQUENTIAL/thread/backup/proxy_aure.c
View File

@ -1,336 +0,0 @@
// Bibliothéques
// ==============================================
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
// 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<strlen( entreeUtilisateur ); i++) {
if( entreeUtilisateur[i] != '@' )
login[i] = entreeUtilisateur[i];
if( entreeUtilisateur[i] == '@' ) {
i++;
while( entreeUtilisateur[i] != '\0' ) {
server[j] = entreeUtilisateur[i];
i++;
j++;
}
}
}
}
void waitingForUser(int *socket,char *buffer,int *n) {
*n = 0;
while(1 == 1) { // Gestion du buffer
recv( *socket, buffer+( *n ), 1, 0 );
if( buffer[*n] == '\n' && buffer[( *n )-1] == '\r') {
buffer[*n] = '\0';
buffer[( *n )-1] = '\0';
break;
}
( *n )++;
}
}
void waitingForServer(int *socket,char *buffer,int *n) {
*n = 0;
while(1 == 1) { // Gestion du buffer
recv( *socket, buffer+( *n ), 1, 0 );
if( buffer[*n] == '\n' && buffer[( *n )-1] == '\r') {
buffer[*n] = '\0';
buffer[( *n )-1] = '\0';
break;
}
( *n )++;
}
}

117
SEQUENTIAL/thread/backup/serveur.c
View File

@ -1,117 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#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);
}

55
SEQUENTIAL/thread/main.c
View File

@ -1,55 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <string.h>
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);
}

215
SEQUENTIAL/thread/proxy_ftp.c
View File

@ -1,215 +0,0 @@
#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
*
*
*
*
*
*
*
*
*/

39
SEQUENTIAL/thread/proxy_ftp.h
View File

@ -1,39 +0,0 @@
/* global */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
/* sys */
#include <sys/types.h>
#include <sys/socket.h>
/* socket */
#include <netinet/in.h>
#include <netdb.h> // getaddrinfo, getnameinfo
#include <arpa/inet.h>
/* basis */
#define TRUE 1
#define FALSE 0
/* debug */
// #define DEBUGMOD FALSE // <Boolean> TRUE = débugmode activé
#define DEBUGMOD TRUE // <Boolean> 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"

BIN
SEQUENTIAL/thread/test
View File

Binary file not shown.

55
SEQUENTIAL/thread/thread/main.c
View File

@ -1,55 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <string.h>
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);
}

BIN
SEQUENTIAL/thread/thread/test
View File

Binary file not shown.

28
dep/server.c
View File

@ -166,8 +166,8 @@ void MANAGE_REQUEST(char* pRequest, int* DUSER_SOCKET, int* DFTP_SOCKET){
// on se connecte au client // on se connecte au client
printf("CONNECTING TO CLIENT %s:%s\n", serverHost, serverPort);
CONNECT_CLIENT(serverHost, serverPort, DUSER_SOCKET); CONNECT_CLIENT(serverHost, serverPort, DUSER_SOCKET);
printf("CONNECTED TO CLIENT %s:%s\n", serverHost, serverPort); printf("CONNECTED TO CLIENT %s:%s\n", serverHost, serverPort);
// on envoie PASV car on veut être en mode passif entre le proxy et le serveur FTP // on envoie PASV car on veut être en mode passif entre le proxy et le serveur FTP
@ -239,14 +239,12 @@ void MANAGE_RESPONSE(char** pAnswer, int* DUSER_SOCKET, int* DFTP_SOCKET){
/* (7) Mode passif => On lance les SOCKETS du BUS DE DONNEES /* (7) Mode passif => On lance les SOCKETS du BUS DE DONNEES
--------------------------------------------*/ --------------------------------------------*/
else if( strcmp(ftpCode, "227") == 0 ){ // on lance la SOCKET FTP du BUS DE DONNEES else if( strcmp(ftpCode, "227") == 0 ){ // on lance la SOCKET FTP du BUS DE DONNEES
strcpy(response, *pAnswer); strcpy(response, "200 Tout s'est bien passé.\n");
int a1, a2, a3, a4 = 0; int a1, a2, a3, a4 = 0;
int p1, p2 = 0; int p1, p2 = 0;
char serverHost[maxHostLen]; char serverHost[maxHostLen];
char serverPort[maxPortLen]; char serverPort[maxPortLen];
char BUFFER[maxBuffLen];
sscanf(*pAnswer, "227 Entering Passive Mode (%d,%d,%d,%d,%d,%d)", &a1, &a2, &a3, &a4, &p1, &p2); sscanf(*pAnswer, "227 Entering Passive Mode (%d,%d,%d,%d,%d,%d)", &a1, &a2, &a3, &a4, &p1, &p2);
// on récupère l'adresse en <char*> // on récupère l'adresse en <char*>
sprintf(serverHost, "%d.%d.%d.%d", a1, a2, a3, a4); sprintf(serverHost, "%d.%d.%d.%d", a1, a2, a3, a4);
@ -254,13 +252,31 @@ void MANAGE_RESPONSE(char** pAnswer, int* DUSER_SOCKET, int* DFTP_SOCKET){
sprintf(serverPort, "%d", p1*256+p2); sprintf(serverPort, "%d", p1*256+p2);
// on se connecte au serveur FTP // on se connecte au serveur FTP
printf("CONNECTING TO FTP %s:%s\n", serverHost, serverPort);
CONNECT_CLIENT(serverHost, serverPort, DFTP_SOCKET); CONNECT_CLIENT(serverHost, serverPort, DFTP_SOCKET);
printf("CONNECTED TO FTP %s:%s\n", serverHost, serverPort); printf("CONNECTED TO FTP %s:%s\n", serverHost, serverPort);
} }
/* (8) Fin de transfert de données /* (8) On lit la SOCKET FTP du BUS DE DONNEES
--------------------------------------------*/
else if( strcmp(ftpCode, "150") == 0 ){ // on lit la SOCKET FTP du BUS DE DONNEES
char BUFFER[maxBuffLen];
// on lit la SOCKET FTP
if( sread(DFTP_SOCKET, BUFFER) == -1 ) printf("ERROR\n");
else xPrint("[BUS_IN]: %s\n", BUFFER);
// on redirige sur la SOCKET utilisateur
if( swrite(DUSER_SOCKET, BUFFER) == -1 ) printf("ERROR\n");
else xPrint("[BUS_OUT]: %s\n", BUFFER);
}
/* (9) Fin de transfert de données
--------------------------------------------*/ --------------------------------------------*/
else if( strcmp(ftpCode, "226") == 0 ){ // on ferme les SOCKETS du BUS DE DONNEES else if( strcmp(ftpCode, "226") == 0 ){ // on ferme les SOCKETS du BUS DE DONNEES
strcpy(response, *pAnswer); strcpy(response, *pAnswer);

4
proxy_ftp.h
View File

@ -30,8 +30,8 @@
#define maxHostLen 64 #define maxHostLen 64
#define maxPortLen 6 #define maxPortLen 6
#define FTP_HOST "31.170.164.47" // #define FTP_HOST "31.170.164.47"
// #define FTP_HOST "localhost" #define FTP_HOST "localhost"
#define FTP_PORT "21" #define FTP_PORT "21"
// u712664263 // u712664263

BIN
test
View File

Binary file not shown.

0
testRemove.c Normal file
View File