Bonjour à tous,

Pour un projet de fin d'année en réseau, je dois réaliser une implémentation du protocole TFTP en C (selon la norme RFC 1350 : https://tools.ietf.org/html/rfc1350) avec les gestion des options (norme RFC 2347 https://tools.ietf.org/html/rfc2347).

J'ai un problème pour construire un paquet OACK. Sur mon sujet, le prototype de la fonction est fourni comme suit :

int tftp_make_oack(char *buffer, size_t *length, uint16_t bloc, size_t nbytes, size_t nblocks);

D'après ce que j'ai compris :

• buffer correspond au tampon qui contiendra le paquet.
• length contient la taille du tampon et contiendra la taille finale du paquet.
• bloc ?
• nbytes contient le nombre d'octets de chaque bloc.
• nblocks RFC 2348 http://www.rfc-editor.org/rfc/rfc2348.txt

Donc mon problème c'est l'argument bloc, je ne comprends pas son utilité.

Pour rappel, voici la forme d'un paquet OACK :

+-------+---~~---+---+---~~---+---+---~~---+---+---~~---+---+
|  opc  |  opt1  | 0 | value1 | 0 |  optN  | 0 | valueN | 0 |
+-------+---~~---+---+---~~---+---+---~~---+---+---~~---+---+

Où :

• opc est l'opcode du paquet (6 pour un OACK).
• opt1 est le nom de la première option.
• value1 est la valeur de la première option.

Les 0 sont le caractère de fin de chaîne.

Vous avez une idée de ce que peut-etre l'argument bloc dans la fonction ? Je vois pas du tout à quoi il peut servir parce que j'arrive à construire le paquet sans cet argument. Je doute que ce soit une erreur du sujet.

Merci

Je peux plus éditer mon message et j'ai une petite précision à apporter :
Mon paquet OACK devra ressembler à ça :

+-------+-------+---+------+---+------------+---+---+---+
|  6  | blksize | 0 | 1024 | 0 | windowsize | 0 | 5 | 0 |
+-----+---------+---+------+---+------------+---+---+---+

J'ai déjà réussi, mais sans utiliser l'argument bloc, ce qui n'est pas normal.
Voici mon code :

int tftp_make_oack(char *buffer, size_t *length, size_t nbytes, size_t nblocks) {
  // Vérifie les arguments
  if (buffer == NULL || length == NULL) {
    return EARGU;
  }
  
  if (nbytes < 8 || nbytes > 65464) {
    return EARGU;
  }
  
  if (nblocks < 1 || nblocks > 65535) {
    return EARGU;
  }
  
  // Construit le paquet
  char snbytes[6];
  char snblocks[6];
  uint16_t opcode = htons(OACK);
  
  sprintf(snbytes, "%zu", nbytes);
  sprintf(snblocks, "%zu", nblocks);
  
  memset(buffer, 0, *length);
  *length = 0;
  memcpy(buffer, &opcode, sizeof(uint16_t));
  *length += sizeof(uint16_t);
  memcpy(buffer + *length, "blksize", strlen("blksize") + 1);
  *length += sizeof(char) * (strlen("blksize") + 1);
  memcpy(buffer + *length, snbytes, strlen(snbytes) + 1);
  *length += sizeof(char) * (strlen(snbytes) + 1);
  memcpy(buffer + *length, "windowsize", strlen("windowsize") + 1);
  *length += sizeof(char) * (strlen("windowsize") + 1);
  memcpy(buffer + *length, snblocks, strlen(snblocks) + 1);
  *length += sizeof(char) * (strlen(snblocks) + 1);
  
  return 0;
}

Quelqu'un a déjà fait ça avant toi : https://github.com/labcoder/simple-tftp

et sûrement d'autres

inutile de réinventer la roue n'est-ce pas ?

Le 25 avril 2016 à 21:45:34 psdal a écrit :
Quelqu'un a déjà fait ça avant toi : https://github.com/labcoder/simple-tftp

et sûrement d'autres

inutile de réinventer la roue n'est-ce pas ?

A mon avis ça lui servira à avoir son année

Ouais j'suis pas contre.

Mais perso j'trouve ça hyper débile de ne pas essayer d'innover (créer un nouveau protocole , faire des apps node/websockets quand on le peut), ça m'étonnerait que les règles de projet soient si strictes qu'on ne puisse pas faire un truc original...