TCP/IP Stack - Connection closed nach ACK

[MiSc (Gast)]

Hallo,
ich bin gerade dabei einen TCP/IP Stack auf einem ATMega32 zu 
implementieren, als Netzwerk Schnittstelle kommt ein ENC28J60 zum 
Einsatz.

ARP, ICMP, DHCP und UDP funktionieren soweit schon einmal, doch beim TCP 
Teil gibt es ein Problem.
Ich teste den TCP Stack, indem ich mich mit einem Telnet-Client (telnet 
unter Linux) zum µC verbinde. Der Handshake funktioniert auch ohne 
Probleme, doch sofort nach dem Handshake meldet telnet "Connection 
closed by foreign host.", jedoch sendet weder der telnet Client noch der 
ATMega weitere Pakete (siehe WireShark Datei / Screenshot).
Verbinde ich mich mit dem telnet Client zu einem anderen Server (z.B. 
XAMPP), sehe ich in Wireshark die gleichen Pakete, allerdings bricht die 
Verbindung nicht ab, und ich kann mit telnet Pakete verschicken.

Weiß jemand wo der Fehler liegen könnte?

Hier ist der Ausschnitt der zugehörigen C Datei:

void handle_tcp(uint8_t* data) {
 EthernetFrame* eth = (EthernetFrame*)(data);
 TCPHeader* tcp = (TCPHeader*)(data + TCP_HEADER_POS);
 IPHeader* ip = (IPHeader*)(data + IP_HEADER_POS);
 
 // look if this port is registered
 uint8_t idx, i, len1;
 if((idx = tcpFindEntry(ntohs(tcp->dst_port))) < MAX_TCP_SOCKETS) {

  // syn from client
  if((tcp->flags & TCP_FLAG_MASK) == TCP_SYN && TCPSocket[idx].status == TCP_LISTENING) {
   
   TCPSocket[idx].status = TCP_SYN_RECV;
   TCPSocket[idx].ack_nr = ntohl(tcp->seq_nr) + 1;
   TCPSocket[idx].seq_nr = network_clock;
   TCPSocket[idx].src_port = ntohs(tcp->src_port);
   TCPSocket[idx].window = 384;

   generateEthernetFrame(send_buffer, eth->MAC_src, 0x0800); // ethernet: ip
   generateIPHeader(send_buffer + IP_HEADER_POS, ip->ip_src, 0x06, IP_HEADER_LEN + TCP_HEADER_LEN + 4 + 4);
   generateTCPPacket(send_buffer + TCP_HEADER_POS, idx, 0);

   // send syn | ack
   enc28j60PacketSend(MAX(60, ETHERNET_FRAME_LEN + IP_HEADER_LEN + TCP_HEADER_LEN + 4 + 4), send_buffer);
   return;
  }
 
   // send ack
  if((tcp->flags & TCP_ACK) && TCPSocket[idx].status == TCP_ESTABLISHED) {
   uint16_t len =  ntohs(ip->ip_len) - IP_HEADER_LEN;
   len -= tcp->off / 4;

   TCPSocket[idx].seq_nr = ntohl(tcp->ack_nr);
   TCPSocket[idx].ack_nr = ntohl(tcp->seq_nr) + len;

   generateEthernetFrame(send_buffer, eth->MAC_src, 0x0800); // ethernet: ip
   generateIPHeader(send_buffer + IP_HEADER_POS, ip->ip_src, 0x06, IP_HEADER_LEN + TCP_HEADER_LEN + TSV_LEN);
   generateTCPPacket(send_buffer + TCP_HEADER_POS, idx, 0);

   // send ack
   enc28j60PacketSend(MAX(60, ETHERNET_FRAME_LEN + IP_HEADER_LEN + TCP_HEADER_LEN + TSV_LEN), send_buffer);

   return;
  }
  
  // ack from client
  if((tcp->flags & TCP_FLAG_MASK) == TCP_ACK && TCPSocket[idx].status == TCP_SYN_RECV) {
   TCPSocket[idx].status = TCP_ESTABLISHED;
   TCPSocket[idx].seq_nr = ntohl(tcp->seq_nr);
   return;
  }
  
  // end connection
  if((tcp->flags & TCP_FIN) || (tcp->flags & TCP_RST)) {
   TCPSocket[idx].status = TCP_LISTENING;
   return;
  }
 }
}

void generateTCPPacket(uint8_t* data, uint8_t idx, uint16_t length) {
 TCPHeader* tcp = (TCPHeader*)(data);

 tcp->src_port = htons(TCPSocket[idx].port);
 tcp->dst_port = htons(TCPSocket[idx].src_port);
 tcp->flags = 0;
 switch(TCPSocket[idx].status) {
  case TCP_SYN_RECV:
   tcp->flags = TCP_SYN | TCP_ACK;
   break;
  
  case TCP_ESTABLISHED:
   tcp->flags = TCP_ACK;
   break;
 }

 tcp->off = 80;
 tcp->window_size = htons(TCPSocket[idx].window);
 tcp->urgent_ptr = 0;
 tcp->checksum = 0;
 tcp->seq_nr = htonl(TCPSocket[idx].seq_nr);
 tcp->ack_nr = htonl(TCPSocket[idx].ack_nr);
 
 if((TCPSocket[idx].status == TCP_SYN_RECV) ) {
  data[TCP_HEADER_LEN] = 2;
  data[TCP_HEADER_LEN + 1] = 4;
  data[TCP_HEADER_LEN + 2] = (TCP_MSS >> 8) & 0xff;
  data[TCP_HEADER_LEN + 3] = TCP_MSS & 0xff;
  
  data[TCP_HEADER_LEN + 4] = 1; // nop
  data[TCP_HEADER_LEN + 5] = 3; // windows scale = 0
  data[TCP_HEADER_LEN + 6] = 3;
  data[TCP_HEADER_LEN + 7] = 0;
  
  tcp->off = 0x60 + 16;
  length += 4 + 4;
 }
 
 uint16_t data_len = TCP_HEADER_LEN + length + 8;
 uint32_t start_val = data_len - 2;

 tcp->checksum = htons(checksum((data - IP_HEADER_LEN + 12), start_val, data_len));
}

[MiSc (Gast)]

Ich habe den Fehler mittlerweile gefunden, schuld am Schließen der 
Verbindung war unter anderem der Router.

Dieser hat nach dem Handshake ein RST an den PC gesendet, hat aber als 
Absender IP die des ATMega Servers verwendet. Bei meiner weiteren 
Analyse habe ich entdeckt, dass er das macht, weil durch einen Fehler 
von mir das IG Bit in der MAC Adresse gesetzt war. Aus welchem Grund der 
Router das RST Paket gesendet hat, ist mir zwar dennoch nicht klar, 
jedoch funktioniert es jetzt.

Vielleicht hat ja jemand einmal ein ähnliches Problem und meine Lösung 
hilft dabei das Problem zu lösen.