gpxe/src/net/udp.c

   1 #include <stdint.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <assert.h>
   5 #include <byteswap.h>
   6 #include <errno.h>
   7 #include <gpxe/tcpip.h>
   8 #include <gpxe/iobuf.h>
   9 #include <gpxe/xfer.h>
  10 #include <gpxe/open.h>
  11 #include <gpxe/uri.h>
  12 #include <gpxe/udp.h>
  13
  14 /** @file
  15  *
  16  * UDP protocol
  17  */
  18
  19 FILE_LICENCE ( GPL2_OR_LATER );
  20
  21 /**
  22  * A UDP connection
  23  *
  24  */
  25 struct udp_connection {
  26         /** Reference counter */
  27         struct refcnt refcnt;
  28         /** List of UDP connections */
  29         struct list_head list;
  30
  31         /** Data transfer interface */
  32         struct xfer_interface xfer;
  33
  34         /** Local socket address */
  35         struct sockaddr_tcpip local;
  36         /** Remote socket address */
  37         struct sockaddr_tcpip peer;
  38 };
  39
  40 /**
  41  * List of registered UDP connections
  42  */
  43 static LIST_HEAD ( udp_conns );
  44
  45 /* Forward declatations */
  46 static struct xfer_interface_operations udp_xfer_operations;
  47 struct tcpip_protocol udp_protocol;
  48
  49 /**
  50  * Bind UDP connection to local port
  51  *
  52  * @v udp               UDP connection
  53  * @ret rc              Return status code
  54  *
  55  * Opens the UDP connection and binds to the specified local port.  If
  56  * no local port is specified, the first available port will be used.
  57  */
  58 static int udp_bind ( struct udp_connection *udp ) {
  59         struct udp_connection *existing;
  60         static uint16_t try_port = 1023;
  61
  62         /* If no port specified, find the first available port */
  63         if ( ! udp->local.st_port ) {
  64                 while ( try_port ) {
  65                         try_port++;
  66                         if ( try_port < 1024 )
  67                                 continue;
  68                         udp->local.st_port = htons ( try_port );
  69                         if ( udp_bind ( udp ) == 0 )
  70                                 return 0;
  71                 }
  72                 return -EADDRINUSE;
  73         }
  74
  75         /* Attempt bind to local port */
  76         list_for_each_entry ( existing, &udp_conns, list ) {
  77                 if ( existing->local.st_port == udp->local.st_port ) {
  78                         DBGC ( udp, "UDP %p could not bind: port %d in use\n",
  79                                udp, ntohs ( udp->local.st_port ) );
  80                         return -EADDRINUSE;
  81                 }
  82         }
  83
  84         /* Add to UDP connection list */
  85         DBGC ( udp, "UDP %p bound to port %d\n",
  86                udp, ntohs ( udp->local.st_port ) );
  87
  88         return 0;
  89 }
  90
  91 /**
  92  * Open a UDP connection
  93  *
  94  * @v xfer              Data transfer interface
  95  * @v peer              Peer socket address, or NULL
  96  * @v local             Local socket address, or NULL
  97  * @v promisc           Socket is promiscuous
  98  * @ret rc              Return status code
  99  */
 100 static int udp_open_common ( struct xfer_interface *xfer,
 101                              struct sockaddr *peer, struct sockaddr *local,
 102                              int promisc ) {
 103         struct sockaddr_tcpip *st_peer = ( struct sockaddr_tcpip * ) peer;
 104         struct sockaddr_tcpip *st_local = ( struct sockaddr_tcpip * ) local;
 105         struct udp_connection *udp;
 106         int rc;
 107
 108         /* Allocate and initialise structure */
 109         udp = zalloc ( sizeof ( *udp ) );
 110         if ( ! udp )
 111                 return -ENOMEM;
 112         DBGC ( udp, "UDP %p allocated\n", udp );
 113         xfer_init ( &udp->xfer, &udp_xfer_operations, &udp->refcnt );
 114         if ( st_peer )
 115                 memcpy ( &udp->peer, st_peer, sizeof ( udp->peer ) );
 116         if ( st_local )
 117                 memcpy ( &udp->local, st_local, sizeof ( udp->local ) );
 118
 119         /* Bind to local port */
 120         if ( ! promisc ) {
 121                 if ( ( rc = udp_bind ( udp ) ) != 0 )
 122                         goto err;
 123         }
 124
 125         /* Attach parent interface, transfer reference to connection
 126          * list and return
 127          */
 128         xfer_plug_plug ( &udp->xfer, xfer );
 129         list_add ( &udp->list, &udp_conns );
 130         return 0;
 131
 132  err:
 133         ref_put ( &udp->refcnt );
 134         return rc;
 135 }
 136
 137 /**
 138  * Open a UDP connection
 139  *
 140  * @v xfer              Data transfer interface
 141  * @v peer              Peer socket address
 142  * @v local             Local socket address, or NULL
 143  * @ret rc              Return status code
 144  */
 145 int udp_open ( struct xfer_interface *xfer, struct sockaddr *peer,
 146                struct sockaddr *local ) {
 147         return udp_open_common ( xfer, peer, local, 0 );
 148 }
 149
 150 /**
 151  * Open a promiscuous UDP connection
 152  *
 153  * @v xfer              Data transfer interface
 154  * @ret rc              Return status code
 155  *
 156  * Promiscuous UDP connections are required in order to support the
 157  * PXE API.
 158  */
 159 int udp_open_promisc ( struct xfer_interface *xfer ) {
 160         return udp_open_common ( xfer, NULL, NULL, 1 );
 161 }
 162
 163 /**
 164  * Close a UDP connection
 165  *
 166  * @v udp               UDP connection
 167  * @v rc                Reason for close
 168  */
 169 static void udp_close ( struct udp_connection *udp, int rc ) {
 170
 171         /* Close data transfer interface */
 172         xfer_nullify ( &udp->xfer );
 173         xfer_close ( &udp->xfer, rc );
 174
 175         /* Remove from list of connections and drop list's reference */
 176         list_del ( &udp->list );
 177         ref_put ( &udp->refcnt );
 178
 179         DBGC ( udp, "UDP %p closed\n", udp );
 180 }
 181
 182 /**
 183  * Transmit data via a UDP connection to a specified address
 184  *
 185  * @v udp               UDP connection
 186  * @v iobuf             I/O buffer
 187  * @v src               Source address, or NULL to use default
 188  * @v dest              Destination address, or NULL to use default
 189  * @v netdev            Network device, or NULL to use default
 190  * @ret rc              Return status code
 191  */
 192 static int udp_tx ( struct udp_connection *udp, struct io_buffer *iobuf,
 193                     struct sockaddr_tcpip *src, struct sockaddr_tcpip *dest,
 194                     struct net_device *netdev ) {
 195         struct udp_header *udphdr;
 196         size_t len;
 197         int rc;
 198
 199         /* Check we can accommodate the header */
 200         if ( ( rc = iob_ensure_headroom ( iobuf, UDP_MAX_HLEN ) ) != 0 ) {
 201                 free_iob ( iobuf );
 202                 return rc;
 203         }
 204
 205         /* Fill in default values if not explicitly provided */
 206         if ( ! src )
 207                 src = &udp->local;
 208         if ( ! dest )
 209                 dest = &udp->peer;
 210
 211         /* Add the UDP header */
 212         udphdr = iob_push ( iobuf, sizeof ( *udphdr ) );
 213         len = iob_len ( iobuf );
 214         udphdr->dest = dest->st_port;
 215         udphdr->src = src->st_port;
 216         udphdr->len = htons ( len );
 217         udphdr->chksum = 0;
 218         udphdr->chksum = tcpip_chksum ( udphdr, len );
 219
 220         /* Dump debugging information */
 221         DBGC ( udp, "UDP %p TX %d->%d len %d\n", udp,
 222                ntohs ( udphdr->src ), ntohs ( udphdr->dest ),
 223                ntohs ( udphdr->len ) );
 224
 225         /* Send it to the next layer for processing */
 226         if ( ( rc = tcpip_tx ( iobuf, &udp_protocol, src, dest, netdev,
 227                                &udphdr->chksum ) ) != 0 ) {
 228                 DBGC ( udp, "UDP %p could not transmit packet: %s\n",
 229                        udp, strerror ( rc ) );
 230                 return rc;
 231         }
 232
 233         return 0;
 234 }
 235
 236 /**
 237  * Identify UDP connection by local address
 238  *
 239  * @v local             Local address
 240  * @ret udp             UDP connection, or NULL
 241  */
 242 static struct udp_connection * udp_demux ( struct sockaddr_tcpip *local ) {
 243         static const struct sockaddr_tcpip empty_sockaddr = { .pad = { 0, } };
 244         struct udp_connection *udp;
 245
 246         list_for_each_entry ( udp, &udp_conns, list ) {
 247                 if ( ( ( udp->local.st_family == local->st_family ) ||
 248                        ( udp->local.st_family == 0 ) ) &&
 249                      ( ( udp->local.st_port == local->st_port ) ||
 250                        ( udp->local.st_port == 0 ) ) &&
 251                      ( ( memcmp ( udp->local.pad, local->pad,
 252                                   sizeof ( udp->local.pad ) ) == 0 ) ||
 253                        ( memcmp ( udp->local.pad, empty_sockaddr.pad,
 254                                   sizeof ( udp->local.pad ) ) == 0 ) ) ) {
 255                         return udp;
 256                 }
 257         }
 258         return NULL;
 259 }
 260
 261 /**
 262  * Process a received packet
 263  *
 264  * @v iobuf             I/O buffer
 265  * @v st_src            Partially-filled source address
 266  * @v st_dest           Partially-filled destination address
 267  * @v pshdr_csum        Pseudo-header checksum
 268  * @ret rc              Return status code
 269  */
 270 static int udp_rx ( struct io_buffer *iobuf, struct sockaddr_tcpip *st_src,
 271                     struct sockaddr_tcpip *st_dest, uint16_t pshdr_csum ) {
 272         struct udp_header *udphdr = iobuf->data;
 273         struct udp_connection *udp;
 274         struct xfer_metadata meta;
 275         size_t ulen;
 276         unsigned int csum;
 277         int rc = 0;
 278
 279         /* Sanity check packet */
 280         if ( iob_len ( iobuf ) < sizeof ( *udphdr ) ) {
 281                 DBG ( "UDP packet too short at %zd bytes (min %zd bytes)\n",
 282                       iob_len ( iobuf ), sizeof ( *udphdr ) );
 283
 284                 rc = -EINVAL;
 285                 goto done;
 286         }
 287         ulen = ntohs ( udphdr->len );
 288         if ( ulen < sizeof ( *udphdr ) ) {
 289                 DBG ( "UDP length too short at %zd bytes "
 290                       "(header is %zd bytes)\n", ulen, sizeof ( *udphdr ) );
 291                 rc = -EINVAL;
 292                 goto done;
 293         }
 294         if ( ulen > iob_len ( iobuf ) ) {
 295                 DBG ( "UDP length too long at %zd bytes (packet is %zd "
 296                       "bytes)\n", ulen, iob_len ( iobuf ) );
 297                 rc = -EINVAL;
 298                 goto done;
 299         }
 300         if ( udphdr->chksum ) {
 301                 csum = tcpip_continue_chksum ( pshdr_csum, iobuf->data, ulen );
 302                 if ( csum != 0 ) {
 303                         DBG ( "UDP checksum incorrect (is %04x including "
 304                               "checksum field, should be 0000)\n", csum );
 305                         rc = -EINVAL;
 306                         goto done;
 307                 }
 308         }
 309
 310         /* Parse parameters from header and strip header */
 311         st_src->st_port = udphdr->src;
 312         st_dest->st_port = udphdr->dest;
 313         udp = udp_demux ( st_dest );
 314         iob_unput ( iobuf, ( iob_len ( iobuf ) - ulen ) );
 315         iob_pull ( iobuf, sizeof ( *udphdr ) );
 316
 317         /* Dump debugging information */
 318         DBGC ( udp, "UDP %p RX %d<-%d len %zd\n", udp,
 319                ntohs ( udphdr->dest ), ntohs ( udphdr->src ), ulen );
 320
 321         /* Ignore if no matching connection found */
 322         if ( ! udp ) {
 323                 DBG ( "No UDP connection listening on port %d\n",
 324                       ntohs ( udphdr->dest ) );
 325                 rc = -ENOTCONN;
 326                 goto done;
 327         }
 328
 329         /* Pass data to application */
 330         memset ( &meta, 0, sizeof ( meta ) );
 331         meta.src = ( struct sockaddr * ) st_src;
 332         meta.dest = ( struct sockaddr * ) st_dest;
 333         rc = xfer_deliver_iob_meta ( &udp->xfer, iob_disown ( iobuf ), &meta );
 334
 335  done:
 336         free_iob ( iobuf );
 337         return rc;
 338 }
 339
 340 struct tcpip_protocol udp_protocol __tcpip_protocol = {
 341         .name = "UDP",
 342         .rx = udp_rx,
 343         .tcpip_proto = IP_UDP,
 344 };
 345
 346 /***************************************************************************
 347  *
 348  * Data transfer interface
 349  *
 350  ***************************************************************************
 351  */
 352
 353 /**
 354  * Close interface
 355  *
 356  * @v xfer              Data transfer interface
 357  * @v rc                Reason for close
 358  */
 359 static void udp_xfer_close ( struct xfer_interface *xfer, int rc ) {
 360         struct udp_connection *udp =
 361                 container_of ( xfer, struct udp_connection, xfer );
 362
 363         /* Close connection */
 364         udp_close ( udp, rc );
 365 }
 366
 367 /**
 368  * Allocate I/O buffer for UDP
 369  *
 370  * @v xfer              Data transfer interface
 371  * @v len               Payload size
 372  * @ret iobuf           I/O buffer, or NULL
 373  */
 374 static struct io_buffer * udp_alloc_iob ( struct xfer_interface *xfer,
 375                                           size_t len ) {
 376         struct udp_connection *udp =
 377                 container_of ( xfer, struct udp_connection, xfer );
 378         struct io_buffer *iobuf;
 379
 380         iobuf = alloc_iob ( UDP_MAX_HLEN + len );
 381         if ( ! iobuf ) {
 382                 DBGC ( udp, "UDP %p cannot allocate buffer of length %zd\n",
 383                        udp, len );
 384                 return NULL;
 385         }
 386         iob_reserve ( iobuf, UDP_MAX_HLEN );
 387         return iobuf;
 388 }
 389
 390 /**
 391  * Deliver datagram as I/O buffer
 392  *
 393  * @v xfer              Data transfer interface
 394  * @v iobuf             Datagram I/O buffer
 395  * @v meta              Data transfer metadata
 396  * @ret rc              Return status code
 397  */
 398 static int udp_xfer_deliver_iob ( struct xfer_interface *xfer,
 399                                   struct io_buffer *iobuf,
 400                                   struct xfer_metadata *meta ) {
 401         struct udp_connection *udp =
 402                 container_of ( xfer, struct udp_connection, xfer );
 403
 404         /* Transmit data, if possible */
 405         udp_tx ( udp, iobuf, ( ( struct sockaddr_tcpip * ) meta->src ),
 406                  ( ( struct sockaddr_tcpip * ) meta->dest ), meta->netdev );
 407
 408         return 0;
 409 }
 410
 411 /** UDP data transfer interface operations */
 412 static struct xfer_interface_operations udp_xfer_operations = {
 413         .close          = udp_xfer_close,
 414         .vredirect      = ignore_xfer_vredirect,
 415         .window         = unlimited_xfer_window,
 416         .alloc_iob      = udp_alloc_iob,
 417         .deliver_iob    = udp_xfer_deliver_iob,
 418         .deliver_raw    = xfer_deliver_as_iob,
 419 };
 420
 421 /***************************************************************************
 422  *
 423  * Openers
 424  *
 425  ***************************************************************************
 426  */
 427
 428 /** UDP socket opener */
 429 struct socket_opener udp_socket_opener __socket_opener = {
 430         .semantics      = UDP_SOCK_DGRAM,
 431         .family         = AF_INET,
 432         .open           = udp_open,
 433 };
 434
 435 /** Linkage hack */
 436 int udp_sock_dgram = UDP_SOCK_DGRAM;
 437
 438 /**
 439  * Open UDP URI
 440  *
 441  * @v xfer              Data transfer interface
 442  * @v uri               URI
 443  * @ret rc              Return status code
 444  */
 445 static int udp_open_uri ( struct xfer_interface *xfer, struct uri *uri ) {
 446         struct sockaddr_tcpip peer;
 447
 448         /* Sanity check */
 449         if ( ! uri->host )
 450                 return -EINVAL;
 451
 452         memset ( &peer, 0, sizeof ( peer ) );
 453         peer.st_port = htons ( uri_port ( uri, 0 ) );
 454         return xfer_open_named_socket ( xfer, SOCK_DGRAM,
 455                                         ( struct sockaddr * ) &peer,
 456                                         uri->host, NULL );
 457 }
 458
 459 /** UDP URI opener */
 460 struct uri_opener udp_uri_opener __uri_opener = {
 461         .scheme         = "udp",
 462         .open           = udp_open_uri,
 463 };