Traduction C

Signaler
Messages postés
1
Date d'inscription
jeudi 11 novembre 2010
Statut
Membre
Dernière intervention
11 novembre 2010
-
Messages postés
14867
Date d'inscription
lundi 11 juillet 2005
Statut
Modérateur
Dernière intervention
24 novembre 2020
-
Salut tous le monde,
Je ne développe pas avec le langage C, je fais comme étude Réseaux
Mais je viens devant une situation de réseaux et veux comprendre la démarche, le probleme est que l'outils est développé en C et pour comprendre la démarche il faut que je comprend le C.

En tous cas, je vous demande SVP que vous me faire la traduction,
juste chaque instruction que ce qu'elle fait;
(l'outil envoie des paquets TCP à un port de destination puis signale les paquets qu'il reçoit en retour. Mais je sais pas comment ca marche.)


Voici le code:
void listenmain(void)
{


int size, ip_size;

int stdoutFD = fileno(stdout);

#ifndef WIN32

char packet[IP_MAX_SIZE+linkhdr_size];
#endif

char *p, *ip_packet;

struct myiphdr ip;
__u16 id;

static __u16 exp_id;
/* expected id */

#ifdef WIN32
char *packet;



packet = malloc(sizeof(char) * (IP_MAX_SIZE + linkhdr_size));

if (packet == NULL) {
fprintf(stderr, "[malloc] failed: %d\n", GetLastError());
exit(1);
}
#endif


exp_id = 1;




while(1) {


size = read_packet(packet, IP_MAX_SIZE + linkhdr_size);


switch(size) {

case 0:
continue;

case -1:
exit(1);
}



/* Skip truncated packets */


if (size < linkhdr_size + IPHDR_SIZE)
continue;


ip_packet = packet + linkhdr_size;



/* copy the ip header so it will be aligned */

memcpy(&ip, ip_packet, sizeof(ip));

id = ntohs(ip.id);

ip_size = ntohs(ip.tot_len);

if (size-linkhdr_size > ip_size)
size = ip_size;

else
size -= linkhdr_size;


if ((p = memstr(ip_packet, sign, size)))
{

if (opt_verbose)
fprintf(stderr, "packet %d received\n", id);


if (opt_safe) {

if (id == exp_id)
exp_id++;

else {

if (opt_verbose)
fprintf(stderr, "packet not in sequence (id %d) received\n", id);

send_hcmp(HCMP_RESTART, exp_id);

if (opt_verbose)
fprintf(stderr, "HCMP restart from %d sent\n", exp_id);
continue;
/* discard this packet */

}

}


p+=strlen(sign);

write(stdoutFD, p, size-(p-ip_packet));

}


}


}

1 réponse

Messages postés
14867
Date d'inscription
lundi 11 juillet 2005
Statut
Modérateur
Dernière intervention
24 novembre 2020
93
Hello,
Voici mon interprétation.
void listenmain(void) 
{ 
  ////////////////////////////
  // Début Bloc Init Variables
  int size, ip_size; 

  int stdoutFD = fileno(stdout); // récupération de la sortie standard (= console)

  #ifndef WIN32 // Pour les autres plateformes que Windows
  char packet[IP_MAX_SIZE+linkhdr_size]; 
  #endif 

  char *p, *ip_packet; 

  struct myiphdr ip; 
  __u16 id; 

  static __u16 exp_id; // je suppose que c'est le numéro du paquet attendu à un instant t. on l'init à 1 un peu plus bas.
  /* expected id */ 

  #ifdef WIN32 // Seulement pour Windows
  char *packet; 
  packet = malloc(sizeof(char) * (IP_MAX_SIZE + linkhdr_size));   // allocation du buffer
  if (packet == NULL) {                       // si null -> erreur allocation
    fprintf(stderr, "[malloc] failed: %d\n", GetLastError());   // affichage message d'erreur
    exit(1); 
    } 
  #endif 

  exp_id = 1;
  
  // Buno: Fin Bloc Init Variables
  ////////////////////////////////

  while(1) { // Boucle sans fin

    // Réception de paquets
    size = read_packet(packet, IP_MAX_SIZE + linkhdr_size); 

    // Vérification du retour: size contient le nombre d'octets lus
    switch(size) { 
      case 0: // rien reçu -> on continue, c'est-à-dire qu'on retourne au début de la boucle
        continue; 
      case -1: // erreur -> on quitte (pas très propre, mais bon...)
        exit(1); 
    } 

    // ici, on a reçu "quelque chose" dans le buffer "packet"

    /* Skip truncated packets */ 
    if (size < linkhdr_size + IPHDR_SIZE)
      continue; 
      
    // ici, on sait que packet est complètement rempli

    // on récupère la l'adresse IP (?) qui se trouve à une position fixe dans le buffer: linkhdr_size
    ip_packet = packet + linkhdr_size; 

    /* copy the ip header so it will be aligned */ 
    // on stocke cette adresse dans la variable ip
    memcpy(&ip, ip_packet, sizeof(ip)); 

    // "bidouille" pour récupérer les infos dans le "bon format"
    // ntohs = short from Network To Host alignement
    id = ntohs(ip.id); 
    ip_size = ntohs(ip.tot_len); 

    // mise à jour de la taille
    if (size-linkhdr_size > ip_size) 
      size = ip_size; 
    else 
      size -= linkhdr_size; 

    // on recherche si le caractère "sign" est présent dans le packet
    if ((p = memstr(ip_packet, sign, size))) 
    { 
      // si oui
      
      // si l'option verbose est activée,
      // on affiche un message disant qu'on a bien reçu un paquet en indiquant son numéro
      if (opt_verbose) 
        fprintf(stderr, "packet %d received\n", id); 

      // si l'option safe est activée
      if (opt_safe) { 
        if (id == exp_id) // on teste si le paquet est celui attendu
          exp_id++; // si oui, on incrémente le numéro du paquet attendu
        else { //sinon
          // verbose? affichage message erreur
          if (opt_verbose) 
            fprintf(stderr, "packet not in sequence (id %d) received\n", id); 

          // Envoi d'une commande de restart, avec le numéro du paquet attendu
          send_hcmp(HCMP_RESTART, exp_id); 

          // verbose? affichage message
          if (opt_verbose) 
            fprintf(stderr, "HCMP restart from %d sent\n", exp_id); 
          
          continue; 
          /* discard this packet */ 
          // on ne prend pas en compte ce paquet et on retourne au début de la boucle
          // pour en attendre un nouveau
        } 
      } 

      // p doit contenir une information de taille,
      // que l'on incrémente si "sign" est présent dans le paquet
      p+=strlen(sign); 
      
      // affichage dans la sortie standard de l'information de taille
      write(stdoutFD, p, size-(p-ip_packet)); 
    } 
  } 
}


@+
Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, prévoir un délai...