No Description
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

tsock_v2.c 7.1KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272
  1. /* librairie standard ... */
  2. #include <stdlib.h>
  3. /* pour getopt */
  4. #include <unistd.h>
  5. /* déclaration des types de base */
  6. #include <sys/types.h>
  7. /* constantes relatives aux domaines, types et protocoles */
  8. #include <sys/socket.h>
  9. /* constantes et structures propres au domaine UNIX */
  10. #include <sys/un.h>
  11. /* constantes et structures propres au domaine INTERNET */
  12. #include <netinet/in.h>
  13. /* structures retournées par les fonctions de gestion de la base de
  14. données du réseau */
  15. #include <netdb.h>
  16. /* pour les entrées/sorties */
  17. #include <stdio.h>
  18. /* pour la gestion des erreurs */
  19. #include <errno.h>
  20. #define BASE_SIZE 10
  21. void construire_message(char *message, char motif, int lg);
  22. void afficher_message(char *message, int lg);
  23. void print_usage(char* arg0);
  24. int main (int argc, char **argv) {
  25. int c;
  26. extern char *optarg;
  27. extern int optind;
  28. int nb_message = -1; /* Nb de messages à envoyer ou à recevoir, par défaut : 10 en émission, infini en réception */
  29. int source = -1 ; /* 0=puits, 1=source */
  30. int udp=0; /* 0=TCP, 1=UDP */
  31. while ((c = getopt(argc, argv, "pn:su")) != -1) {
  32. switch (c) {
  33. case 'p':
  34. if (source == 1) {
  35. print_usage(argv[0]);
  36. exit(1);
  37. }
  38. source = 0;
  39. break;
  40. case 's':
  41. if (source == 0) {
  42. print_usage(argv[0]);
  43. exit(1) ;
  44. }
  45. source = 1;
  46. break;
  47. case 'n':
  48. nb_message = atoi(optarg);
  49. break;
  50. case 'u':
  51. udp=1;
  52. break;
  53. default:
  54. print_usage(argv[0]);
  55. exit(1);
  56. }
  57. }
  58. char* nom_machine_distante;
  59. // Recuperation du port
  60. int port=atoi(argv[argc-1]);
  61. port = htons(port);
  62. char* message = malloc(BASE_SIZE * sizeof(char));
  63. if (source == -1) {
  64. print_usage(argv[0]);
  65. exit(1) ;
  66. }
  67. if (source == 1) {
  68. //Recuperation du nom logique
  69. nom_machine_distante=argv[argc-2];
  70. } else printf("PUITS:");
  71. if (nb_message != -1) {
  72. if (source == 1)
  73. printf("nb de tampons à envoyer : %d\n", nb_message);
  74. else
  75. printf("nb de tampons à recevoir : %d\n", nb_message);
  76. } else {
  77. if (source == 1) {
  78. nb_message = 10 ;
  79. printf("nb de tampons à envoyer = 10 par défaut\n");
  80. } else
  81. printf("nb de tampons à recevoir = infini\n");
  82. }
  83. if (udp==1){
  84. // Creation du socket local
  85. int sock= socket(AF_INET,SOCK_DGRAM,0);
  86. if (source==1) {
  87. // Creation de l'adresse du socket distant
  88. struct hostent *hp ;
  89. struct sockaddr_in adr_dest;
  90. int longueur_adr_dest = sizeof(adr_dest);
  91. int longueur_message = BASE_SIZE;
  92. memset((char *)& adr_dest, 0, sizeof(adr_dest)) ;
  93. adr_dest.sin_family=AF_INET;
  94. adr_dest.sin_port=port;
  95. if ((hp = gethostbyname(nom_machine_distante)) == NULL) {
  96. printf("erreur gethostbyname\n") ;
  97. exit(1) ;
  98. }
  99. memcpy( (char*)&(adr_dest.sin_addr.s_addr),
  100. hp->h_addr,
  101. hp->h_length ) ;
  102. for (int i = 0; i < nb_message; i++) {
  103. // Construction du message
  104. construire_message(message, 'a' + (i % 26), BASE_SIZE);
  105. // Envoi du message
  106. sendto(sock,message,longueur_message,0,(struct sockaddr*)&adr_dest,longueur_adr_dest);
  107. }
  108. } else { // UDP & puit
  109. // Creation de l'adresse du socket distant
  110. struct sockaddr_in adr_locale;
  111. int longueur_adr_locale = sizeof(adr_locale);
  112. int longueur_message = BASE_SIZE;
  113. memset((char *)& adr_locale, 0, sizeof(adr_locale)) ;
  114. adr_locale.sin_family=AF_INET;
  115. adr_locale.sin_port=port;
  116. adr_locale.sin_addr.s_addr = INADDR_ANY;
  117. // Bind the local socket to any local address (ie any available interface)
  118. if (bind(sock, (struct sockaddr *) &adr_locale, longueur_adr_locale) == -1) {
  119. printf("failed to bind\n");
  120. exit(1);
  121. }
  122. while (1) {
  123. // Receive a single message because we are lazy
  124. recvfrom(sock, message, longueur_message, 0, NULL, NULL);
  125. // Afficher notre seule et unique triste message
  126. afficher_message(message, longueur_message);
  127. }
  128. }
  129. } else { // TCP
  130. // Creation du socket local
  131. int sock= socket(AF_INET,SOCK_STREAM,0);
  132. if (source==1) {
  133. // Creation de l'adresse du socket distant
  134. struct hostent *hp ;
  135. struct sockaddr_in adr_dest;
  136. int longueur_adr_dest = sizeof(adr_dest);
  137. int longueur_message = BASE_SIZE;
  138. memset((char *)& adr_dest, 0, sizeof(adr_dest)) ;
  139. adr_dest.sin_family=AF_INET;
  140. adr_dest.sin_port=port;
  141. if ((hp = gethostbyname(nom_machine_distante)) == NULL) {
  142. printf("erreur gethostbyname\n") ;
  143. exit(1) ;
  144. }
  145. memcpy( (char*)&(adr_dest.sin_addr.s_addr),
  146. hp->h_addr,
  147. hp->h_length ) ;
  148. // Demande de connexion
  149. int succ;
  150. if ((succ=connect(sock,(struct sockaddr*) &adr_dest,longueur_adr_dest))!=0){
  151. printf("Echec connect");
  152. exit(1);
  153. }
  154. // Envoie des messages
  155. for (int i = 0; i < nb_message; i++) {
  156. // Construction du message
  157. construire_message(message, 'a' + (i % 26), BASE_SIZE);
  158. // Envoi du message
  159. write(sock,message,longueur_message);
  160. }
  161. // Close socket to avoid dangling connections
  162. close(sock);
  163. } else { // TCP & puit
  164. // Creation de l'adresse du socket local
  165. struct sockaddr_in adr_locale;
  166. socklen_t longueur_adr_locale = sizeof(adr_locale);
  167. int longueur_message = BASE_SIZE;
  168. memset((char *)& adr_locale, 0, sizeof(adr_locale)) ;
  169. adr_locale.sin_family=AF_INET;
  170. adr_locale.sin_port=port;
  171. adr_locale.sin_addr.s_addr = INADDR_ANY;
  172. // Bind the local socket to any local address (ie any available interface)
  173. if (bind(sock, (struct sockaddr *) &adr_locale, longueur_adr_locale) == -1) {
  174. printf("failed to bind\n");
  175. exit(1);
  176. }
  177. // set linstening queue size
  178. if (listen(sock, 5) == -1) {
  179. printf("échec et mat listen\n");
  180. exit(1);
  181. }
  182. int sock_bis;
  183. // Accept a single connection on the main thread
  184. if ((sock_bis = accept( sock, (struct sockaddr *)&adr_locale, &longueur_adr_locale)) == -1){
  185. printf("échec du accept\n") ;
  186. exit(1) ;
  187. }
  188. while (read(sock_bis, message, longueur_message) > 0) {
  189. afficher_message(message, longueur_message);
  190. }
  191. close(sock_bis);
  192. close(sock);
  193. }
  194. }
  195. exit(0);
  196. }
  197. void construire_message(char *message, char motif, int lg) {
  198. int i;
  199. for (i=0;i<lg;i++) message[i] = motif;
  200. }
  201. void afficher_message(char *message, int lg) {
  202. int i;
  203. printf("message reçu : ");
  204. for (i=0;i<lg;i++){
  205. printf("%c", message[i]);
  206. }
  207. printf("\n");
  208. }
  209. void print_usage(char* arg0) {
  210. printf("usage: %s [-psu] [host] <port>\n", arg0);
  211. printf("parameters: host With -s, address of the host to connect to. Required with -s.\n");
  212. printf(" port Port to connect or bind to. Required.\n");
  213. printf("options: -p Runs a TCP/UDP sink. Incompatible with -s.\n");
  214. printf(" -s Runs a TCP/UDP faucet. Incompatible with -p.\n");
  215. printf(" -u Use UDP instead of TCP.\n");
  216. }