Hello,
I am new to LWIP and have been working on a TCP server on my board with a
STM32F429ZI and my
PHY is a DP83848C. The LWIP version being used is v2.1.2. I am using raw
API and copied the echo
server example that is provided and have changed the tcp_server_send
function but I not sure if this was
the right approach for what I want to do. I have separate pbufs that are
used for transmitting that are used in a rotation, these pbufs are
initialized in the server_init. This is so that I do not accidently
overwrite a buffer somehow.
I have a TCP server running which has packets being sent to it every 50 ms.
These packets have
different lengths which I handle and respond to accordingly in my
ValidatePacket()
and ProcessPacket() packet which stores the data I want to send in an
array, this array is then
copied into the payload buffer and sent with tcp_write.
This setup has worked very well however there are times when a packet is
transmitted later than normal,
which I am guessing is a retransmission of the packet but this is too slow
(> 50 ms). This seems to
happen randomly, I have not yet found a pattern to what the problem is. I
have used the debug
messages to see if I can find something however, this has yielded no
problems, memory seems to
completely fine throughout the process.
I do not have a pcap file yet, since the system that is sending packets is
not something I can monitor
using wireshark however I am able to get the tcpdump from the client which
might be of use. In the
meantime I am trying to write my own client to try and replicate the real
client and use wireshark.
In the tcpdump I have two examples of this problem occuring. The server is
at x.x.x.78 whilst the client is
from x.x.x.3. In the first example the client packet is sent in line 6 and
the board's response happens at
line 10 which is too late. In the second example, client sends a packet at
line 46, board responds at line
52, again too slow.
In the past I have tried upgrading the LWIP files to 2.1.3 and 2.2.0
however this did not fix my problem. If
you have any suggestions or find some problems with my code, please let me
know.
Attached is my tcp_server file and tcpdump file.
Thank you in advance,
Sam
/**
* Copyright (c) 2001-2004 Swedish Institute of Computer Science.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY
* OF SUCH DAMAGE.
*
* This file is part of and a contribution to the lwIP TCP/IP stack.
*
* Credits go to Adam Dunkels (and the current maintainers) of this software.
*
* Christiaan Simons rewrote this file to get a more stable echo application.
*
**/
/* This file was modified by ST */
#include "lwip/debug.h"
#include "lwip/stats.h"
#include "lwip/tcp.h"
#include <string.h>
#include "OwnCode\Ethernet.h"
#include "Owncode\UARTDebug.h"
#define TCP_SERVER_PORT 52360 /* define the UDP local connection port
*/
#define PBUF_NUM 5
#if LWIP_TCP
static struct tcp_pcb *tcp_server_pcb;
static struct pbuf *txPBUF[PBUF_NUM];
uint8_t txPBUF_count = 0;
// OWN USER VARIABLE
uint8_t payloadbuffer[PBUF_MAXLENGTH]; // Buffer to copy the packet into - 1000
bytes
/* protocol states */
enum tcp_server_states
{
ES_NONE = 0,
ES_ACCEPTED,
ES_RECEIVED,
ES_CLOSING
};
/* structure for maintaining connection infos to be passed as argument
to LwIP callbacks*/
struct tcp_server_struct
{
u8_t state; /* current connection state */
u8_t retries;
struct tcp_pcb *pcb; /* pointer on the current tcp_pcb */
struct pbuf *p; /* pointer on the received/to be transmitted pbuf */
};
static err_t tcp_server_accept(void *arg, struct tcp_pcb *newpcb, err_t err);
static err_t tcp_server_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
err_t err);
static void tcp_server_error(void *arg, err_t err);
static err_t tcp_server_poll(void *arg, struct tcp_pcb *tpcb);
static err_t tcp_server_sent(void *arg, struct tcp_pcb *tpcb, u16_t len);
static void tcp_server_send(struct tcp_pcb *tpcb, struct tcp_server_struct *es);
static void tcp_server_connection_close(struct tcp_pcb *tpcb, struct
tcp_server_struct *es);
/**
* @brief Initializes the tcp server
* @param None
* @retval None
*/
void tcp_server_init(void)
{
/* create new tcp pcb */
tcp_server_pcb = tcp_new();
if (tcp_server_pcb != NULL)
{
err_t err;
err = tcp_bind(tcp_server_pcb, IP_ADDR_ANY, TCP_SERVER_PORT);
if (err == ERR_OK)
{
/* start tcp listening for pcb */
tcp_server_pcb = tcp_listen(tcp_server_pcb);
/* initialize LwIP tcp_accept callback function */
tcp_accept(tcp_server_pcb, tcp_server_accept);
}
else
{
/* deallocate the pcb */
memp_free(MEMP_TCP_PCB, tcp_server_pcb);
}
}
for (uint8_t i = 0; i < PBUF_NUM; i++) {
txPBUF[i] = pbuf_alloc(PBUF_TRANSPORT, PBUF_MAXLENGTH, PBUF_RAM); //
Allocate pbuf in RAM with enough length
}
}
/**
* @brief This function is the implementation of tcp_accept LwIP callback
* @param arg: not used
* @param newpcb: pointer on tcp_pcb struct for the newly created tcp
connection
* @param err: not used
* @retval err_t: error status
*/
static err_t tcp_server_accept(void *arg, struct tcp_pcb *newpcb, err_t err)
{
err_t ret_err;
struct tcp_server_struct *es;
LWIP_UNUSED_ARG(arg);
LWIP_UNUSED_ARG(err);
/* set priority for the newly accepted tcp connection newpcb */
tcp_setprio(newpcb, TCP_PRIO_MIN);
/* allocate structure es to maintain tcp connection informations */
es = (struct tcp_server_struct *)mem_malloc(sizeof(struct tcp_server_struct));
if (es != NULL)
{
es->state = ES_ACCEPTED;
es->pcb = newpcb;
es->retries = 0;
es->p = NULL;
/* pass newly allocated es structure as argument to newpcb */
tcp_arg(newpcb, es);
/* initialize lwip tcp_recv callback function for newpcb */
tcp_recv(newpcb, tcp_server_recv);
/* initialize lwip tcp_err callback function for newpcb */
tcp_err(newpcb, tcp_server_error);
/* initialize lwip tcp_poll callback function for newpcb */
tcp_poll(newpcb, tcp_server_poll, 0);
/* initialize lwip tcp_sent callback function for newpcb */
tcp_sent(newpcb, tcp_server_sent);
ret_err = ERR_OK;
}
else
{
/* close tcp connection */
tcp_server_connection_close(newpcb, es);
/* return memory error */
ret_err = ERR_MEM;
}
return ret_err;
}
/**
* @brief This function is the implementation for tcp_recv LwIP callback
* @param arg: pointer on a argument for the tcp_pcb connection
* @param tpcb: pointer on the tcp_pcb connection
* @param pbuf: pointer on the received pbuf
* @param err: error information regarding the reveived pbuf
* @retval err_t: error code
*/
static err_t tcp_server_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
err_t err)
{
struct tcp_server_struct *es;
err_t ret_err;
LWIP_ASSERT("arg != NULL",arg != NULL);
es = (struct tcp_server_struct *)arg;
/* if we receive an empty tcp frame from client => close connection */
if (p == NULL)
{
/* remote host closed connection */
es->state = ES_CLOSING;
if(es->p == NULL)
{
/* we're done sending, close connection */
tcp_server_connection_close(tpcb, es);
}
else
{
/* send remaining data*/
tcp_server_send(tpcb, es);
}
ret_err = ERR_OK;
}
/* else : a non empty frame was received from client but for some reason err
!= ERR_OK */
else if(err != ERR_OK)
{
/* free received pbuf*/
if (p != NULL)
{
pbuf_free(p);
}
ret_err = err;
}
else if(es->state == ES_ACCEPTED)
{
/* first data chunk in p->payload */
es->state = ES_RECEIVED;
/* store reference to incoming pbuf (chain) */
es->p = p;
/* send back the data */
tcp_server_send(tpcb, es);
ret_err = ERR_OK;
}
else if (es->state == ES_RECEIVED)
{
/* more data received from client and previous data has been already sent*/
if(es->p == NULL)
{
es->p = p;
/* send back data */
tcp_server_send(tpcb, es);
}
else
{
struct pbuf *ptr;
/* chain pbufs to the end of what we recv'ed previously */
ptr = es->p;
pbuf_cat(ptr,p);
}
ret_err = ERR_OK;
}
else
{
/* unknown es->state, trash data */
tcp_recved(tpcb, p->tot_len);
es->p = NULL;
pbuf_free(p);
ret_err = ERR_OK;
}
return ret_err;
}
/**
* @brief This function implements the tcp_err callback function (called
* when a fatal tcp_connection error occurs.
* @param arg: pointer on argument parameter
* @param err: not used
* @retval None
*/
static void tcp_server_error(void *arg, err_t err)
{
struct tcp_server_struct *es;
LWIP_UNUSED_ARG(err);
es = (struct tcp_server_struct *)arg;
if (es != NULL)
{
/* free es structure */
mem_free(es);
}
}
/**
* @brief This function implements the tcp_poll LwIP callback function
* @param arg: pointer on argument passed to callback
* @param tpcb: pointer on the tcp_pcb for the current tcp connection
* @retval err_t: error code
*/
static err_t tcp_server_poll(void *arg, struct tcp_pcb *tpcb)
{
err_t ret_err;
struct tcp_server_struct *es;
es = (struct tcp_server_struct *)arg;
if (es != NULL)
{
if (es->p != NULL)
{
/* there is a remaining pbuf (chain) , try to send data */
tcp_server_send(tpcb, es);
}
else
{
/* no remaining pbuf (chain) */
if(es->state == ES_CLOSING)
{
/* close tcp connection */
tcp_server_connection_close(tpcb, es);
}
}
ret_err = ERR_OK;
}
else
{
/* nothing to be done */
tcp_abort(tpcb);
ret_err = ERR_ABRT;
}
return ret_err;
}
/**
* @brief This function implements the tcp_sent LwIP callback (called when ACK
* is received from remote host for sent data)
* @param None
* @retval None
*/
static err_t tcp_server_sent(void *arg, struct tcp_pcb *tpcb, u16_t len)
{
struct tcp_server_struct *es;
LWIP_UNUSED_ARG(len);
es = (struct tcp_server_struct *)arg;
es->retries = 0;
if(es->p != NULL)
{
/* still got pbufs to send */
tcp_sent(tpcb, tcp_server_sent);
tcp_server_send(tpcb, es);
}
else
{
/* if no more data to send and client closed connection*/
if(es->state == ES_CLOSING)
tcp_server_connection_close(tpcb, es);
}
return ERR_OK;
}
/**
* @brief This function is used to send data for tcp connection
* @param tpcb: pointer on the tcp_pcb connection
* @param es: pointer on state structure
* @retval None
*/
uint32_t counter = 0;
static void tcp_server_send(struct tcp_pcb *tpcb, struct tcp_server_struct *es)
{
//---------------------------------------------------------------
// ENTIRE FUNCTION REWRITTEN HERE
// FunctionDebug(4,0,0);
uint16_t length = es-> p -> len; // Length of packet
uint8_t packetType = 0;
uint8_t free; // Free variable to check when freeing pbufs
int8_t err;
if (length == 8 || length == 30 || length == 34) {}
else {
printf("Different Length: %lu\n", counter);
counter = 0;
}
memcpy((char*)payloadbuffer,es-> p -> payload,es-> p -> len); // Copy
packet into buffer
packetType = ValidatePacket(payloadbuffer, length); // Check for
checksum and length errors
if (packetType != 0) {
length = ProcessPacket(payloadbuffer, packetType);
if (length != 0) {
// Copy response packet and place it into LWIP pbuf
memcpy(txPBUF[txPBUF_count] -> payload,
(char*)payloadbuffer, length);
txPBUF[txPBUF_count] -> len = length;
txPBUF[txPBUF_count] -> tot_len = length;
if (txPBUF[txPBUF_count]->len <= tcp_sndbuf(tpcb)) {
err = tcp_write(tpcb,
txPBUF[txPBUF_count]->payload, txPBUF[txPBUF_count]->len, 1); // Queue the data
to be sent back and send
//printf("Write: (%p), err: %i\n", (void *)
tpcb -> unsent, err);
if (err != 0) {
printf("tcp_write error\n");
}
else {
counter++;
}
}
else {
printf("length too big\n");
}
txPBUF_count++;
if (txPBUF_count >= PBUF_NUM) {txPBUF_count = 0;}
} else {}
} else {}
tcp_recved(tpcb, es -> p -> len);
pbuf_ref(es -> p);
do {
free = pbuf_free(es -> p);
} while(free == 0);
es -> p = NULL;
// OWN CODE ENDS HERE
//---------------------------------------------------------------
}
/**
* @brief This functions closes the tcp connection
* @param tcp_pcb: pointer on the tcp connection
* @param es: pointer on state structure
* @retval None
*/
static void tcp_server_connection_close(struct tcp_pcb *tpcb, struct
tcp_server_struct *es)
{
/* remove all callbacks */
tcp_arg(tpcb, NULL);
tcp_sent(tpcb, NULL);
tcp_recv(tpcb, NULL);
tcp_err(tpcb, NULL);
tcp_poll(tpcb, NULL, 0);
/* delete es structure */
if (es != NULL)
{
mem_free(es);
}
/* close tcp connection */
tcp_close(tpcb);
}
#endif /* LWIP_TCP */
_______________________________________________
lwip-users mailing list
lwip-users@nongnu.org
https://lists.nongnu.org/mailman/listinfo/lwip-users
