1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
#include <string.h>
#include <assert.h>
#include <byteswap.h>
#include <gpxe/tcp.h>
#include "uip/uip.h"
/** @file
*
* TCP protocol
*
* The gPXE TCP stack is currently implemented on top of the uIP
* protocol stack. This file provides wrappers around uIP so that
* higher-level protocol implementations do not need to talk directly
* to uIP (which has a somewhat baroque API).
*
* Basic operation is to create a #tcp_connection structure, call
* tcp_connect() and then call run_tcpip() in a loop until the
* operation has completed. The TCP stack will call the various
* methods defined in the #tcp_operations structure in order to send
* and receive data.
*
* See hello.c for a trivial example of a TCP protocol using this
* API.
*
*/
/**
* TCP transmit buffer
*
* When a tcp_operations::senddata() method is called, it is
* guaranteed to be able to use this buffer as temporary space for
* constructing the data to be sent. For example, code such as
*
* @code
*
* static void my_senddata ( struct tcp_connection *conn ) {
* int len;
*
* len = snprintf ( tcp_buffer, tcp_buflen, "FETCH %s\r\n", filename );
* tcp_send ( conn, tcp_buffer + already_sent, len - already_sent );
* }
*
* @endcode
*
* is allowed, and is probably the best way to deal with
* variably-sized data.
*
* Note that you cannot use this simple mechanism if you want to be
* able to construct single data blocks of more than #tcp_buflen
* bytes.
*/
void *tcp_buffer = uip_buf + ( 40 + UIP_LLH_LEN );
/** Size of #tcp_buffer */
size_t tcp_buflen = UIP_BUFSIZE - ( 40 + UIP_LLH_LEN );
/**
* Open a TCP connection
*
* @v conn TCP connection
* @ret 0 Success
* @ret <0 Failure
*
* This sets up a new TCP connection to the remote host specified in
* tcp_connection::sin. The actual SYN packet will not be sent out
* until run_tcpip() is called for the first time.
*
* @todo Use linked lists instead of a static buffer, and thereby
* remove the only potential failure case, giving this function
* a void return type.
*/
int tcp_connect ( struct tcp_connection *conn ) {
struct uip_conn *uip_conn;
u16_t ipaddr[2];
assert ( conn->sin.sin_addr.s_addr != 0 );
assert ( conn->sin.sin_port != 0 );
assert ( conn->tcp_op != NULL );
assert ( sizeof ( uip_conn->appstate ) == sizeof ( conn ) );
* ( ( uint32_t * ) ipaddr ) = conn->sin.sin_addr.s_addr;
uip_conn = uip_connect ( ipaddr, conn->sin.sin_port );
if ( ! uip_conn )
return -1;
*( ( void ** ) uip_conn->appstate ) = conn;
return 0;
}
/**
* Send data via a TCP connection
*
* @v conn TCP connection
* @v data Data to send
* @v len Length of data
*
* Data will be automatically limited to the current TCP window size.
*
* If retransmission is required, the connection's
* tcp_operations::senddata() method will be called again in order to
* regenerate the data.
*/
void tcp_send ( struct tcp_connection *conn __unused,
const void *data, size_t len ) {
assert ( conn = *( ( void ** ) uip_conn->appstate ) );
if ( len > tcp_buflen )
len = tcp_buflen;
memmove ( tcp_buffer, data, len );
uip_send ( tcp_buffer, len );
}
/**
* Close a TCP connection
*
* @v conn TCP connection
*/
void tcp_close ( struct tcp_connection *conn __unused ) {
assert ( conn = *( ( void ** ) uip_conn->appstate ) );
uip_close();
}
/**
* uIP TCP application call interface
*
* This is the entry point of gPXE from the point of view of the uIP
* protocol stack. This function calls the appropriate methods from
* the connection's @tcp_operations table in order to process received
* data, transmit new data etc.
*/
void uip_tcp_appcall ( void ) {
struct tcp_connection *conn = *( ( void ** ) uip_conn->appstate );
struct tcp_operations *op = conn->tcp_op;
assert ( conn->tcp_op->closed != NULL );
assert ( conn->tcp_op->connected != NULL );
assert ( conn->tcp_op->acked != NULL );
assert ( conn->tcp_op->newdata != NULL );
assert ( conn->tcp_op->senddata != NULL );
if ( uip_aborted() && op->aborted ) /* optional method */
op->aborted ( conn );
if ( uip_timedout() && op->timedout ) /* optional method */
op->timedout ( conn );
if ( uip_closed() && op->closed ) /* optional method */
op->closed ( conn );
if ( uip_connected() )
op->connected ( conn );
if ( uip_acked() )
op->acked ( conn, uip_conn->len );
if ( uip_newdata() )
op->newdata ( conn, ( void * ) uip_appdata, uip_len );
if ( uip_rexmit() || uip_newdata() || uip_acked() ||
uip_connected() || uip_poll() )
op->senddata ( conn );
}
/* Present here to allow everything to link. Will go into separate
* udp.c file
*/
void uip_udp_appcall ( void ) {
}
|
