pkbuff->iobuf changeover
[gpxe.git] / src / net / udp.c
1 #include <stdint.h>
2 #include <string.h>
3 #include <assert.h>
4 #include <byteswap.h>
5 #include <errno.h>
6 #include <gpxe/tcpip.h>
7 #include <gpxe/iobuf.h>
8 #include <gpxe/netdevice.h>
9 #include <gpxe/udp.h>
10
11 /** @file
12  *
13  * UDP protocol
14  */
15
16 struct tcpip_protocol udp_protocol;
17
18 /**
19  * List of registered UDP connections
20  */
21 static LIST_HEAD ( udp_conns );
22
23 /**
24  * Bind UDP connection to local port
25  *
26  * @v conn              UDP connection
27  * @v local_port        Local port, in network byte order
28  * @ret rc              Return status code
29  */
30 int udp_bind ( struct udp_connection *conn, uint16_t local_port ) {
31         struct udp_connection *existing;
32
33         list_for_each_entry ( existing, &udp_conns, list ) {
34                 if ( existing->local_port == local_port )
35                         return -EADDRINUSE;
36         }
37         conn->local_port = local_port;
38         return 0;
39 }
40
41 /**
42  * Open a local port
43  *
44  * @v conn              UDP connection
45  * @v local_port        Local port, in network byte order, or zero
46  * @ret rc              Return status code
47  *
48  * Opens the UDP connection and binds to a local port.  If no local
49  * port is specified, the first available port will be used.
50  */
51 int udp_open ( struct udp_connection *conn, uint16_t local_port ) {
52         static uint16_t try_port = 1024;
53         int rc;
54
55         /* If no port specified, find the first available port */
56         if ( ! local_port ) {
57                 for ( ; try_port ; try_port++ ) {
58                         if ( try_port < 1024 )
59                                 continue;
60                         if ( udp_open ( conn, htons ( try_port ) ) == 0 )
61                                 return 0;
62                 }
63                 return -EADDRINUSE;
64         }
65
66         /* Attempt bind to local port */
67         if ( ( rc = udp_bind ( conn, local_port ) ) != 0 ) {
68                 DBGC ( conn, "UDP %p could not bind to local port %d: %s\n",
69                        conn, local_port, strerror ( rc ) );
70                 return rc;
71         }
72
73         /* Add to UDP connection list */
74         list_add ( &conn->list, &udp_conns );
75         DBGC ( conn, "UDP %p opened on port %d\n", conn,
76                ntohs ( local_port ) );
77
78         return 0;
79 }
80
81 /**
82  * Close a UDP connection
83  *
84  * @v conn              UDP connection
85  */
86 void udp_close ( struct udp_connection *conn ) {
87         list_del ( &conn->list );
88         DBGC ( conn, "UDP %p closed\n", conn );
89 }
90
91 /**
92  * Allocate I/O buffer for UDP
93  *
94  * @v conn              UDP connection
95  * @ret iobuf           I/O buffer, or NULL
96  */
97 static struct io_buffer * udp_alloc_iob ( struct udp_connection *conn ) {
98         struct io_buffer *iobuf;
99
100         iobuf = alloc_iob ( UDP_MAX_TXIOB );
101         if ( ! iobuf ) {
102                 DBGC ( conn, "UDP %p cannot allocate buffer of length %d\n",
103                        conn, UDP_MAX_TXIOB );
104                 return NULL;
105         }
106         iob_reserve ( iobuf, UDP_MAX_HLEN );
107         return iobuf;
108 }
109
110 /**
111  * User request to send data via a UDP connection
112  *
113  * @v conn              UDP connection
114  *
115  * This function allocates buffer space and invokes the function's
116  * senddata() callback.  The callback may use the buffer space as
117  * temporary storage space.
118  */
119 int udp_senddata ( struct udp_connection *conn ) {
120         int rc;
121
122         conn->tx_iob = udp_alloc_iob ( conn );
123         if ( ! conn->tx_iob )
124                 return -ENOMEM;
125
126         rc = conn->udp_op->senddata ( conn, conn->tx_iob->data, 
127                                       iob_tailroom ( conn->tx_iob ) );
128         if ( rc != 0 ) {
129                 DBGC ( conn, "UDP %p application could not send packet: %s\n",
130                        conn, strerror ( rc ) );
131         }
132
133         if ( conn->tx_iob ) {
134                 free_iob ( conn->tx_iob );
135                 conn->tx_iob = NULL;
136         }
137
138         return rc;
139 }
140                 
141 /**
142  * Transmit data via a UDP connection to a specified address
143  *
144  * @v conn              UDP connection
145  * @v peer              Destination address
146  * @v netdev            Network device to use if no route found, or NULL
147  * @v data              Data to send
148  * @v len               Length of data
149  * @ret rc              Return status code
150  */
151 int udp_sendto_via ( struct udp_connection *conn, struct sockaddr_tcpip *peer,
152                      struct net_device *netdev, const void *data,
153                      size_t len ) {
154         struct udp_header *udphdr;
155         struct io_buffer *iobuf;
156         int rc;
157
158         /* Use precreated I/O buffer if one is available */
159         if ( conn->tx_iob ) {
160                 iobuf = conn->tx_iob;
161                 conn->tx_iob = NULL;
162         } else {
163                 iobuf = udp_alloc_iob ( conn );
164                 if ( ! iobuf )
165                         return -ENOMEM;
166         }
167
168         /* Avoid overflowing TX buffer */
169         if ( len > iob_tailroom ( iobuf ) )
170                 len = iob_tailroom ( iobuf );
171
172         /* Copy payload */
173         memmove ( iob_put ( iobuf, len ), data, len );
174
175         /*
176          * Add the UDP header
177          *
178          * Covert all 16- and 32- bit integers into network btye order before
179          * sending it over the network
180          */
181         udphdr = iob_push ( iobuf, sizeof ( *udphdr ) );
182         udphdr->dest_port = peer->st_port;
183         udphdr->source_port = conn->local_port;
184         udphdr->len = htons ( iob_len ( iobuf ) );
185         udphdr->chksum = 0;
186         udphdr->chksum = tcpip_chksum ( udphdr, sizeof ( *udphdr ) + len );
187
188         /* Dump debugging information */
189         DBGC ( conn, "UDP %p TX %d->%d len %zd\n", conn,
190                ntohs ( udphdr->source_port ), ntohs ( udphdr->dest_port ),
191                ntohs ( udphdr->len ) );
192
193         /* Send it to the next layer for processing */
194         if ( ( rc = tcpip_tx ( iobuf, &udp_protocol, peer, netdev,
195                                &udphdr->chksum ) ) != 0 ) {
196                 DBGC ( conn, "UDP %p could not transmit packet: %s\n",
197                        conn, strerror ( rc ) );
198                 return rc;
199         }
200
201         return 0;
202 }
203
204 /**
205  * Transmit data via a UDP connection to a specified address
206  *
207  * @v conn              UDP connection
208  * @v peer              Destination address
209  * @v data              Data to send
210  * @v len               Length of data
211  * @ret rc              Return status code
212  */
213 int udp_sendto ( struct udp_connection *conn, struct sockaddr_tcpip *peer,
214                  const void *data, size_t len ) {
215         return udp_sendto_via ( conn, peer, NULL, data, len );
216 }
217
218 /**
219  * Transmit data via a UDP connection
220  *
221  * @v conn              UDP connection
222  * @v data              Data to send
223  * @v len               Length of data
224  * @ret rc              Return status code
225  */
226 int udp_send ( struct udp_connection *conn, const void *data, size_t len ) {
227         return udp_sendto ( conn, &conn->peer, data, len );
228 }
229
230 /**
231  * Identify UDP connection by local port number
232  *
233  * @v local_port        Local port (in network-endian order)
234  * @ret conn            TCP connection, or NULL
235  */
236 static struct udp_connection * udp_demux ( uint16_t local_port ) {
237         struct udp_connection *conn;
238
239         list_for_each_entry ( conn, &udp_conns, list ) {
240                 if ( ( conn->local_port == local_port ) ||
241                      ( conn->local_port == 0 ) ) {
242                         return conn;
243                 }
244         }
245         return NULL;
246 }
247
248 /**
249  * Process a received packet
250  *
251  * @v iobuf             I/O buffer
252  * @v st_src            Partially-filled source address
253  * @v st_dest           Partially-filled destination address
254  * @v pshdr_csum        Pseudo-header checksum
255  * @ret rc              Return status code
256  */
257 static int udp_rx ( struct io_buffer *iobuf, struct sockaddr_tcpip *st_src,
258                     struct sockaddr_tcpip *st_dest, uint16_t pshdr_csum ) {
259         struct udp_header *udphdr = iobuf->data;
260         struct udp_connection *conn;
261         size_t ulen;
262         uint16_t csum;
263         int rc = 0;
264
265         /* Sanity check packet */
266         if ( iob_len ( iobuf ) < sizeof ( *udphdr ) ) {
267                 DBG ( "UDP packet too short at %d bytes (min %d bytes)\n",
268                       iob_len ( iobuf ), sizeof ( *udphdr ) );
269                 
270                 rc = -EINVAL;
271                 goto done;
272         }
273         ulen = ntohs ( udphdr->len );
274         if ( ulen < sizeof ( *udphdr ) ) {
275                 DBG ( "UDP length too short at %d bytes "
276                       "(header is %d bytes)\n", ulen, sizeof ( *udphdr ) );
277                 rc = -EINVAL;
278                 goto done;
279         }
280         if ( ulen > iob_len ( iobuf ) ) {
281                 DBG ( "UDP length too long at %d bytes (packet is %d bytes)\n",
282                       ulen, iob_len ( iobuf ) );
283                 rc = -EINVAL;
284                 goto done;
285         }
286         if ( udphdr->chksum ) {
287                 csum = tcpip_continue_chksum ( pshdr_csum, iobuf->data, ulen );
288                 if ( csum != 0 ) {
289                         DBG ( "UDP checksum incorrect (is %04x including "
290                               "checksum field, should be 0000)\n", csum );
291                         rc = -EINVAL;
292                         goto done;
293                 }
294         }
295
296         /* Parse parameters from header and strip header */
297         st_src->st_port = udphdr->source_port;
298         st_dest->st_port = udphdr->dest_port;
299         conn = udp_demux ( udphdr->dest_port );
300         iob_unput ( iobuf, ( iob_len ( iobuf ) - ulen ) );
301         iob_pull ( iobuf, sizeof ( *udphdr ) );
302
303         /* Dump debugging information */
304         DBGC ( conn, "UDP %p RX %d<-%d len %zd\n", conn,
305                ntohs ( udphdr->dest_port ), ntohs ( udphdr->source_port ),
306                ulen );
307
308         /* Ignore if no matching connection found */
309         if ( ! conn ) {
310                 DBG ( "No UDP connection listening on port %d\n",
311                       ntohs ( udphdr->dest_port ) );
312                 rc = -ENOTCONN;
313                 goto done;
314         }
315
316         /* Pass data to application */
317         if ( conn->udp_op->newdata ) {
318                 rc = conn->udp_op->newdata ( conn, iobuf->data, iob_len ( iobuf ),
319                                      st_src, st_dest );
320                 if ( rc != 0 ) {
321                         DBGC ( conn, "UDP %p application rejected packet: %s\n",
322                                conn, strerror ( rc ) );
323                 }
324         } else {
325                 DBGC ( conn, "UDP %p application has no newdata handler for " \
326                         "incoming packet\n", conn );
327         }
328
329  done:
330         free_iob ( iobuf );
331         return rc;
332 }
333
334 struct tcpip_protocol udp_protocol __tcpip_protocol = {
335         .name = "UDP",
336         .rx = udp_rx,
337         .tcpip_proto = IP_UDP,
338 };