Added features that will be required for PXE UDP support.
[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  * Bind UDP connection to all local ports
43  *
44  * @v conn              UDP connection
45  *
46  * A promiscuous UDP connection will receive packets with any
47  * destination UDP port.  This is required in order to support the PXE
48  * UDP API.
49  *
50  * If the promiscuous connection is not the only UDP connection, the
51  * behaviour is undefined.
52  */
53 void udp_bind_promisc ( struct udp_connection *conn ) {
54         conn->local_port = 0;
55 }
56
57 /**
58  * Connect UDP connection to remote host and port
59  *
60  * @v conn              UDP connection
61  * @v peer              Destination socket address
62  *
63  * This function stores the socket address within the connection
64  */
65 void udp_connect ( struct udp_connection *conn, struct sockaddr_tcpip *peer ) {
66         memcpy ( &conn->peer, peer, sizeof ( conn->peer ) );
67 }
68
69 /**
70  * Open a local port
71  *
72  * @v conn              UDP connection
73  * @v local_port        Local port, in network byte order, or zero
74  * @ret rc              Return status code
75  *
76  * Opens the UDP connection and binds to a local port.  If no local
77  * port is specified, the first available port will be used.
78  */
79 int udp_open ( struct udp_connection *conn, uint16_t local_port ) {
80         static uint16_t try_port = 1024;
81         int rc;
82
83         /* If no port specified, find the first available port */
84         if ( ! local_port ) {
85                 for ( ; try_port ; try_port++ ) {
86                         if ( try_port < 1024 )
87                                 continue;
88                         if ( udp_open ( conn, htons ( try_port ) ) == 0 )
89                                 return 0;
90                 }
91                 return -EADDRINUSE;
92         }
93
94         /* Attempt bind to local port */
95         if ( ( rc = udp_bind ( conn, local_port ) ) != 0 )
96                 return rc;
97
98         /* Add to UDP connection list */
99         list_add ( &conn->list, &udp_conns );
100         DBG ( "UDP opened %p on port %d\n", conn, ntohs ( local_port ) );
101
102         return 0;
103 }
104
105 /**
106  * Close a UDP connection
107  *
108  * @v conn              UDP connection
109  */
110 void udp_close ( struct udp_connection *conn ) {
111         list_del ( &conn->list );
112         DBG ( "UDP closed %p\n", conn );
113 }
114
115 /**
116  * User request to send data via a UDP connection
117  *
118  * @v conn              UDP connection
119  *
120  * This function allocates buffer space and invokes the function's senddata()
121  * callback. The callback may use the buffer space
122  */
123 int udp_senddata ( struct udp_connection *conn ) {
124         conn->tx_pkb = alloc_pkb ( UDP_MAX_TXPKB );
125         if ( conn->tx_pkb == NULL ) {
126                 DBG ( "UDP %p cannot allocate packet buffer of length %d\n",
127                       conn, UDP_MAX_TXPKB );
128                 return -ENOMEM;
129         }
130         pkb_reserve ( conn->tx_pkb, UDP_MAX_HLEN );
131         conn->udp_op->senddata ( conn, conn->tx_pkb->data, 
132                                  pkb_available ( conn->tx_pkb ) );
133         return 0;
134 }
135                 
136 /**
137  * Transmit data via a UDP connection to a specified address
138  *
139  * @v conn              UDP connection
140  * @v peer              Destination address
141  * @v data              Data to send
142  * @v len               Length of data
143  * @ret rc              Return status code
144  *
145  * This function fills up the UDP headers and sends the data.  It may
146  * be called only from within the context of an application's
147  * senddata() method; if the application wishes to send data it must
148  * call udp_senddata() and wait for its senddata() method to be
149  * called.
150  */
151 int udp_sendto ( struct udp_connection *conn, struct sockaddr_tcpip *peer,
152                  const void *data, size_t len ) {
153         struct udp_header *udphdr;
154
155         /* Avoid overflowing TX buffer */
156         if ( len > pkb_available ( conn->tx_pkb ) )
157                 len = pkb_available ( conn->tx_pkb );
158
159         /* Copy payload */
160         memmove ( pkb_put ( conn->tx_pkb, len ), data, len );
161
162         /*
163          * Add the UDP header
164          *
165          * Covert all 16- and 32- bit integers into network btye order before
166          * sending it over the network
167          */
168         udphdr = pkb_push ( conn->tx_pkb, sizeof ( *udphdr ) );
169         udphdr->dest_port = peer->st_port;
170         udphdr->source_port = conn->local_port;
171         udphdr->len = htons ( pkb_len ( conn->tx_pkb ) );
172         udphdr->chksum = 0;
173         udphdr->chksum = tcpip_chksum ( udphdr, sizeof ( *udphdr ) + len );
174
175         /* Dump debugging information */
176         DBG ( "UDP %p transmitting %p+%#zx len %#x src %d dest %d "
177               "chksum %#04x\n", conn, conn->tx_pkb->data,
178               pkb_len ( conn->tx_pkb ), ntohs ( udphdr->len ),
179               ntohs ( udphdr->source_port ), ntohs ( udphdr->dest_port ),
180               ntohs ( udphdr->chksum ) );
181
182         /* Send it to the next layer for processing */
183         return tcpip_tx ( conn->tx_pkb, &udp_protocol, peer );
184 }
185
186 /**
187  * Transmit data via a UDP connection
188  *
189  * @v conn              UDP connection
190  * @v data              Data to send
191  * @v len               Length of data
192  * @ret rc              Return status code
193  *
194  * This function fills up the UDP headers and sends the data.  It may
195  * be called only from within the context of an application's
196  * senddata() method; if the application wishes to send data it must
197  * call udp_senddata() and wait for its senddata() method to be
198  * called.
199  */
200 int udp_send ( struct udp_connection *conn, const void *data, size_t len ) {
201         return udp_sendto ( conn, &conn->peer, data, len );
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  * @ret rc              Return status code
211  */
212 static int udp_rx ( struct pk_buff *pkb, struct sockaddr_tcpip *st_src,
213                     struct sockaddr_tcpip *st_dest ) {
214         struct udp_header *udphdr = pkb->data;
215         struct udp_connection *conn;
216         unsigned int ulen;
217         uint16_t chksum;
218
219         /* Sanity check */
220         if ( pkb_len ( pkb ) < sizeof ( *udphdr ) ) {
221                 DBG ( "UDP received underlength packet %p+%#zx\n",
222                       pkb->data, pkb_len ( pkb ) );
223                 return -EINVAL;
224         }
225
226         /* Dump debugging information */
227         DBG ( "UDP received %p+%#zx len %#x src %d dest %d chksum %#04x\n",
228               pkb->data, pkb_len ( pkb ), ntohs ( udphdr->len ),
229               ntohs ( udphdr->source_port ), ntohs ( udphdr->dest_port ),
230               ntohs ( udphdr->chksum ) );
231
232         /* Check length and trim any excess */
233         ulen = ntohs ( udphdr->len );
234         if ( ulen > pkb_len ( pkb ) ) {
235                 DBG ( "UDP received truncated packet %p+%#zx\n",
236                       pkb->data, pkb_len ( pkb ) );
237                 return -EINVAL;
238         }
239         pkb_unput ( pkb, ( pkb_len ( pkb ) - ulen ) );
240
241         /* Verify the checksum */
242 #warning "Don't we need to take the pseudo-header into account here?"
243 #if 0
244         chksum = tcpip_chksum ( pkb->data, pkb_len ( pkb ) );
245         if ( chksum != 0xffff ) {
246                 DBG ( "Bad checksum %#x\n", chksum );
247                 return -EINVAL;
248         }
249 #endif
250
251         /* Complete the socket addresses */
252         st_src->st_port = udphdr->source_port;
253         st_dest->st_port = udphdr->dest_port;
254
255         /* Demux the connection */
256         list_for_each_entry ( conn, &udp_conns, list ) {
257                 if ( conn->local_port &&
258                      ( conn->local_port != udphdr->dest_port ) ) {
259                         /* Bound to local port and local port doesn't match */
260                         continue;
261                 }
262                 if ( conn->peer.st_family &&
263                      ( memcmp ( &conn->peer, st_src,
264                                 sizeof ( conn->peer ) ) != 0 ) ) {
265                         /* Connected to remote port and remote port
266                          * doesn't match
267                          */
268                         continue;
269                 }
270                 
271                 /* Strip off the UDP header */
272                 pkb_pull ( pkb, sizeof ( *udphdr ) );
273
274                 DBG ( "UDP delivering to %p\n", conn );
275                 
276                 /* Call the application's callback */
277                 return conn->udp_op->newdata ( conn, pkb->data, pkb_len( pkb ),
278                                                st_src, st_dest );
279         }
280
281         DBG ( "No UDP connection listening on port %d\n",
282               ntohs ( udphdr->dest_port ) );
283         return 0;
284 }
285
286 struct tcpip_protocol udp_protocol  = {
287         .name = "UDP",
288         .rx = udp_rx,
289         .tcpip_proto = IP_UDP,
290         .csum_offset = 6,
291 };
292
293 TCPIP_PROTOCOL ( udp_protocol );