0a9cea8bd3b3aace271a74376ca72afcab209450
[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/pkbuff.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                 return rc;
69
70         /* Add to UDP connection list */
71         list_add ( &conn->list, &udp_conns );
72         DBGC ( conn, "UDP %p opened on port %d\n", conn,
73                ntohs ( local_port ) );
74
75         return 0;
76 }
77
78 /**
79  * Close a UDP connection
80  *
81  * @v conn              UDP connection
82  */
83 void udp_close ( struct udp_connection *conn ) {
84         list_del ( &conn->list );
85         DBGC ( conn, "UDP %p closed\n", conn );
86 }
87
88 /**
89  * User request to send data via a UDP connection
90  *
91  * @v conn              UDP connection
92  *
93  * This function allocates buffer space and invokes the function's senddata()
94  * callback. The callback may use the buffer space
95  */
96 int udp_senddata ( struct udp_connection *conn ) {
97         int rc;
98
99         conn->tx_pkb = alloc_pkb ( UDP_MAX_TXPKB );
100         if ( conn->tx_pkb == NULL ) {
101                 DBGC ( conn, "UDP %p cannot allocate buffer of length %d\n",
102                        conn, UDP_MAX_TXPKB );
103                 return -ENOMEM;
104         }
105         pkb_reserve ( conn->tx_pkb, UDP_MAX_HLEN );
106         rc = conn->udp_op->senddata ( conn, conn->tx_pkb->data, 
107                                       pkb_tailroom ( conn->tx_pkb ) );
108         if ( conn->tx_pkb )
109                 free_pkb ( conn->tx_pkb );
110         return rc;
111 }
112                 
113 /**
114  * Transmit data via a UDP connection to a specified address
115  *
116  * @v conn              UDP connection
117  * @v peer              Destination address
118  * @v data              Data to send
119  * @v len               Length of data
120  * @ret rc              Return status code
121  *
122  * This function fills up the UDP headers and sends the data.  It may
123  * be called only from within the context of an application's
124  * senddata() method; if the application wishes to send data it must
125  * call udp_senddata() and wait for its senddata() method to be
126  * called.
127  */
128 int udp_sendto ( struct udp_connection *conn, struct sockaddr_tcpip *peer,
129                  const void *data, size_t len ) {
130         struct udp_header *udphdr;
131         struct pk_buff *pkb;
132
133         /* Take ownership of packet buffer back from the
134          * udp_connection structure.
135          */
136         pkb = conn->tx_pkb;
137         conn->tx_pkb = NULL;
138
139         /* Avoid overflowing TX buffer */
140         if ( len > pkb_tailroom ( pkb ) )
141                 len = pkb_tailroom ( pkb );
142
143         /* Copy payload */
144         memmove ( pkb_put ( pkb, len ), data, len );
145
146         /*
147          * Add the UDP header
148          *
149          * Covert all 16- and 32- bit integers into network btye order before
150          * sending it over the network
151          */
152         udphdr = pkb_push ( pkb, sizeof ( *udphdr ) );
153         udphdr->dest_port = peer->st_port;
154         udphdr->source_port = conn->local_port;
155         udphdr->len = htons ( pkb_len ( pkb ) );
156         udphdr->chksum = 0;
157         udphdr->chksum = tcpip_chksum ( udphdr, sizeof ( *udphdr ) + len );
158
159         /* Dump debugging information */
160         DBGC ( conn, "UDP %p TX %d->%d len %zd\n", conn,
161                ntohs ( udphdr->source_port ), ntohs ( udphdr->dest_port ),
162                ntohs ( udphdr->len ) );
163
164         /* Send it to the next layer for processing */
165         return tcpip_tx ( pkb, &udp_protocol, peer, &udphdr->chksum );
166 }
167
168 /**
169  * Transmit data via a UDP connection
170  *
171  * @v conn              UDP connection
172  * @v data              Data to send
173  * @v len               Length of data
174  * @ret rc              Return status code
175  *
176  * This function fills up the UDP headers and sends the data.  It may
177  * be called only from within the context of an application's
178  * senddata() method; if the application wishes to send data it must
179  * call udp_senddata() and wait for its senddata() method to be
180  * called.
181  */
182 int udp_send ( struct udp_connection *conn, const void *data, size_t len ) {
183         return udp_sendto ( conn, &conn->peer, data, len );
184 }
185
186 /**
187  * Identify UDP connection by local port number
188  *
189  * @v local_port        Local port (in network-endian order)
190  * @ret conn            TCP connection, or NULL
191  */
192 static struct udp_connection * udp_demux ( uint16_t local_port ) {
193         struct udp_connection *conn;
194
195         list_for_each_entry ( conn, &udp_conns, list ) {
196                 if ( ( conn->local_port == local_port ) ||
197                      ( conn->local_port == 0 ) ) {
198                         return conn;
199                 }
200         }
201         return NULL;
202 }
203
204 /**
205  * Process a received packet
206  *
207  * @v pkb               Packet buffer
208  * @v st_src            Partially-filled source address
209  * @v st_dest           Partially-filled destination address
210  * @v pshdr_csum        Pseudo-header checksum
211  * @ret rc              Return status code
212  */
213 static int udp_rx ( struct pk_buff *pkb, struct sockaddr_tcpip *st_src,
214                     struct sockaddr_tcpip *st_dest, uint16_t pshdr_csum ) {
215         struct udp_header *udphdr = pkb->data;
216         struct udp_connection *conn;
217         size_t ulen;
218         uint16_t csum;
219         int rc;
220
221         /* Sanity check packet */
222         if ( pkb_len ( pkb ) < sizeof ( *udphdr ) ) {
223                 DBG ( "UDP packet too short at %d bytes (min %d bytes)\n",
224                       pkb_len ( pkb ), sizeof ( *udphdr ) );
225                 
226                 rc = -EINVAL;
227                 goto done;
228         }
229         ulen = ntohs ( udphdr->len );
230         if ( ulen < sizeof ( *udphdr ) ) {
231                 DBG ( "UDP length too short at %d bytes "
232                       "(header is %d bytes)\n", ulen, sizeof ( *udphdr ) );
233                 rc = -EINVAL;
234                 goto done;
235         }
236         if ( ulen > pkb_len ( pkb ) ) {
237                 DBG ( "UDP length too long at %d bytes (packet is %d bytes)\n",
238                       ulen, pkb_len ( pkb ) );
239                 rc = -EINVAL;
240                 goto done;
241         }
242         if ( udphdr->chksum ) {
243                 csum = tcpip_continue_chksum ( pshdr_csum, pkb->data, ulen );
244                 if ( csum != 0 ) {
245                         DBG ( "UDP checksum incorrect (is %04x including "
246                               "checksum field, should be 0000)\n", csum );
247                         rc = -EINVAL;
248                         goto done;
249                 }
250         }
251
252         /* Parse parameters from header and strip header */
253         st_src->st_port = udphdr->source_port;
254         st_dest->st_port = udphdr->dest_port;
255         conn = udp_demux ( udphdr->dest_port );
256         pkb_unput ( pkb, ( pkb_len ( pkb ) - ulen ) );
257         pkb_pull ( pkb, sizeof ( *udphdr ) );
258
259         /* Dump debugging information */
260         DBGC ( conn, "UDP %p RX %d<-%d len %zd\n", conn,
261                ntohs ( udphdr->dest_port ), ntohs ( udphdr->source_port ),
262                ulen );
263
264         /* Ignore if no matching connection found */
265         if ( ! conn ) {
266                 DBG ( "No UDP connection listening on port %d\n",
267                       ntohs ( udphdr->dest_port ) );
268                 rc = -ENOTCONN;
269                 goto done;
270         }
271
272         /* Pass data to application */
273         rc = conn->udp_op->newdata ( conn, pkb->data, pkb_len ( pkb ),
274                                      st_src, st_dest );
275
276  done:
277         free_pkb ( pkb );
278         return rc;
279 }
280
281 struct tcpip_protocol udp_protocol __tcpip_protocol = {
282         .name = "UDP",
283         .rx = udp_rx,
284         .tcpip_proto = IP_UDP,
285 };