Lines Matching +full:host +full:- +full:only
8 using the TCP/IP protocol suite even on small 8-bit
9 micro-controllers. Despite being small and simple, uIP do not require
10 their peers to have complex, full-size stacks, but can communicate
11 with peers running a similarly light-weight stack. The code size is on
18 \sa \ref uipopt "Compile-time configuration options"
19 \sa \ref uipconffunc "Run-time configuration functions"
31 used for web page transfers, e-mail transmissions, file transfers, and
32 peer-to-peer networking over the Internet. For embedded systems, being
35 with full TCP/IP support will be first-class network citizens, thus
40 small 8 or 16-bit systems. Code size of a few hundred kilobytes and
46 The uIP implementation is designed to have only the absolute minimal
47 set of features needed for a full TCP/IP stack. It can only handle a
52 embedded device always will communicate with a full-scale TCP/IP
53 implementation running on a workstation-class machine. Under this
58 peer-to-peer services and protocols. uIP is designed to be RFC
59 compliant in order to let the embedded devices to act as first-class
69 transfer e-mail. The uIP is mostly concerned with the TCP and IP
95 that deal with the host to host communication and those that deal with
103 the second kind of requirements will only affect the communication
104 within the system and will not affect host-to-host communication.
106 In uIP, all RFC requirements that affect host-to-host communication
110 dynamically configurable type-of-service bits for TCP
111 connections. Since there are only very few applications that make use
120 - Check if a packet has arrived from the network.
121 - Check if a periodic timeout has occurred.
132 round-trip time estimations. When the main control loop infers that
142 be hand-tuned for the particular architecture, but generic C
152 calculation must be fine-tuned for the particular architecture on
161 \subsection longarith 32-bit Arithmetic
163 The TCP protocol uses 32-bit sequence numbers, and a TCP
164 implementation will have to do a number of 32-bit additions as part of
165 the normal protocol processing. Since 32-bit arithmetic is not
167 uIP leaves the 32-bit additions to be implemented by the architecture
168 specific module and does not make use of any 32-bit arithmetic in the
171 While uIP implements a generic 32-bit addition, there is support for
179 scarce resource. With only a few kilobytes of RAM available for the
197 either by the network device or by the device driver. Most single-chip
198 Ethernet controllers have on-chip buffers that are large enough to
200 handled by the processor, such as RS-232 ports, can copy incoming
203 performance degradation, but only when multiple connections are
205 receiver window, which means that only a single TCP segment will be in
224 simultaneous connections. A device that will be sending large e-mails
229 provide extremely low throughput and will only allow a small number of
239 API. Because the socket API uses stop-and-wait semantics, it requires
246 uIP provides two APIs to programmers: protosockets, a BSD socket-like
247 API without the overhead of full multi-threading, and a "raw"
248 event-based API that is nore low-level than protosockets but uses less
264 for new data. The application program provides only one callback
269 be achieved even in low-end systems.
306 to either zero or non-zero. Note that certain events can happen in
318 to inspect the uip_conn->lport (the local TCP port number) to decide
321 uip_conn->lport is equal to 80 and act as a TELNET server if the value
326 If the uIP test function uip_newdata() is non-zero, the remote host of
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
396 that the connection was aborted by the remote host, or that the
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
440 two element 16-bit array used by uIP to represent IP addresses.
450 if(uip_connect(uip_conn->ripaddr, HTONS(8080)) == NULL) {
530 been acknowledged by the remote host, it might have been dropped in
531 the network. But once the remote host has sent an acknowledgment
534 application can be in either of two states: either in the WELCOME-SENT
536 the WELCOME-ACKED state where the "Welcome!" has been acknowledged.
538 When a remote host connects to the application, the application sends
539 the "Welcome!" message and sets it's state to WELCOME-SENT. When the
541 WELCOME-ACKED state. If the application receives any new data from the
542 remote host, it responds by sending an "ok" back.
546 the WELCOME-SENT state, it sends a "Welcome!" message since it
548 the application is in the WELCOME-ACKED state, it knows that the last
567 s = (struct example2_state *)uip_conn->appstate;
570 s->state = WELCOME_SENT;
575 if(uip_acked() && s->state == WELCOME_SENT) {
576 s->state = WELCOME_ACKED;
584 switch(s->state) {
617 switch(uip_conn->lport) {
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
669 When the application receives new data from the remote host, it sends
676 remote host by calling the uIP function uip_stop(). The application
702 s = (struct example5_state)uip_conn->appstate;
705 switch(uip_conn->lport) {
707 s->dataptr = data_port_80;
708 s->dataleft = datalen_port_80;
711 s->dataptr = data_port_81;
712 s->dataleft = datalen_port_81;
715 uip_send(s->dataptr, s->dataleft);
720 if(s->dataleft < uip_mss()) {
724 s->dataptr += uip_conn->len;
725 s->dataleft -= uip_conn->len;
726 uip_send(s->dataptr, s->dataleft);
732 sent and the size of the data that is left to send. When a remote host
736 actually sent, even though s->dataleft may be larger than the MSS.
824 struct example6_state *s = (struct example6_state *)uip_conn->appstate;
826 s->state = STATE_WAITING;
827 s->textlen = 0;
831 struct example6_state *s = (struct example6_state *)uip_conn->appstate;
833 if(s->state == STATE_WAITING) {
834 s->state = STATE_HELLO;
835 s->textptr = "Hello ";
836 s->textlen = 6;
841 struct example6_state *s = (struct example6_state *)uip_conn->appstate;
843 s->textlen -= uip_conn->len;
844 s->textptr += uip_conn->len;
845 if(s->textlen == 0) {
846 switch(s->state) {
848 s->state = STATE_WORLD;
849 s->textptr = "world!\n";
850 s->textlen = 7;
860 struct example6_state *s = (struct example6_state *)uip_conn->appstate;
862 if(s->textlen > 0) {
863 uip_send(s->textptr, s->textlen);
893 has been acknowleged by the receiving host. This acked() function
895 the length of the previously sent data (obtained from "uip_conn->len")
917 affect the application state; this should only be done in the acked()
932 \subsection ip IP --- Internet Protocol
948 fragment is aligned on an 8-byte boundary, the bit map requires a
954 The current implementation only has a single buffer for holding
966 as the Microsoft Windows file-sharing SMB protocol. Multicast is
968 RTP. TCP is a point-to-point protocol and does not use broadcast or
971 receiving non-local multicast packets is not currently supported.
973 \subsection icmp ICMP --- Internet Control Message Protocol
976 querying host parameters. Its main use is, however, the echo mechanism
980 only implement ICMP echo messages. Replies to echo messages are
983 Echo-Reply message type. The ICMP checksum is adjusted using standard
986 Since only the ICMP echo message is implemented, there is no support
991 \subsection tcp TCP --- Transmission Control Protocol
1004 uIP, a listening connection is identified by the 16-bit port number
1015 The sliding window algorithm uses a lot of 32-bit operations and
1016 because 32-bit arithmetic is fairly expensive on most 8-bit CPUs, uIP
1020 only a single TCP segment per connection to be unacknowledged at any
1028 \subsubsection rttest Round-Trip Time Estimation
1030 TCP continuously estimates the current Round-Trip Time (RTT) of every
1032 retransmission time-out.
1075 In uIP, the application cannot send more data than the receiving host
1077 bytes it is allowed to send by the receiving host. If the remote host
1085 are designed to be simple to implement and require only a few lines of
1088 Since uIP only handles one in-flight TCP segment per connection,
1094 TCP's urgent data mechanism provides an application-to-application
1109 In TCP/IP implementations for high-end systems, processing time is
1111 packet data and context switching. Operating systems for high-end
1118 with the checksum calculation. Because high-end systems usually have
1130 by the copying of packet data from the network device to host memory,
1132 copying, the TCP processing done for an incoming packet involves only
1143 receiver using this algorithm will only send acknowledgments for every
1145 time-frame, an acknowledgment is sent. The time-frame can be as high
1148 A TCP sender such as uIP that only handles a single outstanding TCP
1150 algorithm. Because the receiver only receives a single segment at a
1158 500 ms. With a segment size of 1000 bytes, a round-trip time of 40 ms