Net : utilitaire linux sockets

Commenter

Contenu du snippet

ce prog pour linux fait le serveur
se connecte a un serveur
scanne un hote

syntaxe :
net [hote] [port] pour se connecter
net -l [port] pour écouter (serveur)
net -s [hote] [port1] [port2] pour scanner du port1 au port2

Source / Exemple : 


#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;
}

Conclusion :


je l'ai assez bien commenté
si il y a des erreurs, dites le

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Krox68)