net: Initial TCP support (d0ba82a5) · Commits · Wenxi XU / zephyr

net/ip/contiki/ip/psock.c

0 → 100644

+319 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (c) 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. Neither the name of the Institute nor the names of its contributors
		* may be used to endorse or promote products derived from this software
		* without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``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 INSTITUTE OR CONTRIBUTORS 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 the Contiki operating system.
		*
		* Author: Adam Dunkels <adam@sics.se>
		*
		*/

		#include <string.h>

		#include "net/ip/psock.h"

		#define STATE_NONE 0
		#define STATE_ACKED 1
		#define STATE_READ 2
		#define STATE_BLOCKED_NEWDATA 3
		#define STATE_BLOCKED_CLOSE 4
		#define STATE_BLOCKED_SEND 5
		#define STATE_DATA_SENT 6

		/*
		* Return value of the buffering functions that indicates that a
		* buffer was not filled by incoming data.
		*
		*/
		#define BUF_NOT_FULL 0
		#define BUF_NOT_FOUND 0

		/*
		* Return value of the buffering functions that indicates that a
		* buffer was completely filled by incoming data.
		*
		*/
		#define BUF_FULL 1

		/*
		* Return value of the buffering functions that indicates that an
		* end-marker byte was found.
		*
		*/
		#define BUF_FOUND 2

		/---------------------------------------------------------------------------/
		static void
		buf_setup(struct psock_buf *buf,
		uint8_t *bufptr, uint16_t bufsize)
		{
		buf->ptr = bufptr;
		buf->left = bufsize;
		}
		/---------------------------------------------------------------------------/
		static uint8_t
		buf_bufdata(struct psock_buf *buf, uint16_t len,
		uint8_t *dataptr, uint16_t datalen)
		{
		if(*datalen < buf->left) {
		memcpy(buf->ptr, dataptr, datalen);
		buf->ptr += *datalen;
		buf->left -= *datalen;
		dataptr += datalen;
		*datalen = 0;
		return BUF_NOT_FULL;
		} else if(*datalen == buf->left) {
		memcpy(buf->ptr, dataptr, datalen);
		buf->ptr += *datalen;
		buf->left = 0;
		dataptr += datalen;
		*datalen = 0;
		return BUF_FULL;
		} else {
		memcpy(buf->ptr, *dataptr, buf->left);
		buf->ptr += buf->left;
		*datalen -= buf->left;
		*dataptr += buf->left;
		buf->left = 0;
		return BUF_FULL;
		}
		}
		/---------------------------------------------------------------------------/
		static uint8_t
		buf_bufto(CC_REGISTER_ARG struct psock_buf *buf, uint8_t endmarker,
		CC_REGISTER_ARG uint8_t *dataptr, CC_REGISTER_ARG uint16_t datalen)
		{
		uint8_t c;
		while(buf->left > 0 && *datalen > 0) {
		c = buf->ptr = *dataptr;
		++*dataptr;
		++buf->ptr;
		--*datalen;
		--buf->left;

		if(c == endmarker) {
		return BUF_FOUND;
		}
		}

		if(*datalen == 0) {
		return BUF_NOT_FOUND;
		}

		return BUF_FULL;
		}
		/---------------------------------------------------------------------------/
		static char
		data_is_sent_and_acked(CC_REGISTER_ARG struct psock *s)
		{
		/* If data has previously been sent, and the data has been acked, we
		increase the send pointer and call send_data() to send more
		data. */
		if(s->state != STATE_DATA_SENT \|\| uip_rexmit()) {
		if(s->sendlen > uip_mss()) {
		uip_send(s->sendptr, uip_mss());
		} else {
		uip_send(s->sendptr, s->sendlen);
		}
		s->state = STATE_DATA_SENT;
		return 0;
		} else if(s->state == STATE_DATA_SENT && uip_acked()) {
		if(s->sendlen > uip_mss()) {
		s->sendlen -= uip_mss();
		s->sendptr += uip_mss();
		} else {
		s->sendptr += s->sendlen;
		s->sendlen = 0;
		}
		s->state = STATE_ACKED;
		return 1;
		}
		return 0;
		}
		/---------------------------------------------------------------------------/
		PT_THREAD(psock_send(CC_REGISTER_ARG struct psock s, const uint8_t buf,
		unsigned int len))
		{
		PT_BEGIN(&s->psockpt);

		/* If there is no data to send, we exit immediately. */
		if(len == 0) {
		PT_EXIT(&s->psockpt);
		}

		/* Save the length of and a pointer to the data that is to be
		sent. */
		s->sendptr = buf;
		s->sendlen = len;

		s->state = STATE_NONE;

		/* We loop here until all data is sent. The s->sendlen variable is
		updated by the data_sent() function. */
		while(s->sendlen > 0) {

		/*
		* The protothread will wait here until all data has been
		* acknowledged and sent (data_is_acked_and_send() returns 1).
		*/
		PT_WAIT_UNTIL(&s->psockpt, data_is_sent_and_acked(s));
		}

		s->state = STATE_NONE;

		PT_END(&s->psockpt);
		}
		/---------------------------------------------------------------------------/
		PT_THREAD(psock_generator_send(CC_REGISTER_ARG struct psock *s,
		unsigned short (generate)(void ), void *arg))
		{
		PT_BEGIN(&s->psockpt);

		/* Ensure that there is a generator function to call. */
		if(generate == NULL) {
		PT_EXIT(&s->psockpt);
		}

		s->state = STATE_NONE;
		do {
		/* Call the generator function to generate the data in the
		uip_appdata buffer. */
		s->sendlen = generate(arg);
		s->sendptr = uip_appdata;

		if(s->sendlen > uip_mss()) {
		uip_send(s->sendptr, uip_mss());
		} else {
		uip_send(s->sendptr, s->sendlen);
		}
		s->state = STATE_DATA_SENT;

		/* Wait until all data is sent and acknowledged. */
		// if (!s->sendlen) break; //useful debugging aid
		PT_YIELD_UNTIL(&s->psockpt, uip_acked() \|\| uip_rexmit());
		} while(!uip_acked());

		s->state = STATE_NONE;

		PT_END(&s->psockpt);
		}
		/---------------------------------------------------------------------------/
		uint16_t
		psock_datalen(struct psock *psock)
		{
		return psock->bufsize - psock->buf.left;
		}
		/---------------------------------------------------------------------------/
		char
		psock_newdata(struct psock *s)
		{
		if(s->readlen > 0) {
		/* There is data in the uip_appdata buffer that has not yet been
		read with the PSOCK_READ functions. */
		return 1;
		} else if(s->state == STATE_READ) {
		/* All data in uip_appdata buffer already consumed. */
		s->state = STATE_BLOCKED_NEWDATA;
		return 0;
		} else if(uip_newdata()) {
		/* There is new data that has not been consumed. */
		return 1;
		} else {
		/* There is no new data. */
		return 0;
		}
		}
		/---------------------------------------------------------------------------/
		PT_THREAD(psock_readto(CC_REGISTER_ARG struct psock *psock, unsigned char c))
		{
		PT_BEGIN(&psock->psockpt);

		buf_setup(&psock->buf, psock->bufptr, psock->bufsize);

		/* XXX: Should add buf_checkmarker() before do{} loop, if
		incoming data has been handled while waiting for a write. */

		do {
		if(psock->readlen == 0) {
		PT_WAIT_UNTIL(&psock->psockpt, psock_newdata(psock));
		psock->state = STATE_READ;
		psock->readptr = (uint8_t *)uip_appdata;
		psock->readlen = uip_datalen();
		}
		} while(buf_bufto(&psock->buf, c,
		&psock->readptr,
		&psock->readlen) == BUF_NOT_FOUND);

		if(psock_datalen(psock) == 0) {
		psock->state = STATE_NONE;
		PT_RESTART(&psock->psockpt);
		}
		PT_END(&psock->psockpt);
		}
		/---------------------------------------------------------------------------/
		PT_THREAD(psock_readbuf_len(CC_REGISTER_ARG struct psock *psock, uint16_t len))
		{
		PT_BEGIN(&psock->psockpt);

		buf_setup(&psock->buf, psock->bufptr, psock->bufsize);

		/* XXX: Should add buf_checkmarker() before do{} loop, if
		incoming data has been handled while waiting for a write. */

		/* read len bytes or to end of data */
		do {
		if(psock->readlen == 0) {
		PT_WAIT_UNTIL(&psock->psockpt, psock_newdata(psock));
		psock->state = STATE_READ;
		psock->readptr = (uint8_t *)uip_appdata;
		psock->readlen = uip_datalen();
		}
		} while(buf_bufdata(&psock->buf, psock->bufsize,
		&psock->readptr, &psock->readlen) == BUF_NOT_FULL &&
		psock_datalen(psock) < len);

		if(psock_datalen(psock) == 0) {
		psock->state = STATE_NONE;
		PT_RESTART(&psock->psockpt);
		}
		PT_END(&psock->psockpt);
		}

		/---------------------------------------------------------------------------/
		void
		psock_init(CC_REGISTER_ARG struct psock *psock,
		uint8_t *buffer, unsigned int buffersize)
		{
		psock->state = STATE_NONE;
		psock->readlen = 0;
		psock->bufptr = buffer;
		psock->bufsize = buffersize;
		buf_setup(&psock->buf, buffer, buffersize);
		PT_INIT(&psock->pt);
		PT_INIT(&psock->psockpt);
		}
		/---------------------------------------------------------------------------/

net/ip/contiki/ip/psock.h

0 → 100644

+404 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (c) 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. Neither the name of the Institute nor the names of its contributors
		* may be used to endorse or promote products derived from this software
		* without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``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 INSTITUTE OR CONTRIBUTORS 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 the Contiki operating system.
		*
		* Author: Adam Dunkels <adam@sics.se>
		*
		*/

		/**
		* \addtogroup uip
		* @{
		*/

		/**
		* \defgroup psock Protosockets library
		* @{
		*
		* The protosocket library provides an interface to the uIP stack that is
		* similar to the traditional BSD socket interface. Unlike programs
		* written for the ordinary uIP event-driven interface, programs
		* written with the protosocket library are executed in a sequential
		* fashion and does not have to be implemented as explicit state
		* machines.
		*
		* Protosockets only work with TCP connections.
		*
		* The protosocket library uses \ref pt protothreads to provide
		* sequential control flow. This makes the protosockets lightweight in
		* terms of memory, but also means that protosockets inherits the
		* functional limitations of protothreads. Each protosocket lives only
		* within a single function block. Automatic variables (stack
		* variables) are not necessarily retained across a protosocket
		* library function call.
		*
		* \note Because the protosocket library uses protothreads, local variables
		* will not always be saved across a call to a protosocket library
		* function. It is therefore advised that local variables are used
		* with extreme care.
		*
		* The protosocket library provides functions for sending data without
		* having to deal with retransmissions and acknowledgements, as well
		* as functions for reading data without having to deal with data
		* being split across more than one TCP segment.
		*
		* Because each protosocket runs as a protothread, the protosocket has to be
		* started with a call to PSOCK_BEGIN() at the start of the function
		* in which the protosocket is used. Similarly, the protosocket protothread can
		* be terminated by a call to PSOCK_EXIT().
		*
		*/

		/**
		* \file
		* Protosocket library header file
		* \author
		* Adam Dunkels <adam@sics.se>
		*
		*/

		#ifndef PSOCK_H_
		#define PSOCK_H_

		#include "contiki.h"
		#include "contiki-lib.h"
		#include "contiki-net.h"

		/*
		* The structure that holds the state of a buffer.
		*
		* This structure holds the state of a uIP buffer. The structure has
		* no user-visible elements, but is used through the functions
		* provided by the library.
		*
		*/
		struct psock_buf {
		uint8_t *ptr;
		unsigned short left;
		};

		/**
		* The representation of a protosocket.
		*
		* The protosocket structrure is an opaque structure with no user-visible
		* elements.
		*/
		struct psock {
		struct pt pt, psockpt; /* Protothreads - one that's using the psock
		functions, and one that runs inside the
		psock functions. */
		const uint8_t sendptr; / Pointer to the next data to be sent. */
		uint8_t readptr; / Pointer to the next data to be read. */

		uint8_t bufptr; / Pointer to the buffer used for buffering
		incoming data. */

		uint16_t sendlen; /* The number of bytes left to be sent. */
		uint16_t readlen; /* The number of bytes left to be read. */

		struct psock_buf buf; /* The structure holding the state of the
		input buffer. */
		unsigned int bufsize; /* The size of the input buffer. */

		unsigned char state; /* The state of the protosocket. */
		};

		void psock_init(struct psock psock, uint8_t buffer, unsigned int buffersize);
		/**
		* Initialize a protosocket.
		*
		* This macro initializes a protosocket and must be called before the
		* protosocket is used. The initialization also specifies the input buffer
		* for the protosocket.
		*
		* \param psock (struct psock *) A pointer to the protosocket to be
		* initialized
		*
		* \param buffer (uint8_t *) A pointer to the input buffer for the
		* protosocket.
		*
		* \param buffersize (unsigned int) The size of the input buffer.
		*
		* \hideinitializer
		*/
		#define PSOCK_INIT(psock, buffer, buffersize) \
		psock_init(psock, buffer, buffersize)

		/**
		* Start the protosocket protothread in a function.
		*
		* This macro starts the protothread associated with the protosocket and
		* must come before other protosocket calls in the function it is used.
		*
		* \param psock (struct psock *) A pointer to the protosocket to be
		* started.
		*
		* \hideinitializer
		*/
		#define PSOCK_BEGIN(psock) PT_BEGIN(&((psock)->pt))

		PT_THREAD(psock_send(struct psock psock, const uint8_t buf, unsigned int len));
		/**
		* Send data.
		*
		* This macro sends data over a protosocket. The protosocket protothread blocks
		* until all data has been sent and is known to have been received by
		* the remote end of the TCP connection.
		*
		* \param psock (struct psock *) A pointer to the protosocket over which
		* data is to be sent.
		*
		* \param data (uint8_t *) A pointer to the data that is to be sent.
		*
		* \param datalen (unsigned int) The length of the data that is to be
		* sent.
		*
		* \hideinitializer
		*/
		#define PSOCK_SEND(psock, data, datalen) \
		PT_WAIT_THREAD(&((psock)->pt), psock_send(psock, data, datalen))

		/**
		* \brief Send a null-terminated string.
		* \param psock Pointer to the protosocket.
		* \param str The string to be sent.
		*
		* This function sends a null-terminated string over the
		* protosocket.
		*
		* \hideinitializer
		*/
		#define PSOCK_SEND_STR(psock, str) \
		PT_WAIT_THREAD(&((psock)->pt), psock_send(psock, (uint8_t *)str, strlen(str)))

		PT_THREAD(psock_generator_send(struct psock *psock,
		unsigned short (f)(void ), void *arg));

		/**
		* \brief Generate data with a function and send it
		* \param psock Pointer to the protosocket.
		* \param generator Pointer to the generator function
		* \param arg Argument to the generator function
		*
		* This function generates data and sends it over the
		* protosocket. This can be used to dynamically generate
		* data for a transmission, instead of generating the data
		* in a buffer beforehand. This function reduces the need for
		* buffer memory. The generator function is implemented by
		* the application, and a pointer to the function is given
		* as an argument with the call to PSOCK_GENERATOR_SEND().
		*
		* The generator function should place the generated data
		* directly in the uip_appdata buffer, and return the
		* length of the generated data. The generator function is
		* called by the protosocket layer when the data first is
		* sent, and once for every retransmission that is needed.
		*
		* \hideinitializer
		*/
		#define PSOCK_GENERATOR_SEND(psock, generator, arg) \
		PT_WAIT_THREAD(&((psock)->pt), \
		psock_generator_send(psock, generator, arg))


		/**
		* Close a protosocket.
		*
		* This macro closes a protosocket and can only be called from within the
		* protothread in which the protosocket lives.
		*
		* \param psock (struct psock *) A pointer to the protosocket that is to
		* be closed.
		*
		* \hideinitializer
		*/
		#define PSOCK_CLOSE(psock) uip_close()

		PT_THREAD(psock_readbuf_len(struct psock *psock, uint16_t len));
		/**
		* Read data until the buffer is full.
		*
		* This macro will block waiting for data and read the data into the
		* input buffer specified with the call to PSOCK_INIT(). Data is read
		* until the buffer is full..
		*
		* \param psock (struct psock *) A pointer to the protosocket from which
		* data should be read.
		*
		* \hideinitializer
		*/
		#define PSOCK_READBUF(psock) \
		PT_WAIT_THREAD(&((psock)->pt), psock_readbuf_len(psock, 1))


		/**
		* Read data until at least len bytes have been read.
		*
		* This macro will block waiting for data and read the data into the
		* input buffer specified with the call to PSOCK_INIT(). Data is read
		* until the buffer is full or len bytes have been read.
		*
		* \param psock (struct psock *) A pointer to the protosocket from which
		* data should be read.
		* \param len (uint16_t) The minimum number of bytes to read.
		*
		* \hideinitializer
		*/
		#define PSOCK_READBUF_LEN(psock, len) \
		PT_WAIT_THREAD(&((psock)->pt), psock_readbuf_len(psock, len))

		PT_THREAD(psock_readto(struct psock *psock, unsigned char c));
		/**
		* Read data up to a specified character.
		*
		* This macro will block waiting for data and read the data into the
		* input buffer specified with the call to PSOCK_INIT(). Data is only
		* read until the specified character appears in the data stream.
		*
		* \param psock (struct psock *) A pointer to the protosocket from which
		* data should be read.
		*
		* \param c (char) The character at which to stop reading.
		*
		* \hideinitializer
		*/
		#define PSOCK_READTO(psock, c) \
		PT_WAIT_THREAD(&((psock)->pt), psock_readto(psock, c))

		/**
		* The length of the data that was previously read.
		*
		* This macro returns the length of the data that was previously read
		* using PSOCK_READTO() or PSOCK_READ().
		*
		* \param psock (struct psock *) A pointer to the protosocket holding the data.
		*
		* \hideinitializer
		*/
		#define PSOCK_DATALEN(psock) psock_datalen(psock)

		uint16_t psock_datalen(struct psock *psock);

		/**
		* Exit the protosocket's protothread.
		*
		* This macro terminates the protothread of the protosocket and should
		* almost always be used in conjunction with PSOCK_CLOSE().
		*
		* \sa PSOCK_CLOSE_EXIT()
		*
		* \param psock (struct psock *) A pointer to the protosocket.
		*
		* \hideinitializer
		*/
		#define PSOCK_EXIT(psock) PT_EXIT(&((psock)->pt))

		/**
		* Close a protosocket and exit the protosocket's protothread.
		*
		* This macro closes a protosocket and exits the protosocket's protothread.
		*
		* \param psock (struct psock *) A pointer to the protosocket.
		*
		* \hideinitializer
		*/
		#define PSOCK_CLOSE_EXIT(psock) \
		do { \
		PSOCK_CLOSE(psock); \
		PSOCK_EXIT(psock); \
		} while(0)

		/**
		* Declare the end of a protosocket's protothread.
		*
		* This macro is used for declaring that the protosocket's protothread
		* ends. It must always be used together with a matching PSOCK_BEGIN()
		* macro.
		*
		* \param psock (struct psock *) A pointer to the protosocket.
		*
		* \hideinitializer
		*/
		#define PSOCK_END(psock) PT_END(&((psock)->pt))

		char psock_newdata(struct psock *s);

		/**
		* Check if new data has arrived on a protosocket.
		*
		* This macro is used in conjunction with the PSOCK_WAIT_UNTIL()
		* macro to check if data has arrived on a protosocket.
		*
		* \param psock (struct psock *) A pointer to the protosocket.
		*
		* \hideinitializer
		*/
		#define PSOCK_NEWDATA(psock) psock_newdata(psock)

		/**
		* Wait until a condition is true.
		*
		* This macro blocks the protothread until the specified condition is
		* true. The macro PSOCK_NEWDATA() can be used to check if new data
		* arrives when the protosocket is waiting.
		*
		* Typically, this macro is used as follows:
		*
		\code
		PT_THREAD(thread(struct psock s, struct timer t))
		{
		PSOCK_BEGIN(s);

		PSOCK_WAIT_UNTIL(s, PSOCK_NEWDATA(s) \|\| timer_expired(t));

		if(PSOCK_NEWDATA(s)) {
		PSOCK_READTO(s, '\n');
		} else {
		handle_timed_out(s);
		}

		PSOCK_END(s);
		}
		\endcode
		*
		* \param psock (struct psock *) A pointer to the protosocket.
		* \param condition The condition to wait for.
		*
		* \hideinitializer
		*/
		#define PSOCK_WAIT_UNTIL(psock, condition) \
		PT_WAIT_UNTIL(&((psock)->pt), (condition));

		#define PSOCK_WAIT_THREAD(psock, condition) \
		PT_WAIT_THREAD(&((psock)->pt), (condition))

		#endif /* PSOCK_H_ */

		/** @} */
		/** @} */

net/ip/contiki/ip/tcpip.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -425,7 +425,7 @@ eventhandler(process_event_t ev, process_data_t data, struct net_buf *buf)
		/* Only restart the timer if there are active
		connections. */
		etimer_restart(&periodic);
		uip_periodic(i);
		uip_periodic(buf, i);
		#if NETSTACK_CONF_WITH_IPV6
		tcpip_ipv6_output(buf);
		#else
		@@ -488,7 +488,7 @@ eventhandler(process_event_t ev, process_data_t data, struct net_buf *buf)
		#if UIP_TCP
		case TCP_POLL:
		if(data != NULL) {
		uip_poll_conn(data);
		uip_poll_conn(buf, data);
		#if NETSTACK_CONF_WITH_IPV6
		tcpip_ipv6_output(buf);
		#else /* NETSTACK_CONF_WITH_IPV6 */
		@@ -829,10 +829,10 @@ tcpip_uipcall(struct net_buf *buf)

		/* If this is a connection request for a listening port, we must
		mark the connection with the right process ID. */
		if(uip_connected()) {
		if(uip_connected(buf)) {
		l = &s.listenports[0];
		for(i = 0; i < UIP_LISTENPORTS; ++i) {
		if(l->port == uip_conn->lport &&
		if(l->port == uip_conn(buf)->lport &&
		l->p != PROCESS_NONE) {
		ts->p = l->p;
		ts->state = NULL;

net/ip/contiki/ip/tcpip.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -77,7 +77,7 @@ struct tcpip_uipstate {
		void *state;
		};

		#define UIP_APPCALL tcpip_uipcall
		#define UIP_APPCALL(buf) tcpip_uipcall(buf)
		#define UIP_UDP_APPCALL(buf) tcpip_uipcall(buf)
		#define UIP_ICMP6_APPCALL tcpip_icmp6_call

net/ip/contiki/ip/uip.h

+12 −12

File changed.

Preview size limit exceeded, changes collapsed.

Admin message