Lines Matching full:that

51 Many other TCP/IP implementations for small systems assume that the
54 assumption, it is possible to remove certain TCP/IP mechanisms that
60 network citizens. The uIP TCP/IP implementation that is not tailored
68 addresses, to application level protocols such as SMTP that is used to
72 or firmware and will be referred to as "the network device" that are
80 another network by a router that is situated between the two
84 chosen so that fragmentation is minimized. The final recipient of the
95 that deal with the host to host communication and those that deal with
100 application." A TCP/IP implementation that violates requirements of
106 In uIP, all RFC requirements that affect host-to-host communication
111 connections. Since there are only very few applications that make use
130 Periodic timeouts are used to drive TCP mechanisms that depend on
132 round-trip time estimations. When the main control loop infers that
136 driver should called to send out the packets that may have been produced.
147 The TCP and IP protocols implement a checksum that covers the data and
150 received it is important that the function that calculates the
151 checksum is efficient. Most often, this means that the checksum
195 packets before the application has processed the data. Packets that
198 Ethernet controllers have on-chip buffers that are large enough to
199 contain at least 4 maximum sized Ethernet frames. Devices that are
205 receiver window, which means that only a single TCP segment will be in
208 In uIP, the same global packet buffer that is used for incoming
211 packet buffer that are not used for headers as a temporary storage
224 simultaneous connections. A device that will be sending large e-mails
248 event-based API that is nore low-level than protosockets but uses less
259 of uIP is implemented as a C function that is called by uIP in
271 uIP is different from other TCP/IP stacks in that it requires help
281 In order to reduce memory usage, uIP utilizes the fact that the
285 uIP requires that the application takes an active part in performing
286 the retransmission. When uIP decides that a segment should be
288 that a retransmission is required. The application checks the
289 retransmission flag and produces the same data that was previously
292 application can be written in such a way that the same code is used
294 to note that even though the actual retransmission operation is
303 that uIP calls whenever an event occurs. Each event has a corresponding
304 test function that is used to distinguish between different
305 events. The functions are implemented as C macros that will evaluate
306 to either zero or non-zero. Note that certain events can happen in
313 set to point to the uip_conn structure for the connection that
340 dictated by the memory configuration. It is therefore possible that
343 data that actually will be sent by the stack.
348 for producing the actual data that should be sent, the packet buffer
362 been sent by the device driver, uIP requires that the
364 retransmission. When uIP decides that a segment should be
366 uip_rexmit() flag set, indicating that a retransmission is
370 data that was previously sent. From the application's standpoint,
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
395 There are two fatal errors that can happen to a connection, either
396 that the connection was aborted by the remote host, or that the
409 application periodically know that a connection is idle, which allows
410 the application to close connections that have been idle for too
411 long. The other purpose is to let the application send new data that
504 and has to be retransmitted, it also sends an "ok".  Note that this
515 This application is similar to the first application in that it
517 to it with a single "ok". The big difference is that this application
523 complexity is that if data should be lost in the network, the
529 The application knows that as long as the "Welcome!" message has not
532 back, the application can be sure that the welcome has been received
533 and knows that any lost data must be an "ok" message. Thus the
547 knows that the previous welcome message hasn't been acknowledged. If
548 the application is in the WELCOME-ACKED state, it knows that the last
630 This example shows a simple application that connects to a host, sends
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
671 important to note that this example assumes that this function copies
677 can then be sure that it will not receive any new data until
684 This example shows a very simple file server application that listens
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
735 uip_send(). uIP makes sure that no more than MSS bytes of data is
746 provides a structured design that has showed itself to be useful for
749 that calls seven application handler functions that process new data,
754 the protocol that is being implemented.
788 The function starts with dealing with any error conditions that might
798 for the connection. Since it may be the case that data should be sent
871 that the application is waiting for data to arrive from the network,
882 "STATE_WAITING" and the "textlen" variable to be zero, indicating that
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
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
910 that is to be sent, and to call the uip_send() function to actually
916 It is important to note that the senddata() function never should
935 protocol that examines the packet. The IP layer does a few simple
938 checksum. Since there are no IP options that are strictly required and
944 IP fragment reassembly is implemented using a separate buffer that
995 data that is to be delivered to the application, the application is
1018 sliding window implementation that does not buffer sent packets will have
1023 It is important to note that even though most TCP implementations use
1036 each connection that has unacknowledged data in the network. When an
1040 estimate of the RTT. Karn's algorithm is used to ensure that
1051 been sent by the device driver, uIP requires that the
1053 retransmission. When uIP decides that a segment should be
1055 that a retransmission is required. The application checks the
1056 retransmission flag and produces the same data that was previously
1059 application can be written in such a way that the same code is used
1061 to note that even though the actual retransmission operation is
1148 A TCP sender such as uIP that only handles a single outstanding TCP
1152 sent. This means that the maximum possible throughput is severely
1164 It should be noted, however, that since small systems running uIP are