Lines Matching full:data

147 The TCP and IP protocols implement a checksum that covers the data and
190 contains data, the TCP/IP stack will notify the corresponding
191 application. Because the data in the buffer will be overwritten by the
193 immediately on the data or copy the data into a secondary buffer for
195 packets before the application has processed the data. Packets that
196 arrive when the application is processing the data must be queued,
209 packets is also used for the TCP/IP headers of outgoing data. If the
210 application sends dynamic data, it may use the parts of the global
212 buffer. To send the data, the application passes a pointer to the data
213 as well as the length of the data to the stack. The TCP/IP headers are
215 produced, the device driver sends the headers and the application data
216 out on the network. The data is not queued for
218 data if a retransmission is necessary.
260 response to certain events. uIP calls the application when data is
261 received, when data has been successfully delivered to the other end
262 of the connection, when a new connection has been set up, or when data
264 for new data. The application program provides only one callback
267 application is able to act on incoming data and connection requests as
273 buffer the transmitted data in memory until the data is known to be
275 data needs to be retransmitted, the stack takes care of the
277 the data has to be buffered in memory while waiting for an
279 regenerate the data if a retransmission has to be made.
282 application may be able to regenerate sent data and lets the
289 retransmission flag and produces the same data that was previously
291 is not different from how the data originally was sent. Therefore the
293 both for sending data and retransmitting data. Also, it is important
307 conjunction with each other (i.e., new data can arrive at the same
308 time as data is acknowledged).
324 \subsubsection recvdata Receiving Data
327 the connection has sent new data. The uip_appdata pointer point to the
328 actual data. The size of the data is obtained through the uIP function
329 uip_datalen(). The data is not buffered by uIP, but will be
332 data, or by itself copy the incoming data into a buffer for later
335 \subsubsection senddata Sending Data
337 When sending data, uIP adjusts the length of the data sent by the
341 all data sent from the application does not arrive at the receiver,
343 data that actually will be sent by the stack.
345 The application sends data by using the uIP function uip_send(). The
346 uip_send() function takes two arguments; a pointer to the data to be
347 sent and the length of the data. If the application needs RAM space
348 for producing the actual data that should be sent, the packet buffer
351 The application can send only one chunk of data at a time on a
353 per application invocation; only the data from the last call will be
356 \subsubsection rexmitdata Retransmitting Data
370 data that was previously sent. From the application's standpoint,
371 performing a retransmission is not different from how the data
373 a way that the same code is used both for sending data and
374 retransmitting data. Also, it is important to note that even though
397 connection retransmitted the last data too many times and has been
411 long. The other purpose is to let the application send new data that
412 has been produced. The application can only send data when invoked by
413 uIP, and therefore the poll event is the only way to send data on an
477 been established, the application replies to all data sent to it by
502 the remote end has sent it data, it responds with an "ok". If the
503 application function was called because data was lost in the network
516 listens to a port for incoming connections and responds to data sent
523 complexity is that if data should be lost in the network, the
524 application must know what data to retransmit. If the "Welcome!"
533 and knows that any lost data must be an "ok" message. Thus the
541 WELCOME-ACKED state. If the application receives any new data from the
664 the server. Since this is the only data that is sent, the application
665 knows that if it needs to retransmit any data, it is that request that
669 When the application receives new data from the remote host, it sends
670 this data to the device by using the function device_enqueue(). It is
672 the data into its own buffers. The data in the uip_appdata buffer will
675 If the device's queue is full, the application stops the data from the
677 can then be sure that it will not receive any new data until
679 check if the device's queue is no longer full and if so, the data flow
731 The application state consists of a pointer to the data that should be
732 sent and the size of the data that is left to send. When a remote host
734 determine which file to send. The first chunk of data is sent using
735 uip_send(). uIP makes sure that no more than MSS bytes of data is
738 The application is driven by incoming acknowledgments. When data has
739 been acknowledged, new data can be sent. If there is no more data to
749 that calls seven application handler functions that process new data,
750 act on acknowledged data, send new data, deal with connection
798 for the connection. Since it may be the case that data should be sent
799 out, the senddata() function is called to deal with the outgoing data.
803 waits for any data to arrive on the connection, and responds to the
804 data by sending out the message "Hello world!". To illustrate how to
871 that the application is waiting for data to arrive from the network,
885 When new data arrives from the network, the newdata() function will be
892 The acked() function is called whenever data that previously was sent
894 first reduces the amount of data that is left to send, by subtracting
895 the length of the previously sent data (obtained from "uip_conn->len")
898 which indicates that all data now has been successfully received, and
905 data that is to be sent. It is called by the event handler function
906 when new data has been received, when data has been acknowledged, when
909 purpose of the senddata() function is to optionally format the data
911 send out the data. In this particular example, the function simply
912 calls uip_send() with the appropriate arguments if data is to be sent,
913 after checking if data should be sent out or not as indicated by the
995 data that is to be delivered to the application, the application is
997 packet acknowledges previously sent data, the connection state is
999 data.
1012 data. Multiple data segments are sent in succession without waiting
1036 each connection that has unacknowledged data in the network. When an
1056 retransmission flag and produces the same data that was previously
1058 is not different from how the data originally was sent. Therefore the
1060 both for sending data and retransmitting data. Also, it is important
1072 space. A TCP sender must not send more data than the buffer space
1075 In uIP, the application cannot send more data than the receiving host
1076 can buffer. And application cannot send more data than the amount of
1078 cannot accept any data at all, the stack initiates the zero window
1092 \subsubsection urgdata Urgent Data
1094 TCP's urgent data mechanism provides an application-to-application
1096 parts of the data stream as being more urgent than the normal
1098 of the urgent data.
1101 urgent data feature increases the complexity of the implementation
1104 based API, the implementation of the urgent data feature does not lead
1111 packet data and context switching. Operating systems for high-end
1113 data from user processes and user processes from each other. Because
1114 the TCP/IP stack is run in the kernel, data has to be copied between
1116 context switch has to be performed once the data has been
1125 data between the TCP/IP stack and the application program. With an
1130 by the copying of packet data from the network device to host memory,
1133 updating a few counters and flags before handing the data over to the
1155 Thus the maximum throughput equation when sending data from uIP will
1165 not very likely to have large amounts of data to send, the delayed
1167 severe. Small amounts of data sent by such a system will not span more