Added fragment reassembly code
[people/xl0/gpxe.git] / src / net / udp.c
1 #include <stdint.h>
2 #include <string.h>
3 #include <assert.h>
4 #include <byteswap.h>
5 #include <latch.h>
6 #include <errno.h>
7 #include <gpxe/in.h>
8 #include <gpxe/ip.h>
9 #include <gpxe/ip6.h>
10 #include <gpxe/udp.h>
11 #include <gpxe/init.h>
12 #include <gpxe/pkbuff.h>
13 #include <gpxe/netdevice.h>
14 #include <gpxe/tcpip_if.h>
15
16 /** @file
17  *
18  * UDP protocol
19  */
20
21 static inline void copy_sockaddr ( struct sockaddr *source, struct sockaddr *dest ) {
22         memcpy ( dest, source, sizeof ( *dest ) );
23 }
24
25 static inline uint16_t * dest_port ( struct sockaddr *sock ) {
26         switch ( sock->sa_family ) {
27         case AF_INET:
28                 return &sock->sin.sin_port;
29         case AF_INET6:
30                 return &sock->sin6.sin6_port;
31         }
32         return NULL;
33 }
34
35 /**
36  * Dump the UDP header
37  *
38  * @v udphdr    UDP header
39  */
40 void udp_dump ( struct udp_header *udphdr ) {
41
42         /* Print UDP header for debugging */
43         DBG ( "UDP header at %#x + %d\n", udphdr, sizeof ( *udphdr ) );
44         DBG ( "\tSource Port = %d\n", ntohs ( udphdr->source_port ) );
45         DBG ( "\tDestination Port = %d\n", ntohs ( udphdr->dest_port ) );
46         DBG ( "\tLength = %d\n", ntohs ( udphdr->len ) );
47         DBG ( "\tChecksum = %x\n", ntohs ( udphdr->chksum ) );
48         DBG ( "\tChecksum located at %#x\n", &udphdr->chksum );
49 }
50
51 /**
52  * Open a UDP connection
53  *
54  * @v conn      UDP connection
55  * @v peer      Destination socket address
56  *
57  * This function stores the socket address within the connection
58  */
59 void udp_connect ( struct udp_connection *conn, struct sockaddr *peer ) {
60         copy_sockaddr ( peer, &conn->sin );
61
62         /* Not sure if this should add the connection to udp_conns; If it does,
63          * uncomment the following code
64          */
65 //      list_add ( &conn->list, &udp_conns );
66 }
67
68 /**
69  * Initialize a UDP connection
70  *
71  * @v conn      UDP connection
72  * @v udp_op    UDP operations
73  */
74 void udp_init ( struct udp_connection *conn, struct udp_operations *udp_op ) {
75         conn->local_port = 0;
76         conn->tx_pkb = NULL;
77         if ( udp_op != NULL ) {
78                 conn->udp_op = udp_op;
79         }
80 }
81
82 /**
83  * Allocate space to the UDP buffer
84  *
85  * @v conn      UDP connection
86  * @v len       Length to allocate
87  * @ret rc      Status
88  *
89  * Allocate "len" amount of space in the transmit buffer
90  */
91 int udp_buf_alloc ( struct udp_connection *conn, size_t len ) {
92         if ( conn->tx_pkb != NULL ) {
93                 free_pkb ( conn->tx_pkb );
94                 conn->tx_pkb = NULL;
95         }
96         conn->tx_pkb = alloc_pkb ( len < UDP_MIN_TXPKB ? UDP_MIN_TXPKB : len );
97         return !conn ? -ENOMEM : 0;
98 }
99
100 /**
101  * Send data via a UDP connection
102  *
103  * @v conn      UDP connection
104  * @v data      Data to send
105  * @v len       Length of data
106  *
107  * This function fills up the UDP headers and sends the data. Discover the
108  * network protocol through the sa_family field in the destination socket
109  * address.
110  */
111 int udp_send ( struct udp_connection *conn, const void *data, size_t len ) {
112         struct udp_header *udphdr;              /* UDP header */
113         struct sockaddr *sock = &conn->sin;     /* Destination sockaddr */
114         uint16_t *dest;
115         int rc;
116
117         /* Copy data into packet buffer, if necessary */
118         if ( data != conn->tx_pkb->data ) {
119                 /* Allocate space for data and lower layer headers */
120                 if ( ( rc = udp_buf_alloc ( conn, len + UDP_MAX_HLEN ) ) != 0 ) {
121                         DBG ( "Error allocating buffer" );
122                         return rc;
123                 }
124
125                 /* Reserve space for the headers and copy contents */
126                 pkb_reserve ( conn->tx_pkb, UDP_MAX_HLEN );
127                 memcpy ( pkb_put ( conn->tx_pkb, len ), data, len );
128         }
129
130         /*
131          * Add the UDP header
132          *
133          * Covert all 16- and 32- bit integers into network btye order before
134          * sending it over the network
135          */
136         udphdr = pkb_push ( conn->tx_pkb, sizeof ( *udphdr ) );
137         if ( (dest = dest_port ( sock ) ) == NULL ) {
138                 DBG ( "Network family %d not supported\n", sock->sa_family );
139                 return -EAFNOSUPPORT;
140         }
141         udphdr->dest_port = *dest;
142         udphdr->source_port = conn->local_port;
143         udphdr->len = htons ( pkb_len ( conn->tx_pkb ) );
144         udphdr->chksum = htons ( calc_chksum ( udphdr, sizeof ( *udphdr ) ) );
145
146         udp_dump ( udphdr );
147
148         /* Send it to the next layer for processing */
149         return trans_tx ( conn->tx_pkb, &udp_protocol, sock );
150 }
151
152 /**
153  * Send data to a specified address
154  *
155  * @v conn      UDP connection
156  * @v peer      Destination address
157  * @v data      Data to send
158  * @v len       Length of data
159  */
160 int udp_sendto ( struct udp_connection *conn, struct sockaddr *peer,
161                  const void *data, size_t len ) {
162         struct sockaddr tempsock;
163         copy_sockaddr ( &conn->sin, &tempsock );
164         copy_sockaddr ( peer, &conn->sin );
165         int rc = udp_send ( conn, data, len );
166         copy_sockaddr ( &tempsock, &conn->sin );
167         return rc;
168 }
169
170 /**
171  * Close a UDP connection
172  *
173  * @v conn      UDP connection
174  */
175 void udp_close ( struct udp_connection *conn ) {
176         list_del ( &conn->list );
177 }
178
179 /**
180  * Open a local port
181  *
182  * @v conn              UDP connection
183  * @v local_port        Local port on which to open connection
184  *
185  * This does not support the 0 port option correctly yet
186  */
187 int udp_open ( struct udp_connection *conn, uint16_t local_port ) {
188         struct udp_connection *connr;
189         uint16_t min_port = 0xffff;
190
191         /* Iterate through udp_conns to see if local_port is available */
192         list_for_each_entry ( connr, &udp_conns, list ) {
193                 if ( connr->local_port == local_port ) {
194                         return -EISCONN;
195                 }
196                 if ( min_port > connr->local_port ) {
197                         min_port = connr->local_port;
198                 }
199         }
200         /* This code is buggy. I will update it soon :) */
201         conn->local_port = local_port == 0 ? min_port > 1024 ? 1024 :
202                                                 min_port + 1 : local_port;
203
204         /* Add the connection to the list of listening connections */
205         list_add ( &conn->list, &udp_conns );
206         return 0;
207 }
208
209 /**
210  * Process a received packet
211  *
212  * @v pkb              Packet buffer
213  * @v src_net_addr      Source network address
214  * @v dest_net_addr     Destination network address
215  */
216 void udp_rx ( struct pk_buff *pkb, struct in_addr *src_net_addr __unused,
217                         struct in_addr *dest_net_addr __unused ) {
218         struct udp_header *udphdr = pkb->data;
219         struct udp_connection *conn;
220         uint16_t ulen;
221         uint16_t chksum;
222
223         udp_dump ( udphdr );
224
225         /* Validate the packet and the UDP length */
226         if ( pkb_len ( pkb ) < sizeof ( *udphdr ) ) {
227                 DBG ( "UDP packet too short (%d bytes)\n",
228                       pkb_len ( pkb ) );
229                 return;
230         }
231
232         ulen = ntohs ( udphdr->len );
233         if ( ulen != pkb_len ( pkb ) ) {
234                 DBG ( "Inconsistent UDP packet length (%d bytes)\n",
235                       pkb_len ( pkb ) );
236                 return;
237         }
238
239         /* Verify the checksum */
240         chksum = calc_chksum ( pkb->data, pkb_len ( pkb ) );
241         if ( chksum != 0xffff ) {
242                 DBG ( "Bad checksum %d\n", chksum );
243                 return;
244         }
245
246         /* Todo: Check if it is a broadcast or multicast address */
247
248         /* Demux the connection */
249         list_for_each_entry ( conn, &udp_conns, list ) {
250                 if ( conn->local_port == ntohs ( udphdr->dest_port ) ) {
251                         goto conn;
252                 }
253         }
254         return;
255
256         conn:
257         /** Strip off the UDP header */
258         pkb_pull ( pkb, sizeof ( *udphdr ) );
259
260         /** Allocate max possible buffer space to the tx buffer */
261         conn->tx_pkb = alloc_pkb ( UDP_MAX_TXPKB );
262         pkb_reserve ( conn->tx_pkb, UDP_MAX_HLEN );
263
264         /** Call the application's callback */
265         conn->udp_op->newdata ( conn, pkb->data, ulen - sizeof ( *udphdr ) );
266 }
267
268 struct tcpip_protocol udp_protocol  = {
269         .name = "UDP",
270         .rx = udp_rx,
271         .trans_proto = IP_UDP,
272         .csum_offset = 6,
273 };
274
275 TCPIP_PROTOCOL ( udp_protocol );