360 lines
9.4 KiB
C
360 lines
9.4 KiB
C
/*test */
|
|
/* librairie standard ... */
|
|
#include <stdlib.h>
|
|
/* pour getopt */
|
|
#include <unistd.h>
|
|
/* déclaration des types de base */
|
|
#include <sys/types.h>
|
|
/* constantes relatives aux domaines, types et tcps */
|
|
#include <sys/socket.h>
|
|
/* constantes et structures propres au domaine UNIX */
|
|
#include <sys/un.h>
|
|
/* constantes et structures propres au domaine INTERNET */
|
|
#include <netinet/in.h>
|
|
/* structures retournées par les fonctions de gestion de la base de
|
|
données du réseau */
|
|
#include <netdb.h>
|
|
/* pour les entrées/sorties */
|
|
#include <stdio.h>
|
|
/* pour la gestion des erreurs */
|
|
#include <errno.h>
|
|
|
|
#define DEFAULTSERVERPORT 9000
|
|
#define DEFAULTCLIENTPORT 8999
|
|
#define MSG_LENGTH 10
|
|
#define NB_CLIENTS 1
|
|
#define TCP_BUFFER_LEN 2000
|
|
|
|
// affiche l'utilisation de la fonction
|
|
void usage(char* prog) {
|
|
printf("usage: %s [-h][-p|-s][-u|-t][-n ##]\n", prog);
|
|
}
|
|
|
|
// remplit le message avec le charactere motif
|
|
void construire_message(char* message, char motif, int lg) {
|
|
for (int i = 0; i < lg; ++i) {
|
|
message[i] = motif;
|
|
}
|
|
message[lg] = '\0';
|
|
}
|
|
|
|
// essaye de recevoir un message par udp et traite le message.
|
|
void recvudp(int sock, char* buffer, int buf_len, void* addr, unsigned int addr_len) {
|
|
int lg_recv = recvfrom(sock, buffer, buf_len, 0, (struct sockaddr*) addr, &addr_len);
|
|
if (lg_recv == -1) {
|
|
perror("Message could not be recieved, Error");
|
|
exit(1);
|
|
} else if (lg_recv < buf_len) {
|
|
fprintf(stderr, "Only %i from %i characters have been reviewed.", lg_recv, buf_len);
|
|
exit(1);
|
|
} else {
|
|
buffer[lg_recv] = '\0';
|
|
printf("message revieved: %s\n", buffer);
|
|
}
|
|
}
|
|
|
|
// essaye d'envoyer un message par udp et gere les erreurs
|
|
void sendudp(int sock, char* message, int msg_len, void* addr, unsigned int addr_len) {
|
|
int lg_sent = sendto(sock, message, msg_len, 0, (struct sockaddr*) addr, addr_len);
|
|
if (lg_sent == -1) {
|
|
perror("Message could not be sent, Error");
|
|
exit(1);
|
|
} else if (lg_sent < MSG_LENGTH) {
|
|
fprintf(stderr, "Only %i from %i characters have been sent.", lg_sent, MSG_LENGTH);
|
|
exit(1);
|
|
}
|
|
printf("message sent: %s\n", message);
|
|
}
|
|
|
|
/* void recvtcp(int sock) { */
|
|
/* } */
|
|
|
|
/* affiche les lg premier characteres de message */
|
|
void afficher_message(char* message, int lg) {
|
|
message[lg] = '\0';
|
|
printf("message construit: %s", message);
|
|
}
|
|
|
|
int main (int argc, char **argv)
|
|
{
|
|
int c;
|
|
extern char *optarg;
|
|
extern int optind;
|
|
int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
|
|
int source = -1 ; /* 0=puits, 1=source */
|
|
char* hostname; /* stocke la chaine de charactere de l'url avec la quelle on communique */
|
|
int tcp = -1; /* 0=tcp, 1=udp */
|
|
int sock; /* identifiant du buffer */
|
|
char* message; /* stocke le message à onvoyer ou à recevoir */
|
|
struct hostent *hp; /* structure pour rérupérer l'addresse de l'url */
|
|
struct sockaddr_in addr_local;
|
|
struct sockaddr_in addr_distant;
|
|
/* taille de la structure d'addresse */
|
|
unsigned int addr_distant_len = sizeof(addr_distant);
|
|
while ((c = getopt(argc, argv, "hpst:u:n:")) != -1) {
|
|
switch (c) {
|
|
// affiche l'utilisation du programme
|
|
case 'h':
|
|
usage(argv[0]);
|
|
return 0;
|
|
// mode puit
|
|
case 'p':
|
|
if (source == 1) {
|
|
usage(argv[0]);
|
|
exit(1);
|
|
}
|
|
source = 0;
|
|
break;
|
|
// mode source
|
|
case 's':
|
|
if (source == 0) {
|
|
usage(argv[0]);
|
|
exit(1) ;
|
|
}
|
|
source = 1;
|
|
break;
|
|
// nombre de messages à afficher
|
|
case 'n':
|
|
nb_message = atoi(optarg);
|
|
break;
|
|
// utilise le protocole UDP
|
|
case 'u':
|
|
if (tcp == 1) {
|
|
usage(argv[0]);
|
|
exit(1);
|
|
}
|
|
tcp = 0;
|
|
hostname = optarg;
|
|
break;
|
|
// utilise le protocole TCP
|
|
case 't':
|
|
if (tcp == 0) {
|
|
usage(argv[0]);
|
|
exit(1);
|
|
}
|
|
tcp = 1;
|
|
hostname = optarg;
|
|
break;
|
|
// argument non reconnu
|
|
default:
|
|
usage(argv[0]);
|
|
exit(1);
|
|
break;
|
|
}
|
|
}
|
|
// si le protocole n'a pas été défini par l'utilisateur, utiliser TCP
|
|
if (tcp == -1) {
|
|
tcp = 1;
|
|
}
|
|
|
|
// si le mode de fonctionnement(source/puit) n'a pas été défini -> ERREUR
|
|
if (source == -1) {
|
|
printf("outside\n");
|
|
usage(argv[0]);
|
|
/* printf("usage: cmd [-p|-s][-n ##]\n"); */
|
|
exit(1) ;
|
|
}
|
|
|
|
/* if (source == 1) */
|
|
/* printf("on est dans le source\n"); */
|
|
/* else */
|
|
/* printf("on est dans le puits\n"); */
|
|
|
|
/* if (nb_message != -1) { */
|
|
/* if (source == 1) */
|
|
/* printf("nb de tampons à envoyer : %d\n", nb_message); */
|
|
/* else */
|
|
/* printf("nb de tampons à recevoir : %d\n", nb_message); */
|
|
/* } else { */
|
|
/* if (source == 1) { */
|
|
/* nb_message = 10 ; */
|
|
/* printf("nb de tampons à envoyer = 10 par défaut\n"); */
|
|
/* } else { */
|
|
/* // changed envoyer to recevoir */
|
|
/* printf("nb de tampons à recevoir = infini\n"); */
|
|
/* } */
|
|
|
|
/* } */
|
|
if (tcp) {
|
|
sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
} else /* if udp */ {
|
|
sock = socket(AF_INET, SOCK_DGRAM, 0);
|
|
}
|
|
if (sock < 0) {
|
|
perror("Error creating socket");
|
|
exit(1);
|
|
}
|
|
|
|
printf("socket created\n");
|
|
|
|
// remplissage de l'addresse locale
|
|
memset(&addr_local, 0, sizeof(addr_local));
|
|
addr_local.sin_family = AF_INET;
|
|
if (source) {
|
|
addr_local.sin_port = DEFAULTCLIENTPORT;
|
|
} else {
|
|
addr_local.sin_port = DEFAULTSERVERPORT;
|
|
}
|
|
addr_local.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
printf("address built\n");
|
|
|
|
// liaison entre l'addresse locale et le buffer(sock)
|
|
if (bind(sock, (struct sockaddr*) &addr_local, (sizeof(addr_local))) < 0 ) {
|
|
perror("Error while binding socket");
|
|
exit(1);
|
|
}
|
|
|
|
printf("socket bound\n");
|
|
|
|
memset(&addr_distant, 0, sizeof(addr_local));
|
|
addr_distant.sin_family = AF_INET;
|
|
if (source) {
|
|
addr_local.sin_port = DEFAULTSERVERPORT;
|
|
} else {
|
|
addr_local.sin_port = DEFAULTCLIENTPORT;
|
|
}
|
|
hp = gethostbyname(hostname);
|
|
if (hp == NULL) {
|
|
printf("hostname not found\n");
|
|
herror("Error: ");
|
|
exit(1);
|
|
}
|
|
|
|
memcpy(&addr_distant.sin_addr.s_addr, hp->h_addr, hp->h_length);
|
|
|
|
printf("distant address built\n");
|
|
|
|
if (tcp) {
|
|
if (source) {
|
|
// envoie de connection au serveur TCP
|
|
if (connect(sock,(struct sockaddr*)&addr_distant, sizeof(addr_distant)) == -1) {
|
|
printf("echec de la connexion\n");
|
|
exit(1);
|
|
}
|
|
} else {
|
|
// ouverture pour l'écoute de connexions
|
|
if (listen(sock, NB_CLIENTS) < 0) {
|
|
perror("Server could not listen");
|
|
exit(1);
|
|
} else {
|
|
printf("listening\n");
|
|
}
|
|
// accepte la première demande de connexion
|
|
if (accept(sock, (struct sockaddr*) &addr_distant, &addr_distant_len) < 0) {
|
|
perror("Server could not accept connection");
|
|
exit(1);
|
|
} else {
|
|
printf("accepting request\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/* if (!tcp) /\* if udp activated *\/ { */
|
|
/* printf("pas tcp\n"); */
|
|
/* memset(&addr_distant, 0, sizeof(addr_local)); */
|
|
/* addr_distant.sin_family = AF_INET; */
|
|
/* addr_distant.sin_port = DEFAULTPORT; */
|
|
/* hp = gethostbyname(hostname); */
|
|
/* if (hp == NULL) { */
|
|
/* printf("hosname not found\n"); */
|
|
/* /\* herror("Error: "); *\/ */
|
|
/* exit(1); */
|
|
/* } */
|
|
/* printf("hostname found\n"); */
|
|
|
|
/* memcpy(&addr_distant.sin_addr.s_addr, hp->h_addr, hp->h_length); */
|
|
/* } else /\* tcp activated *\/{ */
|
|
/* if (source) { */
|
|
/* memset(&addr_distant, 0, sizeof(addr_local)); */
|
|
/* addr_distant.sin_family = AF_INET; */
|
|
/* addr_distant.sin_port = DEFAULTPORT; */
|
|
/* hp = gethostbyname(hostname); */
|
|
/* if (hp == NULL) { */
|
|
/* printf("hosname not found\n"); */
|
|
/* /\* herror("Error: "); *\/ */
|
|
/* exit(1); */
|
|
/* } */
|
|
/* printf("hostname found\n"); */
|
|
|
|
/* memcpy(&addr_distant.sin_addr.s_addr, hp->h_addr, hp->h_length); */
|
|
|
|
/* if (connect(sock,(struct sockaddr*)&addr_distant, sizeof(addr_distant)) == -1) { */
|
|
/* printf("echec de la connexion\n"); */
|
|
/* exit(1); */
|
|
/* } */
|
|
/* } else { */
|
|
/* if (listen(sock, NB_CLIENTS) < 0) { */
|
|
/* perror("Server could not listen: "); */
|
|
/* exit(1); */
|
|
/* } else { */
|
|
/* printf("listening\n"); */
|
|
/* } */
|
|
/* if (accept(sock, (struct sockaddr*) &addr_distant, &addr_distant_len) < 0) { */
|
|
/* perror("Server could not accept connection: "); */
|
|
/* exit(1); */
|
|
/* } else { */
|
|
/* printf("accepting request\n"); */
|
|
/* } */
|
|
/* } */
|
|
/* } */
|
|
|
|
|
|
|
|
message = malloc((MSG_LENGTH + 1) * sizeof(char));
|
|
if (tcp) /* tcp activated */ {
|
|
if (source) {
|
|
for(int i=0;i<nb_message;i++) {
|
|
construire_message(message, (char)((i%26)+97), MSG_LENGTH);
|
|
afficher_message(message, MSG_LENGTH);
|
|
printf("\t\tsending message: \n");
|
|
send(sock, message, MSG_LENGTH, 0);
|
|
}
|
|
|
|
if (shutdown(sock, SHUT_RDWR)==-1) {
|
|
perror("echec de destruction du socket");
|
|
}
|
|
} else /*puit */ {
|
|
char buffer[TCP_BUFFER_LEN];
|
|
size_t nb_octed_read = read(sock, buffer, TCP_BUFFER_LEN - 1);
|
|
if (nb_octed_read < 0) {
|
|
perror("Could not read octed-stream: ");
|
|
exit(1);
|
|
} else {
|
|
buffer[nb_octed_read] = '\0';
|
|
printf("message recieved: %s\n", buffer);
|
|
}
|
|
|
|
}
|
|
} else /* udp activated */ {
|
|
if (source) {
|
|
if (nb_message < 0) {
|
|
nb_message = 10;
|
|
}
|
|
for (int i = 0; i < nb_message; ++i) {
|
|
construire_message(message, i % 26 + 'a', MSG_LENGTH);
|
|
sendudp(sock, message, MSG_LENGTH, &addr_distant, sizeof(addr_distant));
|
|
}
|
|
|
|
} else {
|
|
if (nb_message < 0) {
|
|
while (1) {
|
|
recvudp(sock, message, MSG_LENGTH, &addr_distant, sizeof(addr_distant));
|
|
}
|
|
} else {
|
|
for (int i = 0; i < nb_message; ++i) {
|
|
recvudp(sock, message, MSG_LENGTH, &addr_distant, sizeof(addr_distant));
|
|
}
|
|
}
|
|
printf("puit not implemented\n");
|
|
}
|
|
}
|
|
|
|
|
|
if (close(sock) < 0) {
|
|
perror("Error closing socket");
|
|
exit(1);
|
|
}
|
|
return 0;
|
|
}
|
|
|