Lines Matching full:be
12 the order of a few kilobytes and RAM usage can be configured to be as
15 uIP can be found at the uIP web page: http://www.sics.se/~adam/uip/
35 with full TCP/IP support will be first-class network citizens, thus
39 resources both in terms of code size and memory usage to be useful in
58 peer-to-peer services and protocols. uIP is designed to be RFC
70 protocols and upper layer protocols will be referred to as "the
72 or firmware and will be referred to as "the network device" that are
86 can be passed to higher layers.
94 The RFC1122 requirements can be divided into two categories; those
97 example of the first kind is "A TCP MUST be able to receive a TCP
99 MUST be a mechanism for reporting soft TCP error conditions to the
101 the first kind may not be able to communicate with other TCP/IP
112 of those features they can be removed without loss of generality.
116 The uIP stack can be run either as a task in a multitasking system, or
124 should be invoked by the main control loop. The input handler function
127 produced one or more reply packets which should be sent out. If so,
128 the network device driver should be called to send out these packets.
140 uIP requires a few functions to be implemented specifically for the
142 be hand-tuned for the particular architecture, but generic C
152 calculation must be fine-tuned for the particular architecture on
158 functions can be written in highly optimized assembler rather than
167 uIP leaves the 32-bit additions to be implemented by the architecture
180 TCP/IP stack to use, mechanisms used in traditional TCP/IP cannot be
191 application. Because the data in the buffer will be overwritten by the
194 later processing. The packet buffer will not be overwritten by new
196 arrive when the application is processing the data must be queued,
205 receiver window, which means that only a single TCP segment will be in
222 to be run. The memory configuration determines both the amount of
223 traffic the system should be able to handle and the maximum amount of
224 simultaneous connections. A device that will be sending large e-mails
242 space for the tasks might be too high in the intended uIP target
263 has to be retransmitted. The application is also periodically polled
269 be achieved even in low-end systems.
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
278 acknowledgment even if the application might be able to quickly
279 regenerate the data if a retransmission has to be made.
282 application may be able to regenerate sent data and lets the
286 the retransmission. When uIP decides that a segment should be
292 application can be written in such a way that the same code is used
296 to know when the retransmission should be made. Thus the complexity of
302 The application must be implemented as a C function, UIP_APPCALL(),
315 fields in the uip_conn structure for the current connection can be
317 which IP address the connection is connected. One typical use would be
329 uip_datalen(). The data is not buffered by uIP, but will be
343 data that actually will be sent by the stack.
346 uip_send() function takes two arguments; a pointer to the data to be
348 for producing the actual data that should be sent, the packet buffer
349 (pointed to by the uip_appdata pointer) can be used for this purpose.
353 per application invocation; only the data from the last call will be
361 should be made. As uIP does not keep track of packet contents after they have
364 retransmission. When uIP decides that a segment should be
372 originally was sent. Therefor, the application can be written in such
377 should be made. Thus the complexity of the application does not
385 to be cleanly closed. In order to indicate a fatal error, the
429 New connections can be opened from within
439 The function uip_ipaddr() may be used to pack an IP address into the
445 new connection to be opened, the uip_connect() function returns NULL
483 configuration variable UIP_APPCALL should be defined to be
504 and has to be retransmitted, it also sends an "ok". Note that this
523 complexity is that if data should be lost in the network, the
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
534 application can be in either of two states: either in the WELCOME-SENT
608 how the two examples above can be combined into one application.
666 should be retransmitted. It is therefore possible to combine these two
673 be overwritten by the next incoming packet.
677 can then be sure that it will not receive any new data until
687 be used as a web server with static pages. The implementation follows.
731 The application state consists of a pointer to the data that should be
736 actually sent, even though s->dataleft may be larger than the MSS.
739 been acknowledged, new data can be sent. If there is no more data to
744 When writing larger programs using uIP it is useful to be able to
746 provides a structured design that has showed itself to be useful for
753 aborted(), and timedout(), and needs to be written specifically for
796 called and is supposed to do whatever needs to be done when the
798 for the connection. Since it may be the case that data should be sent
870 message. The "state" variable can be either "STATE_WAITING", meaning
880 The connected() function will be called when a connection has been
881 established, and in this case sets the "state" variable to be
882 "STATE_WAITING" and the "textlen" variable to be zero, indicating that
883 there is no message to be sent out.
885 When new data arrives from the network, the newdata() function will be
889 " message with the connection. This message will later be sent out by
901 7 byte "world!\n" message to be sent. If the application was in the
905 data that is to be sent. It is called by the event handler function
908 because of inactivity, or when a retransmission should be made. The
910 that is to be sent, and to call the uip_send() function to actually
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
917 affect the application state; this should only be done in the acked()
945 holds the packet to be reassembled. An incoming fragment is copied
955 packets to be reassembled, and therefore does not support simultaneous
957 uncommon, this ought to be a reasonable decision. Extending the
958 implementation to support multiple buffers would be straightforward,
995 data that is to be delivered to the application, the application is
1007 and can be altered by the applications in the system.
1019 to be supported by a complex application layer. Instead, uIP allows
1020 only a single TCP segment per connection to be unacknowledged at any
1048 should be made.
1053 retransmission. When uIP decides that a segment should be
1059 application can be written in such a way that the same code is used
1063 to know when the retransmission should be made. Thus the complexity of
1085 are designed to be simple to implement and require only a few lines of
1089 the amount of simultaneous segments cannot be further limited, thus
1095 notification mechanism, which can be used by an application to mark
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
1117 copied. Performance can be enhanced by combining the copy operation
1135 implementations can be obtained by calculating the amount of CPU
1145 time-frame, an acknowledgment is sent. The time-frame can be as high
1156 be $p = s / (t + t_d)$ where $s$ is the segment size and $t_d$ is the
1160 throughput will be 4166 bytes per second. With the delayed acknowledgment
1161 algorithm disabled at the receiver, the maximum throughput would be
1164 It should be noted, however, that since small systems running uIP are
1166 acknowledgmen t throughput degradation of uIP need not be very
1168 than a single TCP segment, and would therefore not be affected by the