/** * Deliver datagram as raw data * * @v intf Data transfer interface * @v data Data * @v len Length of data * @v meta Data transfer metadata * @ret rc Return status code */ int xfer_deliver_raw_meta ( struct interface *intf, const void *data, size_t len, struct xfer_metadata *meta ) { struct io_buffer *iobuf; iobuf = xfer_alloc_iob ( intf, len ); if ( ! iobuf ) return -ENOMEM; memcpy ( iob_put ( iobuf, len ), data, len ); return xfer_deliver ( intf, iobuf, meta ); }
/** * Seek to position * * @v intf Data transfer interface * @v offset Offset to new position * @ret rc Return status code */ int xfer_seek ( struct interface *intf, off_t offset ) { struct io_buffer *iobuf; struct xfer_metadata meta = { .flags = XFER_FL_ABS_OFFSET, .offset = offset, }; DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " seek to %ld\n", INTF_DBG ( intf ), offset ); /* Allocate and send a zero-length data buffer */ iobuf = xfer_alloc_iob ( intf, 0 ); if ( ! iobuf ) return -ENOMEM; return xfer_deliver ( intf, iobuf, &meta ); }
/** * UDP WRITE * * @v pxenv_udp_write Pointer to a struct s_PXENV_UDP_WRITE * @v s_PXENV_UDP_WRITE::ip Destination IP address * @v s_PXENV_UDP_WRITE::gw Relay agent IP address, or 0.0.0.0 * @v s_PXENV_UDP_WRITE::src_port Source UDP port, or 0 * @v s_PXENV_UDP_WRITE::dst_port Destination UDP port * @v s_PXENV_UDP_WRITE::buffer_size Length of the UDP payload * @v s_PXENV_UDP_WRITE::buffer Address of the UDP payload * @ret #PXENV_EXIT_SUCCESS Packet was transmitted successfully * @ret #PXENV_EXIT_FAILURE Packet could not be transmitted * @ret s_PXENV_UDP_WRITE::Status PXE status code * @err #PXENV_STATUS_UDP_CLOSED UDP connection is not open * @err #PXENV_STATUS_UNDI_TRANSMIT_ERROR Could not transmit packet * * Transmits a single UDP packet. A valid IP and UDP header will be * prepended to the payload in s_PXENV_UDP_WRITE::buffer; the buffer * should not contain precomputed IP and UDP headers, nor should it * contain space allocated for these headers. The first byte of the * buffer will be transmitted as the first byte following the UDP * header. * * If s_PXENV_UDP_WRITE::gw is 0.0.0.0, normal IP routing will take * place. See the relevant @ref pxe_routing "implementation note" for * more details. * * If s_PXENV_UDP_WRITE::src_port is 0, port 2069 will be used. * * You must have opened a UDP connection with pxenv_udp_open() before * calling pxenv_udp_write(). * * On x86, you must set the s_PXE::StatusCallout field to a nonzero * value before calling this function in protected mode. You cannot * call this function with a 32-bit stack segment. (See the relevant * @ref pxe_x86_pmode16 "implementation note" for more details.) * * @note Etherboot currently ignores the s_PXENV_UDP_WRITE::gw * parameter. * */ PXENV_EXIT_t pxenv_udp_write ( struct s_PXENV_UDP_WRITE *pxenv_udp_write ) { struct sockaddr_in dest; struct xfer_metadata meta = { .src = ( struct sockaddr * ) &pxe_udp.local, .dest = ( struct sockaddr * ) &dest, .netdev = pxe_netdev, }; size_t len; struct io_buffer *iobuf; userptr_t buffer; int rc; DBG ( "PXENV_UDP_WRITE" ); /* Construct destination socket address */ memset ( &dest, 0, sizeof ( dest ) ); dest.sin_family = AF_INET; dest.sin_addr.s_addr = pxenv_udp_write->ip; dest.sin_port = pxenv_udp_write->dst_port; /* Set local (source) port. PXE spec says source port is 2069 * if not specified. Really, this ought to be set at UDP open * time but hey, we didn't design this API. */ pxe_udp.local.sin_port = pxenv_udp_write->src_port; if ( ! pxe_udp.local.sin_port ) pxe_udp.local.sin_port = htons ( 2069 ); /* FIXME: we ignore the gateway specified, since we're * confident of being able to do our own routing. We should * probably allow for multiple gateways. */ /* Allocate and fill data buffer */ len = pxenv_udp_write->buffer_size; iobuf = xfer_alloc_iob ( &pxe_udp.xfer, len ); if ( ! iobuf ) { DBG ( " out of memory\n" ); pxenv_udp_write->Status = PXENV_STATUS_OUT_OF_RESOURCES; return PXENV_EXIT_FAILURE; } buffer = real_to_user ( pxenv_udp_write->buffer.segment, pxenv_udp_write->buffer.offset ); copy_from_user ( iob_put ( iobuf, len ), buffer, 0, len ); DBG ( " %04x:%04x+%x %d->%s:%d\n", pxenv_udp_write->buffer.segment, pxenv_udp_write->buffer.offset, pxenv_udp_write->buffer_size, ntohs ( pxenv_udp_write->src_port ), inet_ntoa ( dest.sin_addr ), ntohs ( pxenv_udp_write->dst_port ) ); /* Transmit packet */ if ( ( rc = xfer_deliver ( &pxe_udp.xfer, iobuf, &meta ) ) != 0 ) { DBG ( "PXENV_UDP_WRITE could not transmit: %s\n", strerror ( rc ) ); pxenv_udp_write->Status = PXENV_STATUS ( rc ); return PXENV_EXIT_FAILURE; } pxenv_udp_write->Status = PXENV_STATUS_SUCCESS; return PXENV_EXIT_SUCCESS; } /** * UDP READ * * @v pxenv_udp_read Pointer to a struct s_PXENV_UDP_READ * @v s_PXENV_UDP_READ::dest_ip Destination IP address, or 0.0.0.0 * @v s_PXENV_UDP_READ::d_port Destination UDP port, or 0 * @v s_PXENV_UDP_READ::buffer_size Size of the UDP payload buffer * @v s_PXENV_UDP_READ::buffer Address of the UDP payload buffer * @ret #PXENV_EXIT_SUCCESS A packet has been received * @ret #PXENV_EXIT_FAILURE No packet has been received * @ret s_PXENV_UDP_READ::Status PXE status code * @ret s_PXENV_UDP_READ::src_ip Source IP address * @ret s_PXENV_UDP_READ::dest_ip Destination IP address * @ret s_PXENV_UDP_READ::s_port Source UDP port * @ret s_PXENV_UDP_READ::d_port Destination UDP port * @ret s_PXENV_UDP_READ::buffer_size Length of UDP payload * @err #PXENV_STATUS_UDP_CLOSED UDP connection is not open * @err #PXENV_STATUS_FAILURE No packet was ready to read * * Receive a single UDP packet. This is a non-blocking call; if no * packet is ready to read, the call will return instantly with * s_PXENV_UDP_READ::Status==PXENV_STATUS_FAILURE. * * If s_PXENV_UDP_READ::dest_ip is 0.0.0.0, UDP packets addressed to * any IP address will be accepted and may be returned to the caller. * * If s_PXENV_UDP_READ::d_port is 0, UDP packets addressed to any UDP * port will be accepted and may be returned to the caller. * * You must have opened a UDP connection with pxenv_udp_open() before * calling pxenv_udp_read(). * * On x86, you must set the s_PXE::StatusCallout field to a nonzero * value before calling this function in protected mode. You cannot * call this function with a 32-bit stack segment. (See the relevant * @ref pxe_x86_pmode16 "implementation note" for more details.) * * @note The PXE specification (version 2.1) does not state that we * should fill in s_PXENV_UDP_READ::dest_ip and * s_PXENV_UDP_READ::d_port, but Microsoft Windows' NTLDR program * expects us to do so, and will fail if we don't. * */ PXENV_EXIT_t pxenv_udp_read ( struct s_PXENV_UDP_READ *pxenv_udp_read ) { struct in_addr dest_ip_wanted = { .s_addr = pxenv_udp_read->dest_ip }; struct in_addr dest_ip; uint16_t d_port_wanted = pxenv_udp_read->d_port; uint16_t d_port; /* Try receiving a packet */ pxe_udp.pxenv_udp_read = pxenv_udp_read; step(); if ( pxe_udp.pxenv_udp_read ) { /* No packet received */ DBG2 ( "PXENV_UDP_READ\n" ); pxe_udp.pxenv_udp_read = NULL; goto no_packet; } dest_ip.s_addr = pxenv_udp_read->dest_ip; d_port = pxenv_udp_read->d_port; DBG ( "PXENV_UDP_READ" ); /* Filter on destination address and/or port */ if ( dest_ip_wanted.s_addr && ( dest_ip_wanted.s_addr != dest_ip.s_addr ) ) { DBG ( " wrong IP %s", inet_ntoa ( dest_ip ) ); DBG ( " (wanted %s)\n", inet_ntoa ( dest_ip_wanted ) ); goto no_packet; } if ( d_port_wanted && ( d_port_wanted != d_port ) ) { DBG ( " wrong port %d", htons ( d_port ) ); DBG ( " (wanted %d)\n", htons ( d_port_wanted ) ); goto no_packet; } DBG ( " %04x:%04x+%x %s:", pxenv_udp_read->buffer.segment, pxenv_udp_read->buffer.offset, pxenv_udp_read->buffer_size, inet_ntoa ( *( ( struct in_addr * ) &pxenv_udp_read->src_ip ) )); DBG ( "%d<-%s:%d\n", ntohs ( pxenv_udp_read->s_port ), inet_ntoa ( *( ( struct in_addr * ) &pxenv_udp_read->dest_ip ) ), ntohs ( pxenv_udp_read->d_port ) ); pxenv_udp_read->Status = PXENV_STATUS_SUCCESS; return PXENV_EXIT_SUCCESS; no_packet: pxenv_udp_read->Status = PXENV_STATUS_FAILURE; return PXENV_EXIT_FAILURE; }
/** * Deliver datagram as I/O buffer without metadata * * @v intf Data transfer interface * @v iobuf Datagram I/O buffer * @ret rc Return status code */ int xfer_deliver_iob ( struct interface *intf, struct io_buffer *iobuf ) { return xfer_deliver ( intf, iobuf, &dummy_metadata ); }