Discussion :

[robertmouac]

Bonjour tout le monde.
Je suis en train de coder une version simplifier du protocol TCP/IP en raw socket. Je formate et deformate bien les trames (verif avec ethreal). Le problème se passe lors de la demande de connexion du client vers un serveur:
J'envoie la demande de connexion au serveur: trame SYN
Le serveur me repond avec un SYN/ACK.
Et la mon système envoi, malgres moi , un RST.
Et biensur la connexion est fermé
J'ai donc tenté de me renseigner un max... mais bon rien qui a reussi a me debloquer
Ca fait un bon moment que je couince sur le problème et je deviens completement
je precise que je suis sous linux debian avec un noyau 2.4.22
Merci
A12C4

[Nasky]

Donc en fait, c'est au moment d'envoyer le ACK du client vers le serveur que ton OS (très bon OS ) arrête la connexion?
Ne serait-ce pas un problème du à une configuration de Netfilter (iptable)?
Parce que si c'est ton OS qui prend les décisions à ta place, ça doit surement venir de sa configuration. J'ai déjà eu ce problème mais c'était pas un RST mais un FIN...
Montre ton code (meme si je pense que t'as bien du coder le programme).

Et tu devrais poster ton message sur le forum "Developpement réseaux" où t'auras plus de réponses (surtout que tu n'as pas montré de code C ).

Nas'

[robertmouac]

Je vais essayer de faire court

Fonction qui format et envoi les trames

void envTcp() {
char tampon[TAILLE_PACKET];
char strPacket[TAILLE_PACKET];
int szbuff; /* taille du buffer */
int szpkt; /* taille du packet */

/* configuration packet */
char *src_ip=strSrcIp; /* arrive src ip */
char *dst_ip=strDstIp; /* arrive dst ip */
short chk;
int addr_len;

unsigned char version;
int i;


szbuff=strlen(strData);
szpkt=sizeof(struct tcphdr)+sizeof(struct iphdr)+szbuff;
/* fabrique de l'entete ip */
ip.version = 4; /* IPV4 */
ip.ihl = 5;
ip.tot_len = htons(szpkt); /* Taille du packet */
ip.id = htons(iIdIp); /* ID */
ip.frag_off = htons(iFragOffIp); /* frag off */
ip.ttl = iTtlIp; /* TTL */
ip.protocol = IPPROTO_TCP; /* Protocol 6 = TCP */
ip.saddr = rsrc_ip; /* source ip */
ip.daddr = rdst_ip; /* dst ip */
ip.tot_len = htons(szpkt); /* Taille du packet */
ip.check = in_cksum((u_short *)&ip, TAILLE_IPHDR);


/* fabrique de l'entete tcp */
tcp.source = htons(iSrcPort); /* port source */
tcp.dest = htons(iDstPort); /* port dest */
tcp.seq = htonl(iSeqn);
tcp.ack_seq = htonl(iAckn);
tcp.doff = (TAILLE_TCPHDR*8)/32; //iDoff; /* 5? */
tcp.fin = iFin;
tcp.syn = iSyn;
tcp.rst = iRst;
tcp.psh = iPsh;
tcp.ack = iAck;
tcp.urg = iUrg;
tcp.window = htons(iWinn); /* 512 ? */
tcp.urg_ptr = iUrgp;
tcp.check = 0;


/* fabrique de la pseudo entete tcp pour le calcul du checksum */
pseudoTcp.saddr = rsrc_ip;
pseudoTcp.daddr = rdst_ip;
pseudoTcp.zero = 0;
pseudoTcp.protocol=IPPROTO_TCP;
pseudoTcp.length = htons(TAILLE_TCPHDR+szbuff);
memcpy(tampon, &pseudoTcp, TAILLE_PSEUDO_TCPHDR);
memcpy(tampon+TAILLE_PSEUDO_TCPHDR, &tcp, TAILLE_TCPHDR);
memcpy(tampon+TAILLE_PSEUDO_TCPHDR+TAILLE_TCPHDR, strData, strlen(strData));

/* Calcul du checksum pour l'entete tcp */
tcp.check = in_cksum((unsigned short *)&tampon,
TAILLE_PSEUDO_TCPHDR+TAILLE_TCPHDR+strlen(strData));
memcpy(strPacket, &ip, TAILLE_IPHDR);
memcpy(strPacket+TAILLE_IPHDR, &tcp, TAILLE_TCPHDR);
memcpy(strPacket+TAILLE_IPHDR+TAILLE_TCPHDR, strData, strlen(strData));

addr_len = sizeof(struct sockaddr);
/* envoie de la trame */
sendto(sd, &strPacket, szpkt, 0, (struct sockaddr *) &sock,
sizeof(struct sockaddr));
/* Reception de la trame reponse */
rcpTcp();
}

Fonction principale
int main() {

strcpy (strSrcIp, "192.168.0.2");
strcpy (strDstIp, "192.168.0.1");
strcpy (strData, "");
iSrcPort = 6969;
iDstPort = 62000;


iIdIp = 1; /* -identification */
iFragOffIp = 16384; /* -fragment */
iTtlIp = 64; /* -duree de vie : nb max de routeur que peut traverser le packet */

iSyn = 1;
iFin = 0;
iAck = 0;
iRst = 0;
iPsh = 0;
iUrg = 0;
iRes1 = 0;
iRes2 = 0;
iSeqn = 1;
iAckn = 0;
iUrgp = 0;
iDoff = 5;
iWinn = 63360;
/* formatage et envoie du packet */
/* ouverture de la socket */
envSock();
recepSock();
envTcp();

iIdIp = 2;
iSyn = 0;
iFin = 0;
iAck = 1;
iRst = 0;
iPsh = 0;
iUrg = 0;
iAckn = 1;
iSeqn = 1;
envTcp();

iIdIp = 3;
iSyn = 0;
iFin = 0;
iAck = 0;
iRst = 0;
iPsh = 1;
iUrg = 0;
iAckn = 0;
iSeqn = 0;
strcpy (strData, "TOTO");
envTcp();


/* Fermeture du socket */
close (sd);
close (sd_recep);
printf ("fin\n");
printf ("bye bye\n");
return (OK);
}

Voilou
Bon courage

[robertmouac]

c'est exactement ca qui se passe Nasky !
Losque mon client doit envoyer le ACK (en reponse au SYN du serveur) l'os me devance et envoi en RST, et forcement le ACK de mon client n'a plus aucun effet