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, NULL, &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 };