NET : UTILITAIRE LINUX SOCKETS

#include <stdio.h>          // les includes obligatoires
#include <stdlib.h>         // pour les sockets
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

int connecter(char*HOST, char*PORT);            // les fonctions qu'on va utiliser
int ecouter(char*PORT);                         // pour clarifier le code
int scanner(char*HOST,char*PORT1,char*PORT2);

int sock, nsock;    // déclare sock et nsock pour tout le programme

//###############################################################################################################

int main(int argv, char*argc[])
{
 int n;

 if((argv < 2)||(argv > 5))    // si le nombre d'arguments n'est pas correct...
 {
  printf("syntaxe:\n\
   net [hote] [port]             pour se connecter a l'hote\n\
   net -l [port]                 pour écouter le port (serveur)\n\
   net -s [hote] [port1] [port2] pour scanner l'hote du port1 au port2\n");
  return 0;
 }

 if((strcmp(argc[1], "-l")) == 0)  // compare l'argument 1 et -l, si ils sont égaux...
 {
  n = 1;
  ecouter(argc[2]);                // on appelle la fonction ecouter() avec l'argument 2 (le port)
 }

 if((strcmp(argc[1], "-s")) == 0)  // compare l'argument 1 et -s, si ils sont égaux...
 {
  n = 2;
  scanner(argc[2],argc[3],argc[4]); // on appelle la fonction scanner()
 }                                  //avec l'argument 2 (l'hote), l'argument 3 (port1), l'argument 4 (port2)


 if((n != 1)&&(n != 2))           // fonction par défaut
 {
  connecter(argc[1], argc[2]);
 }

 return 0;
}

//###############################################################################################################

int connecter(char*HOST, char*PORT)
{
 char buffer[255];     // pour stocker les données que l'on va recevoir du serveur

 struct hostent*IP;     // déclare une struct IP qui contiendra l'IP de l'hote
  if ((IP = gethostbyname(HOST)) == NULL)     // on convertit l'hote en IP
  {
   printf("erreur IP incorrect\n");
   return 0;
  }

 struct sockaddr_in sin;       // déclare une struct sin qui contiendra les données nécessaires à la conection
 sin.sin_family = AF_INET;     // internet
 sin.sin_addr   = *((struct in_addr *)IP -> h_addr);  //l'adresse IP
 sin.sin_port   = htons(atoi(PORT));     // le port
 bzero(&(sin.sin_zero),8);        // zéro pour le reste de la struct sin

 if((sock = socket(AF_INET,SOCK_STREAM,0)) == -1)   // on implémente sock
  {
   printf("erreur lors de l'initialisation de la socket\n");
   return 0;
  }

  printf("tentative de connection sur %s / %s...\n",inet_ntoa(*((struct in_addr *)IP -> h_addr)),PORT);

  if((connect(sock,(struct sockaddr*)&sin,sizeof(struct sockaddr))) == -1) // tentative de connection
  {
   printf("erreur lors de la connection %s / %s\n",IP,PORT);
   return 0;
  }

 printf("connecté %s / %s\n",inet_ntoa(*((struct in_addr *)IP -> h_addr)),PORT);

  if((recv(sock,buffer,sizeof(buffer),0)) == -1)    // on reçoit les données du serveur et on les place dans buffer
  {
   printf("erreur lors de la réception des données\n");
   return 0;
  }

 printf("buffer: %s\n",buffer);     // on affiche le buffer

 close(sock);   // on détruit la socket
 return 0;
}

//###############################################################################################################

int ecouter(char*PORT)
{
 char msg[]="Bienvenue sur le serveur!";  // message qu'on enverra aux éventuels clients qui se connecteront

 struct sockaddr_in sin;    // pareil que pour le client plus haut
 sin.sin_family      = AF_INET;
 sin.sin_addr.s_addr = INADDR_ANY; // on a pas besoin d'une adresse puisqu'on est pas client
 sin.sin_port        = htons(atoi(PORT));
 bzero(&(sin.sin_zero),8);

  if((sock = socket(AF_INET,SOCK_STREAM,0)) == -1)
  {
   printf("erreur lors de l'initialisation de la socket\n");
   return 0;
  }

  if((bind(sock, (struct sockaddr *)&sin, sizeof(struct sockaddr))) == -1)  // on "réserve" le port
  {
   printf("erreur lors de la réservation du port %s\n",PORT);
   return 0;
  }

  if((listen(sock,50)) == -1)     // on écoute le port
  {
   printf("erreur lors de l'écoute du port %s\n",PORT);
   return 0;
  }

 printf("port %s en écoute...\n",PORT);

  while(1) // boucle infini
  {
   int sin_size = sizeof(struct sockaddr_in);
    if ((nsock = accept(sock,(struct sockaddr *)&sin,&sin_size)) == -1) // nsock (new sock) est un nouveau client
    {
     printf("erreur lors de la connection du client\n");
     continue;
    }

   printf("connection de %s sur le port %s\n",inet_ntoa(sin.sin_addr),PORT);

    if (!fork())
    {
      if (send(nsock,msg,sizeof(msg),0) == -1)  // on essaie d'envoyer au client le message
      {
       printf("erreur lors de l'envoie du message\n");
       return 0;
      }

     close(nsock); // détruit la socket
     return 0;
    }
    close(nsock);
   }

 return 0;
}

//###############################################################################################################

int scanner(char*HOST,char*PORT1,char*PORT2) // pour scanner, pas besoin de commentaires, c'est comme le client
{                                            // mais il se connecte sur plusieurs port pour les tester
 int n;                                      // et ne reçoit pas de données

 struct hostent*IP;
  if ((IP = gethostbyname(HOST)) == NULL)
  {
   printf("erreur IP incorrect\n");
   return 0;
  }

 printf("scan de %s...\n",inet_ntoa(*((struct in_addr *)IP -> h_addr)));

  for(n = (atoi(PORT1)); n < (atoi(PORT2)); n++)
  {
    if((sock = socket(AF_INET,SOCK_STREAM,0)) == -1)
    {
     printf("erreur lors de l'initialisation de la socket\n");
     return 0;
    }

   struct sockaddr_in sin;
   sin.sin_family = AF_INET;
   sin.sin_addr   = *((struct in_addr *)IP -> h_addr);
   sin.sin_port   = htons(n);
   bzero(&(sin.sin_zero),8);

    if((connect(sock,(struct sockaddr*)&sin,sizeof(struct sockaddr))) == 0)
    {
     printf("%i OUVERT\n",n);
    }

   close(sock);
  }

 close(sock);
 return 0;
}