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