自学教程：C++ tcp_new函数代码示例

/*****************************************************************************************************************************函数名称:	 	fpt_new**函数功能:	 	**入口参数:**返回参数:***************************************************************************************************************************/void ftp_new(FTP_INFO *pftpInfo){	if(eRAW == pftpInfo->attri)	{		if(eCtr == pftpInfo->ctrOrMsg)		{			pftpInfo->ftpRAWControl = tcp_new();			LIBMCU_DEBUG(ETHERNTE_DEBUG,("/r/n ftpRAWControl %p",pftpInfo->ftpRAWControl));			if(NULL == pftpInfo->ftpRAWControl)			{				LIBMCU_DEBUG(ETHERNTE_DEBUG,("/r/n Control tcp_new Fail"));			}		}		else if(eMsg == pftpInfo->ctrOrMsg)		{			pftpInfo->ftpRAWDataMsg = tcp_new();			LIBMCU_DEBUG(ETHERNTE_DEBUG,("/r/n ftpRAWDataMsg %p",pftpInfo->ftpRAWDataMsg));			if(NULL == pftpInfo->ftpRAWDataMsg)			{				LIBMCU_DEBUG(ETHERNTE_DEBUG,("/r/n DataMsg tcp_new Fail"));			}		}	}	else if(eLWIP == pftpInfo->attri)	{		}}

rdpTransport* transport_new(rdpSettings* settings){	rdpTransport* transport;	transport = (rdpTransport*) xzalloc(sizeof(rdpTransport));	if (transport != NULL)	{		transport->tcp = tcp_new(settings);		transport->tcp_in = tcp_new(settings);		transport->settings = settings;		/* a small 0.1ms delay when transport is blocking. */		transport->usleep_interval = 100;		/* receive buffer for non-blocking read. */		transport->recv_buffer = stream_new(BUFFER_SIZE);		transport->recv_event = wait_obj_new();		/* buffers for blocking read/write */		transport->recv_stream = stream_new(BUFFER_SIZE);		transport->send_stream = stream_new(BUFFER_SIZE);		transport->blocking = true;		transport->layer = TRANSPORT_LAYER_TCP;	}	return transport;}

//------------------------------------------------------------------------------------------------------------------------------------------------------bool TCPSocket_Init(void(*_funcConnect)(void), void(*_funcReciever)(const char *_buffer, uint _length)){    struct tcp_pcb *pcb = tcp_new();    if (pcb != NULL)    {        err_t err = tcp_bind(pcb, IP_ADDR_ANY, (u16_t)DEFAULT_PORT);        if (err == ERR_OK)        {            pcb = tcp_listen(pcb);            SocketFuncReciever = _funcReciever;            SocketFuncConnect = _funcConnect;            tcp_accept(pcb, CallbackOnAccept);        }        else        {            // abort? output diagnostic?        }    }    else    {        // abort? output diagonstic?    }    pcb = tcp_new();    if (pcb != NULL)    {        err_t err = tcp_bind(pcb, IP_ADDR_ANY, (u16_t)POLICY_PORT);        if (err == ERR_OK)        {            pcb = tcp_listen(pcb);            SocketFuncReciever = _funcReciever;            SocketFuncConnect = _funcConnect;            tcp_accept(pcb, CallbackOnAcceptPolicyPort);        }        else        {        }    }    else    {    }    pcbClient = 0;    return true;}

/**  * @brief  This function is called when a datagram is received   * @param arg user supplied argument (udp_pcb.recv_arg)   * @param upcb the udp_pcb which received data   * @param p the packet buffer that was received   * @param addr the remote IP address from which the packet was received   * @param port the remote port from which the packet was received  * @retval None  */void udp_client_callback(void *arg, struct udp_pcb *upcb, struct pbuf *p, struct ip_addr *addr, u16_t port){    struct tcp_pcb *pcb;    __IO uint8_t iptab[4];    uint8_t iptxt[20];    /* Read the Server's IP address */    iptab[0] = (uint8_t)((uint32_t)(addr->addr) >> 24);    iptab[1] = (uint8_t)((uint32_t)(addr->addr) >> 16);    iptab[2] = (uint8_t)((uint32_t)(addr->addr) >> 8);    iptab[3] = (uint8_t)((uint32_t)(addr->addr));    sprintf((char*)iptxt, "is: %d.%d.%d.%d     ", iptab[3], iptab[2], iptab[1], iptab[0]);    LCD_DisplayStringLine(Line3, "The server's IP add.");    LCD_DisplayStringLine(Line4, iptxt);    /* Create a new TCP control block  */    pcb = tcp_new();    /* Assign to the new pcb a local IP address and a port number */    tcp_bind(pcb, IP_ADDR_ANY, TCP_PORT);    /* Connect to the server: send the SYN */    tcp_connect(pcb, addr, TCP_PORT, tcp_client_connected);//    tcp_accept(pcb, APP_accept);  ////   tcp_sent(pcb, App_sent);    /* Free the p buffer */    pbuf_free(p);}

intstart_txperf_application(){	struct tcp_pcb *pcb;	struct ip_addr ipaddr;	err_t err;	u16_t port;	int i;	/* create new TCP PCB structure */	pcb = tcp_new();	if (!pcb) {		xil_printf("txperf: Error creating PCB. Out of Memory/r/n");		return -1;	}	/* connect to iperf server */	IP4_ADDR(&ipaddr,  192, 168, 1, 3);		/* iperf server address */	port = 5001;					/* iperf default port */	err = tcp_connect(pcb, &ipaddr, port, txperf_connected_callback);        txperf_client_connected = 0;	if (err != ERR_OK) {		xil_printf("txperf: tcp_connect returned error: %d/r/n", err);		return err;	}	/* initialize data buffer being sent */	for (i = 0; i < SEND_BUFSIZE; i++)		send_buf[i] = (i % 10) + '0';	return 0;}

void AsyncServer::begin(){  if(_pcb)    return;  int8_t err;  tcp_pcb* pcb = tcp_new();  if (!pcb)    return;  ip_addr_t local_addr;  local_addr.addr = (uint32_t) _addr;  err = tcp_bind(pcb, &local_addr, _port);  if (err != ERR_OK) {    tcp_close(pcb);    return;  }  tcp_pcb* listen_pcb = tcp_listen(pcb);  if (!listen_pcb) {    tcp_close(pcb);    return;  }  _pcb = listen_pcb;  tcp_arg(_pcb, (void*) this);  tcp_accept(_pcb, _s_accept);}

voidecho_client_init (int *ipaddr, int port){	struct tcp_pcb *pcb;	err_t e;	IP4_ADDR (&destip,		  ipaddr[0],		  ipaddr[1],		  ipaddr[2],		  ipaddr[3]);	destport = port;	printd ("New Connection./n");	pcb = tcp_new ();	if (pcb) {		e = tcp_connect (pcb, &destip, destport,				 echo_client_connected);		if (e == ERR_OK) {			printf ("Connecting.../n");			echo_client_pcb = pcb;		} else {			printf ("Connect failed!/n");		}	} else {		printf ("New context failed./n");	}}

static struct tcp_pcb *connect(struct ip_addr *ip, int port){    //    debug_printf("connect()/n");    err_t err;    struct tcp_pcb *pcb;    pcb = tcp_new();    if (pcb == NULL) {        fprintf(stderr, "failed to create new pcb/n");        assert(pcb != NULL);        return NULL;    }    //    debug_printf("pcb created/n");    //    debug_printf("connecting to server/n");    wait_cond = true;    err = tcp_connect(pcb, ip, port, tcp_is_connected);    wait_for_condition();    // TODO: proper error handling    if (err != ERR_OK) {        fprintf(stderr, "error connecting %d/n", err);        return NULL;    }    return pcb;}

/** * The initialization function. */err_thttpd_init(void){	struct tcp_pcb *pcb;	err_t  err;	/* Create a new TCP PCB. */	pcb = tcp_new();	if (pcb == NULL) {		printf("F: Fail to create PCB/n/r");		return ERR_BUF;	}	/* Bind the PCB to TCP port 80. */	err = tcp_bind(pcb, NULL, 80);	if (err != ERR_OK) {		printf("E: tcp_bind %x/n/r", err);		return err;	}	/* Change TCP state to LISTEN. */	pcb = tcp_listen(pcb);	if (pcb == NULL) {		printf("E: tcp_listen/n/r");		return ERR_BUF;	}	/* Set up httpd_accet() function to be called	when a new connection arrives. */	tcp_accept(pcb, httpd_accept);	return ERR_OK;}

static int open_dataconnection(struct tcp_pcb *pcb, struct ftpd_msgstate *fsm){	if (fsm->passive)		return 0;	/* Allocate memory for the structure that holds the state of the	   connection. */	fsm->datafs = malloc(sizeof(struct ftpd_datastate));	if (fsm->datafs == NULL) {		send_msg(pcb, fsm, msg451);		return 1;	}	memset(fsm->datafs, 0, sizeof(struct ftpd_datastate));	fsm->datafs->msgfs = fsm;	fsm->datafs->msgpcb = pcb;	sfifo_init(&fsm->datafs->fifo, 2000);	fsm->datapcb = tcp_new();	/* Tell TCP that this is the structure we wish to be passed for our	   callbacks. */	tcp_arg(fsm->datapcb, fsm->datafs);	ip_addr_t dataip;	IP_SET_TYPE_VAL(dataip, IPADDR_TYPE_V4);	ip4_addr_copy(*ip_2_ip4(&dataip), fsm->dataip);	tcp_connect(fsm->datapcb, &dataip, fsm->dataport, ftpd_dataconnected);	return 0;}

rdpTransport* transport_new(rdpSettings* settings){	rdpTransport* transport;	transport = (rdpTransport*) malloc(sizeof(rdpTransport));	if (transport != NULL)	{		ZeroMemory(transport, sizeof(rdpTransport));		transport->TcpIn = tcp_new(settings);		transport->settings = settings;		/* a small 0.1ms delay when transport is blocking. */		transport->SleepInterval = 100;		transport->ReceivePool = StreamPool_New(TRUE, BUFFER_SIZE);		/* receive buffer for non-blocking read. */		transport->ReceiveBuffer = StreamPool_Take(transport->ReceivePool, 0);		transport->ReceiveEvent = CreateEvent(NULL, TRUE, FALSE, NULL);		transport->connectedEvent = CreateEvent(NULL, TRUE, FALSE, NULL);		transport->blocking = TRUE;		transport->ReadMutex = CreateMutex(NULL, FALSE, NULL);		transport->WriteMutex = CreateMutex(NULL, FALSE, NULL);		transport->layer = TRANSPORT_LAYER_TCP;	}	return transport;}

int tcp_server_bm_init(uint16_t bind_port){    err_t r;    //don't use htons() (don't know why...)    struct tcp_pcb *pcb = tcp_new();    if (pcb == NULL) {        return ERR_MEM;    }    r = tcp_bind(pcb, IP_ADDR_ANY, bind_port);    if(r != ERR_OK) {        return(r);    }    struct tcp_pcb *pcb2 = tcp_listen(pcb);    assert(pcb2 != NULL);    tcp_accept(pcb2, tcp_server_bm_accept);    printf("TCP tcp_server_bm_init(): bound./n");    printf("TCP installed receive callback./n");    printf("TCP benchmark server started/n");    return (0);}

// initialize tcp connection for the clientint tcp_client_bm_init(char *ip_addr_str,  uint16_t server_port){    err_t r;    // Preparing IP address for use    assert(ip_addr_str != NULL);    struct in_addr addr;    if (inet_aton(ip_addr_str, &addr) == 0) {        printf("Invalid IP addr: %s/n", ip_addr_str);        USER_PANIC("Invalid IP address %s", ip_addr_str);        return -1;    }    struct ip_addr ip;    ip.addr = addr.s_addr;    // Prepare tcp_pcb    client_pcb = tcp_new();    if (client_pcb == NULL) {        USER_PANIC("tcp_new failed");        return -1;    }    //don't use htons() on port no. (don't know why...)    r = tcp_connect(client_pcb, &ip, server_port, tcp_is_connected_client);    if(r != ERR_OK) {        USER_PANIC("tcp_connect failed");        return(r);    }    // Connection established!    printf("TCP benchmark client started/n");    return (0);} // end function: tcp_client_bm_init

// ------------------------------------------------// Function:        smtp_from()// ------------------------------------------------// Input:           Sender email address// Output:          TRUE if succesful// ------------------------------------------------// Description:     Adds one MAIL FROM clause// ------------------------------------------------BOOL smtp_from(char *s){    PPBUF buf;    BOOL res;    if(smtp_state != SMTP_FROM) return FALSE;    // ----------------------    // send MAIL FROM command    // ----------------------    buf = tcp_new(SOCKET_SMTP);    if(buf == NULL) return FALSE;    write_string(buf, "MAIL FROM:<");    write_string(buf, s);    write_string(buf, ">/r/n");    res = tcp_send(SOCKET_SMTP, buf);    release_buffer(buf);    if(!res) return FALSE;    if(!smtp_ok()) return FALSE;    smtp_state = SMTP_RCPT;    return TRUE;}	

rdpTransport* transport_new(rdpSettings* settings){    rdpTransport* transport;    transport = (rdpTransport*) xzalloc(sizeof(rdpTransport));    if (transport != NULL)    {        transport->tcp = tcp_new(settings);        transport->settings = settings;        /* a small 0.1ms delay when transport is blocking. */        transport->ts.tv_sec = 0;        transport->ts.tv_nsec = 100000;        /* receive buffer for non-blocking read. */        transport->recv_buffer = stream_new(BUFFER_SIZE);        /* buffers for blocking read/write */        transport->recv_stream = stream_new(BUFFER_SIZE);        transport->send_stream = stream_new(BUFFER_SIZE);    }    return transport;}

/**  * @brief  Initialize the server application.  * @param  None  * @retval None  */void server_init(void){  struct tcp_pcb *tpcb;    	struct udp_pcb *upcb;  	  	/* Create a new TCP control block  */	tpcb = tcp_new();		/* Assign to the new pcb a local IP address and a port number */	/* Using IP_ADDR_ANY allow the pcb to be used by any local interface */	tcp_bind(tpcb, IP_ADDR_ANY, TCP_SERVER_PORT);		/* Set the connection to the LISTEN state */	tpcb = tcp_listen(tpcb);	/* Specify the function to be called when a connection is established */		tcp_accept(tpcb, tcp_server_accept);		  /* Create a new UDP control block  */  upcb = udp_new();    /* Bind the upcb to the UDP_PORT port */  /* Using IP_ADDR_ANY allow the upcb to be used by any local interface */  udp_bind(upcb, IP_ADDR_ANY, UDP_SERVER_PORT);    /* Set a receive callback for the upcb */  udp_recv(upcb, udp_server_callback, NULL);  }

voidsocks_tcp_connect(struct socks_data *data){	struct tcp_pcb *pcb;	err_t ret;	bufferevent_disable(data->bev, EV_READ);	LWIP_DEBUGF(SOCKS_DEBUG, ("%s: %s:%d/n", __func__,				ipaddr_ntoa(&data->ipaddr), data->port));	pcb = tcp_new();	if (!pcb)		data->connect_failed(data);	pcb->flags |= TF_NODELAY;	if (data->keep_alive) {		pcb->so_options |= SOF_KEEPALIVE;		pcb->keep_intvl = data->keep_alive;		pcb->keep_idle = data->keep_alive;	}	ret = tcp_connect(pcb, &data->ipaddr, data->port, socks_tcp_connect_ok);	if (ret < 0) {		tcp_abort(pcb);		data->connect_failed(data);	} else {		data->pcb = pcb;		tcp_arg(pcb, data);		tcp_err(pcb, socks_tcp_connect_err);	}}

void WiFiServer::begin(){    err_t err;    tcp_pcb* pcb = tcp_new();    if (!pcb)        return;    err = tcp_bind(pcb, INADDR_ANY, _port);    if (err != ERR_OK)    {        tcp_close(pcb);        return;    }    tcp_pcb* listen_pcb = tcp_listen(pcb);    if (!listen_pcb)    {        tcp_close(pcb);        return;    }    _pcb = listen_pcb;    tcp_accept(listen_pcb, &WiFiServer::_s_accept);    tcp_arg(listen_pcb, (void*) this);}

intsocks_tcp_bind(struct socks_data *data){	struct tcp_pcb *pcb;	err_t ret;	pcb = tcp_new();	if (!pcb)		return -1;	pcb->flags |= TF_NODELAY;	ip_set_option(pcb, SOF_REUSEADDR);	ret = tcp_bind(pcb, IP_ADDR_ANY, data->port);	if (ret < 0) {		tcp_abort(pcb);		return -1;	}	data->pcb = tcp_listen(pcb);	if (!data->pcb) {		tcp_abort(pcb);		return -1;	}	tcp_arg(data->pcb, data);	tcp_accept(data->pcb, socks_tcp_accept);	return 0;}

void lwHTTPDispatcher_Init(		struct lwHTTPDispatcher* dispatcher,		int port,		struct lwhttpSite* site){	err_t err;	dispatcher->caps.clientValidator = 0;	memset(		&dispatcher->caps.wsProtocolsList,		0,		sizeof(dispatcher->caps.wsProtocolsList)	);	memset(		&dispatcher->conns,		0,		sizeof(dispatcher->conns	)	);	dispatcher->pcb = tcp_new();	dispatcher->port = port;	dispatcher->nextConnectionToTry = 0;	dispatcher->site = site;	/* bind to specified @port */	err = tcp_bind(dispatcher->pcb, IP_ADDR_ANY, port);	if (err != ERR_OK) {		LWHTTPDebug("Unable to bind to port %d: err = %d/n/r", port, err);	}	tcp_arg(dispatcher->pcb, dispatcher);	dispatcher->pcb = tcp_listen(dispatcher->pcb);	tcp_accept(dispatcher->pcb, lwHTTPDispatcher_AcceptCallback);}

int lwip_bind(int s, struct sockaddr *name, socklen_t namelen) {	sockfd_t	* fd;	struct ip_addr	ip;	int		port, rv = 0;	s = sock_for_fd(s);	if (s < 0) {		errno = EBADF;		return -1;	}	fd = fds + s;	// Make sure it's an internet address we understand.	if (namelen != sizeof(struct sockaddr_in)) {		errno = ENAMETOOLONG;		return -1;	}	// Get access	mutex_lock(fd->mutex);	// Copy it over	memcpy(&fd->name, name, namelen);	// Convert this to an lwIP-happy format	ip.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;	port = ((struct sockaddr_in *)name)->sin_port;	// Are we TCP or UDP?	switch (fd->type) {	case SOCK_STREAM:		fd->tcppcb = tcp_new();		tcp_arg(fd->tcppcb, (void *)s);		tcp_recv(fd->tcppcb, recv_tcp);		tcp_sent(fd->tcppcb, sent_tcp);		tcp_poll(fd->tcppcb, poll_tcp, 4);	// 4 == 4 TCP timer intervals		tcp_err(fd->tcppcb, err_tcp);		if (tcp_bind(fd->tcppcb, &ip, ntohs(port)) != ERR_OK) {			if (tcp_close(fd->tcppcb) != ERR_OK)				tcp_abort(fd->tcppcb);			fd->tcppcb = NULL;			errno = EINVAL;			rv = -1; goto out;		}		break;	case SOCK_DGRAM:		fd->udppcb = udp_new();		udp_recv(fd->udppcb, recv_udp, (void *)s);		udp_bind(fd->udppcb, &ip, ntohs(port));		break;	default:		assert( 0 );		errno = EINVAL;		rv = -1; goto out;	}out:	mutex_unlock(fd->mutex);	return rv;}

boolean transport_connect(rdpTransport* transport, const char* hostname, uint16 port){	boolean status = false;	rdpSettings* settings = transport->settings;	if (transport->settings->ts_gateway)	{		transport->layer = TRANSPORT_LAYER_TSG;		transport->tcp_out = tcp_new(settings);		status = tcp_connect(transport->tcp_in, settings->tsg_hostname, 443);		if (status)			status = tcp_connect(transport->tcp_out, settings->tsg_hostname, 443);		if (status)			status = transport_tsg_connect(transport, hostname, port);	}	else	{		status = tcp_connect(transport->tcp, hostname, port);	}	return status;}

BOOL transport_connect(rdpTransport* transport, const char* hostname, UINT16 port){	BOOL status = FALSE;	rdpSettings* settings = transport->settings;	if (transport->settings->GatewayUsageMethod)	{		transport->layer = TRANSPORT_LAYER_TSG;		transport->TcpOut = tcp_new(settings);		status = tcp_connect(transport->TcpIn, settings->GatewayHostname, 443);		if (status)			status = tcp_connect(transport->TcpOut, settings->GatewayHostname, 443);		if (status)			status = transport_tsg_connect(transport, hostname, port);	}	else	{		status = tcp_connect(transport->TcpIn, hostname, port);		transport->SplitInputOutput = FALSE;		transport->TcpOut = transport->TcpIn;	}	return status;}

int start_connection(void){	struct tcp_pcb *_pcb;	err_t err;	/* create new TCP PCB structure */	_pcb = tcp_new();	if (!_pcb) {		xil_printf("Error creating PCB. Out of Memory/n/r");		return -1;	}	/* bind to specified @port */	err = tcp_bind(_pcb, IP_ADDR_ANY, (unsigned short)PORT);	if (err != ERR_OK) {		xil_printf("Unable to bind to port %d: err = %d/n/r", PORT, err);		return -2;	}	/* we do not need any arguments to callback functions */	tcp_arg(_pcb, NULL);	/* listen for connections */	_pcb = tcp_listen(_pcb);	if (!_pcb) {		xil_printf("Out of memory while tcp_listen/n/r");		return -3;	}	/* specify callback to use for incoming connections */	tcp_accept(_pcb, accept_callback);	return 0;}

/**  * @brief  Initializes the tcp echo server  * @param  None  * @retval None  */void tcp_echoserver_init(void){  /* create new tcp pcb */  tcp_echoserver_pcb = tcp_new();  if (tcp_echoserver_pcb != NULL)  {    err_t err;        /* bind echo_pcb to port 7 (ECHO protocol) */    err = tcp_bind(tcp_echoserver_pcb, IP_ADDR_ANY, 7);        if (err == ERR_OK)    {      /* start tcp listening for echo_pcb */      tcp_echoserver_pcb = tcp_listen(tcp_echoserver_pcb);            /* initialize LwIP tcp_accept callback function */      tcp_accept(tcp_echoserver_pcb, tcp_echoserver_accept);    }    else     {      /* deallocate the pcb */      memp_free(MEMP_TCP_PCB, tcp_echoserver_pcb);      printf("Can not bind pcb/n");    }  }  else  {    printf("Can not create new pcb/n");  }}

bool TcpConnection::connect(String server, int port){	if (tcp == NULL)		initialize(tcp_new());	ip_addr_t addr;	debugf("connect to: %s", server.c_str());	canSend = false; // Wait for connection	DnsLookup *look = new DnsLookup { this, port };	err_t dnslook = dns_gethostbyname(server.c_str(), &addr, staticDnsResponse, look);	if (dnslook != ERR_OK)	{		if (dnslook == ERR_INPROGRESS)			return true;		else		{			delete look;			return false;		}	}	delete look;	return internalTcpConnect(addr, port);}

int start_application(){    struct ip_addr ipaddr;    err_t err;    u16_t port = 1955;    IP4_ADDR(&ipaddr,  192, 168,   3, 22);    /* create new TCP PCB structure */    pcb = tcp_new();    if (!pcb) {        xil_printf("Error creating PCB. Out of Memory/n/r");        return -1;    }    /* we do not need any arguments to callback functions */    tcp_arg(pcb, NULL);    /* bind to specified @port */    err = tcp_connect(pcb, &ipaddr, port, tcp_connected);    if (err != ERR_OK) {        xil_printf("Unable to bind to connect to server port %d: err = %d/n/r", port, err);        return -2;    }    xil_printf("TCP client connected @ port %d/n/r", port);    return 0;}

void telnet_init(void){	telnet_pcb = tcp_new();	tcp_bind(telnet_pcb, IP_ADDR_ANY, 23);	telnet_pcb = tcp_listen(telnet_pcb);	tcp_accept(telnet_pcb, telnet_accept);}

END_TEST/** Call tcp_new() and tcp_abort() and test memp stats */START_TEST(test_tcp_listen_passive_open){  struct tcp_pcb *pcb, *pcbl;  struct tcp_pcb_listen *lpcb;  struct netif netif;  struct test_tcp_txcounters txcounters;  struct test_tcp_counters counters;  struct pbuf *p;  ip_addr_t src_addr;  err_t err;  LWIP_UNUSED_ARG(_i);  fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);  test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);  /* initialize counter struct */  memset(&counters, 0, sizeof(counters));  pcb = tcp_new();  EXPECT_RET(pcb != NULL);  err = tcp_bind(pcb, &netif.ip_addr, 1234);  EXPECT(err == ERR_OK);  pcbl = tcp_listen(pcb);  EXPECT_RET(pcbl != NULL);  EXPECT_RET(pcbl != pcb);  lpcb = (struct tcp_pcb_listen *)pcbl;  ip_addr_set_ip4_u32_val(src_addr, lwip_htonl(lwip_ntohl(ip_addr_get_ip4_u32(&lpcb->local_ip)) + 1));  /* check correct syn packet */  p = tcp_create_segment(&src_addr, &lpcb->local_ip, 12345,    lpcb->local_port, NULL, 0, 12345, 54321, TCP_SYN);  EXPECT(p != NULL);  if (p != NULL) {    /* pass the segment to tcp_input */    test_tcp_input(p, &netif);    /* check if counters are as expected */    EXPECT(txcounters.num_tx_calls == 1);  }  /* check syn packet with short length */  p = tcp_create_segment(&src_addr, &lpcb->local_ip, 12345,    lpcb->local_port, NULL, 0, 12345, 54321, TCP_SYN);  EXPECT(p != NULL);  EXPECT(p->next == NULL);  if ((p != NULL) && (p->next == NULL)) {    p->len -= 2;    p->tot_len -= 2;    /* pass the segment to tcp_input */    test_tcp_input(p, &netif);    /* check if counters are as expected */    EXPECT(txcounters.num_tx_calls == 1);  }  tcp_close(pcbl);}