Lines Matching full:and

9 micro-controllers. Despite being small and simple, uIP do not require
12 the order of a few kilobytes and RAM usage can be configured to be as
21 \sa \ref uipdevfunc "Device driver interface" and
24 (see below) and the \ref psock "protosockets API" and their underlying
31 used for web page transfers, e-mail transmissions, file transfers, and
39 resources both in terms of code size and memory usage to be useful in
40 small 8 or 16-bit systems. Code size of a few hundred kilobytes and
43 of kilobytes of RAM and room for less than 100 kilobytes of
48 single network interface and contains the IP, ICMP, UDP and TCP
58 peer-to-peer services and protocols. uIP is designed to be RFC
69 transfer e-mail. The uIP is mostly concerned with the TCP and IP
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
76 breaks the byte stream into appropriately sized segments and each
91 defined in one more RFC documents and RFC1122 collects
92 all requirements and updates the previous RFCs. 
95 that deal with the host to host communication and those that deal with
96 communication between the application and the networking stack. An
98 option in any segment" and an example of the second kind is "There
102 implementations and may even lead to network failures. Violation of
104 within the system and will not affect host-to-host communication.
109 and the stack, such as the soft error reporting mechanism and
131 timers, such as delayed acknowledgments, retransmissions and
147 The TCP and IP protocols implement a checksum that covers the data and
148 header portions of the TCP and IP packets. Since the calculation of
149 this checksum is made over all bytes in every packet being sent and
157 uip_ipchksum() and uip_tcpchksum(). The checksum calculations in those
163 The TCP protocol uses 32-bit sequence numbers, and a TCP
168 specific module and does not make use of any 32-bit arithmetic in the
186 packets and has a fixed table for holding connection state. The global
189 it in the global buffer and calls the TCP/IP stack. If the packet
214 written into the global buffer and once the headers have been
215 produced, the device driver sends the headers and the application data
223 traffic the system should be able to handle and the maximum amount of
226 pages and multiple simultaneous clients, will require more RAM than a
229 provide extremely low throughput and will only allow a small number of
238 systems and has heavily influenced the Microsoft Windows WinSock
239 API. Because the socket API uses stop-and-wait semantics, it requires
241 overhead of task management, context switching and allocation of stack
247 API without the overhead of full multi-threading, and a "raw"
266 network services to different ports and connections. Because the
267 application is able to act on incoming data and connection requests as
282 application may be able to regenerate sent data and lets the
284 packet contents after they have been sent by the device driver, and
289 retransmission flag and produces the same data that was previously
293 both for sending data and retransmitting data. Also, it is important
314 currently is handled, and is called the "current connection". The
321 uip_conn->lport is equal to 80 and act as a TELNET server if the value
330 overwritten after the application function returns, and the
338 application according to the available buffer space and the current
342 and the application may use the uip_mss() function to see how much
347 sent and the length of the data. If the application needs RAM space
352 connection and it is not possible to call uip_send() more than once
369 The application must check the uip_rexmit() flag and produce the same
373 a way that the same code is used both for sending data and
386 application might want to abort the connection and does so by calling
397 connection retransmitted the last data too many times and has been
399 application can use the two test functions uip_aborted() and
413 uIP, and therefore the poll event is the only way to send data on an
420 arrives on a listening port, uIP creates a new connection and calls
431 allocates a new connection and sets a flag in the connection state
432 which will open a TCP connection to the specified IP address and port
446 and the current connection is aborted by uip_abort(). 
481 is initialized with the function called example1_init() and the uIP
500 example1_app() uses the test functions uip_newdata() and uip_rexmit()
504 and has to be retransmitted, it also sends an "ok".  Note that this
512 and shows how the application state field in the uip_conn structure is
516 listens to a port for incoming connections and responds to data sent
525 message was lost, the application must retransmit the welcome and if
533 and knows that any lost data must be an "ok" message. Thus the
539 the "Welcome!" message and sets it's state to WELCOME-SENT. When the
549 message was an "ok" message and sends such a message.
631 an HTTP request for a file and downloads it to a slow device such a
679 check if the device's queue is no longer full and if so, the data flow
685 to two ports and uses the port number to determine which file to
732 sent and the size of the data that is left to send. When a remote host
751 establishment or closure events and handle errors. The functions are
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
803 waits for any data to arrive on the connection, and responds to the
806 parts, first the "Hello" part and then the "world!" part.
869 pointer to a text message and the "textlen" length of the text
877 and therefore the aborted(), timedout() and closed() functions are
881 established, and in this case sets the "state" variable to be
882 "STATE_WAITING" and the "textlen" variable to be zero, indicating that
887 check if the connection is in the "STATE_WAITING" state, and if so
888 switches to the "STATE_HELLO" state and registers a 6 byte long "Hello
896 from the "textlen" variable, and also adjusts the "textptr" pointer
898 which indicates that all data now has been successfully received, and
900 "STATE_HELLO" state, it switches state to "STATE_WORLD" and sets up a
910 that is to be sent, and to call the uip_send() function to actually
918 and newdata() functions.
923 fashion where each protocol performs a specific function and the
937 matches any of the local IP address and verifies the IP header
938 checksum. Since there are no IP options that are strictly required and
946 into the right place in the buffer and a bit map is used to keep track
955 packets to be reassembled, and therefore does not support simultaneous
961 \subsubsection ipbroadcast Broadcasts and Multicasts
963 IP has the ability to broadcast and multicast packets on the local
964 network. Such packets are addressed to special broadcast and multicast
968 RTP. TCP is a point-to-point protocol and does not use broadcast or
970 sending multicast packets. Joining multicast groups (IGMP) and
975 The ICMP protocol is used for reporting soft error conditions and for
981 constructed by simply swapping the source and destination IP addresses
982 of incoming echo requests and rewriting the ICMP header with the
993 The TCP implementation in uIP is driven by incoming packets and timer
994 events. Incoming packets are parsed by TCP and if the packet contains
998 updated and the application is informed, allowing it to send out new
1005 and incoming connection requests are checked against the list of
1007 and can be altered by the applications in the system.
1015 The sliding window algorithm uses a lot of 32-bit operations and
1017 does not implement it. Also, uIP does not buffer sent packets and a
1056 retransmission flag and produces the same data that was previously
1060 both for sending data and retransmitting data. Also, it is important
1076 can buffer. And application cannot send more data than the amount of
1085 are designed to be simple to implement and require only a few lines of
1111 packet data and context switching. Operating systems for high-end
1113 data from user processes and user processes from each other. Because
1115 the kernel space and the address space of the user processes and a
1123 to have multiple protection domains and the power to run a
1125 data between the TCP/IP stack and the application program. With an
1127 and the applications.
1131 and checksum calculation. Apart from the checksum calculation and
1133 updating a few counters and flags before handing the data over to the
1136 cycles needed for the checksum calculation and copying of a maximum
1156 be $p = s / (t + t_d)$ where $s$ is the segment size and $t_d$ is the
1157 delayed acknowledgment timeout, which typically is between 200 and
1159 and a delayed acknowledgment timeout of 200 ms, the maximum
1168 than a single TCP segment, and would therefore not be affected by the