--- /dev/null
+/*
+ * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gpxe/uaccess.h>
+#include <registers.h>
+#include <pxe.h>
+
+/** @file
+ *
+ * PXE API entry point
+ */
+
+/** A function pointer to hold any PXE API call
+ *
+ * Used by pxe_api_call() to avoid large swathes of duplicated code.
+ */
+union pxenv_call {
+ PXENV_EXIT_t ( * any ) ( union u_PXENV_ANY * );
+ PXENV_EXIT_t ( * unknown ) ( struct s_PXENV_UNKNOWN * );
+ PXENV_EXIT_t ( * unload_stack ) ( struct s_PXENV_UNLOAD_STACK * );
+ PXENV_EXIT_t ( * get_cached_info )
+ ( struct s_PXENV_GET_CACHED_INFO * );
+ PXENV_EXIT_t ( * restart_tftp ) ( struct s_PXENV_TFTP_READ_FILE * );
+ PXENV_EXIT_t ( * start_undi ) ( struct s_PXENV_START_UNDI * );
+ PXENV_EXIT_t ( * stop_undi ) ( struct s_PXENV_STOP_UNDI * );
+ PXENV_EXIT_t ( * start_base ) ( struct s_PXENV_START_BASE * );
+ PXENV_EXIT_t ( * stop_base ) ( struct s_PXENV_STOP_BASE * );
+ PXENV_EXIT_t ( * tftp_open ) ( struct s_PXENV_TFTP_OPEN * );
+ PXENV_EXIT_t ( * tftp_close ) ( struct s_PXENV_TFTP_CLOSE * );
+ PXENV_EXIT_t ( * tftp_read ) ( struct s_PXENV_TFTP_READ * );
+ PXENV_EXIT_t ( * tftp_read_file ) ( struct s_PXENV_TFTP_READ_FILE * );
+ PXENV_EXIT_t ( * tftp_get_fsize ) ( struct s_PXENV_TFTP_GET_FSIZE * );
+ PXENV_EXIT_t ( * udp_open ) ( struct s_PXENV_UDP_OPEN * );
+ PXENV_EXIT_t ( * udp_close ) ( struct s_PXENV_UDP_CLOSE * );
+ PXENV_EXIT_t ( * udp_write ) ( struct s_PXENV_UDP_WRITE * );
+ PXENV_EXIT_t ( * udp_read ) ( struct s_PXENV_UDP_READ * );
+ PXENV_EXIT_t ( * undi_startup ) ( struct s_PXENV_UNDI_STARTUP * );
+ PXENV_EXIT_t ( * undi_cleanup ) ( struct s_PXENV_UNDI_CLEANUP * );
+ PXENV_EXIT_t ( * undi_initialize )
+ ( struct s_PXENV_UNDI_INITIALIZE * );
+ PXENV_EXIT_t ( * undi_reset_adapter ) ( struct s_PXENV_UNDI_RESET * );
+ PXENV_EXIT_t ( * undi_shutdown ) ( struct s_PXENV_UNDI_SHUTDOWN * );
+ PXENV_EXIT_t ( * undi_open ) ( struct s_PXENV_UNDI_OPEN * );
+ PXENV_EXIT_t ( * undi_close ) ( struct s_PXENV_UNDI_CLOSE * );
+ PXENV_EXIT_t ( * undi_transmit ) ( struct s_PXENV_UNDI_TRANSMIT * );
+ PXENV_EXIT_t ( * undi_set_mcast_address )
+ ( struct s_PXENV_UNDI_SET_MCAST_ADDRESS * );
+ PXENV_EXIT_t ( * undi_set_station_address )
+ ( struct s_PXENV_UNDI_SET_STATION_ADDRESS * );
+ PXENV_EXIT_t ( * undi_set_packet_filter )
+ ( struct s_PXENV_UNDI_SET_PACKET_FILTER * );
+ PXENV_EXIT_t ( * undi_get_information )
+ ( struct s_PXENV_UNDI_GET_INFORMATION * );
+ PXENV_EXIT_t ( * undi_get_statistics )
+ ( struct s_PXENV_UNDI_GET_STATISTICS * );
+ PXENV_EXIT_t ( * undi_clear_statistics )
+ ( struct s_PXENV_UNDI_CLEAR_STATISTICS * );
+ PXENV_EXIT_t ( * undi_initiate_diags )
+ ( struct s_PXENV_UNDI_INITIATE_DIAGS * );
+ PXENV_EXIT_t ( * undi_force_interrupt )
+ ( struct s_PXENV_UNDI_FORCE_INTERRUPT * );
+ PXENV_EXIT_t ( * undi_get_mcast_address )
+ ( struct s_PXENV_UNDI_GET_MCAST_ADDRESS * );
+ PXENV_EXIT_t ( * undi_get_nic_type )
+ ( struct s_PXENV_UNDI_GET_NIC_TYPE * );
+ PXENV_EXIT_t ( * undi_get_iface_info )
+ ( struct s_PXENV_UNDI_GET_IFACE_INFO * );
+ PXENV_EXIT_t ( * undi_get_state ) ( struct s_PXENV_UNDI_GET_STATE * );
+ PXENV_EXIT_t ( * undi_isr ) ( struct s_PXENV_UNDI_ISR * );
+};
+
+/**
+ * Handle an unknown PXE API call
+ *
+ * @v pxenv_unknown Pointer to a struct s_PXENV_UNKNOWN
+ * @ret #PXENV_EXIT_FAILURE Always
+ * @err #PXENV_STATUS_UNSUPPORTED Always
+ */
+static PXENV_EXIT_t pxenv_unknown ( struct s_PXENV_UNKNOWN *pxenv_unknown ) {
+ pxenv_unknown->Status = PXENV_STATUS_UNSUPPORTED;
+ return PXENV_EXIT_FAILURE;
+}
+
+/**
+ * Dispatch PXE API call
+ *
+ * @v bx PXE opcode
+ * @v es:di Address of PXE parameter block
+ * @ret ax PXE exit code
+ */
+void pxe_api_call ( struct i386_all_regs *ix86 ) {
+ int opcode = ix86->regs.bx;
+ userptr_t parameters = real_to_user ( ix86->segs.es, ix86->regs.di );
+ size_t param_len;
+ union u_PXENV_ANY pxenv_any;
+ union pxenv_call pxenv_call;
+ PXENV_EXIT_t ret;
+
+ switch ( opcode ) {
+ case PXENV_UNLOAD_STACK:
+ pxenv_call.unload_stack = pxenv_unload_stack;
+ param_len = sizeof ( pxenv_any.unload_stack );
+ break;
+ case PXENV_GET_CACHED_INFO:
+ pxenv_call.get_cached_info = pxenv_get_cached_info;
+ param_len = sizeof ( pxenv_any.get_cached_info );
+ break;
+ case PXENV_RESTART_TFTP:
+ pxenv_call.restart_tftp = pxenv_restart_tftp;
+ param_len = sizeof ( pxenv_any.restart_tftp );
+ break;
+ case PXENV_START_UNDI:
+ pxenv_call.start_undi = pxenv_start_undi;
+ param_len = sizeof ( pxenv_any.start_undi );
+ break;
+ case PXENV_STOP_UNDI:
+ pxenv_call.stop_undi = pxenv_stop_undi;
+ param_len = sizeof ( pxenv_any.stop_undi );
+ break;
+ case PXENV_START_BASE:
+ pxenv_call.start_base = pxenv_start_base;
+ param_len = sizeof ( pxenv_any.start_base );
+ break;
+ case PXENV_STOP_BASE:
+ pxenv_call.stop_base = pxenv_stop_base;
+ param_len = sizeof ( pxenv_any.stop_base );
+ break;
+ case PXENV_TFTP_OPEN:
+ pxenv_call.tftp_open = pxenv_tftp_open;
+ param_len = sizeof ( pxenv_any.tftp_open );
+ break;
+ case PXENV_TFTP_CLOSE:
+ pxenv_call.tftp_close = pxenv_tftp_close;
+ param_len = sizeof ( pxenv_any.tftp_close );
+ break;
+ case PXENV_TFTP_READ:
+ pxenv_call.tftp_read = pxenv_tftp_read;
+ param_len = sizeof ( pxenv_any.tftp_read );
+ break;
+ case PXENV_TFTP_READ_FILE:
+ pxenv_call.tftp_read_file = pxenv_tftp_read_file;
+ param_len = sizeof ( pxenv_any.tftp_read_file );
+ break;
+ case PXENV_TFTP_GET_FSIZE:
+ pxenv_call.tftp_get_fsize = pxenv_tftp_get_fsize;
+ param_len = sizeof ( pxenv_any.tftp_get_fsize );
+ break;
+ case PXENV_UDP_OPEN:
+ pxenv_call.udp_open = pxenv_udp_open;
+ param_len = sizeof ( pxenv_any.udp_open );
+ break;
+ case PXENV_UDP_CLOSE:
+ pxenv_call.udp_close = pxenv_udp_close;
+ param_len = sizeof ( pxenv_any.udp_close );
+ break;
+ case PXENV_UDP_WRITE:
+ pxenv_call.udp_write = pxenv_udp_write;
+ param_len = sizeof ( pxenv_any.udp_write );
+ break;
+ case PXENV_UDP_READ:
+ pxenv_call.udp_read = pxenv_udp_read;
+ param_len = sizeof ( pxenv_any.udp_read );
+ break;
+ case PXENV_UNDI_STARTUP:
+ pxenv_call.undi_startup = pxenv_undi_startup;
+ param_len = sizeof ( pxenv_any.undi_startup );
+ break;
+ case PXENV_UNDI_CLEANUP:
+ pxenv_call.undi_cleanup = pxenv_undi_cleanup;
+ param_len = sizeof ( pxenv_any.undi_cleanup );
+ break;
+ case PXENV_UNDI_INITIALIZE:
+ pxenv_call.undi_initialize = pxenv_undi_initialize;
+ param_len = sizeof ( pxenv_any.undi_initialize );
+ break;
+ case PXENV_UNDI_RESET_ADAPTER:
+ pxenv_call.undi_reset_adapter = pxenv_undi_reset_adapter;
+ param_len = sizeof ( pxenv_any.undi_reset_adapter );
+ break;
+ case PXENV_UNDI_SHUTDOWN:
+ pxenv_call.undi_shutdown = pxenv_undi_shutdown;
+ param_len = sizeof ( pxenv_any.undi_shutdown );
+ break;
+ case PXENV_UNDI_OPEN:
+ pxenv_call.undi_open = pxenv_undi_open;
+ param_len = sizeof ( pxenv_any.undi_open );
+ break;
+ case PXENV_UNDI_CLOSE:
+ pxenv_call.undi_close = pxenv_undi_close;
+ param_len = sizeof ( pxenv_any.undi_close );
+ break;
+ case PXENV_UNDI_TRANSMIT:
+ pxenv_call.undi_transmit = pxenv_undi_transmit;
+ param_len = sizeof ( pxenv_any.undi_transmit );
+ break;
+ case PXENV_UNDI_SET_MCAST_ADDRESS:
+ pxenv_call.undi_set_mcast_address =
+ pxenv_undi_set_mcast_address;
+ param_len = sizeof ( pxenv_any.undi_set_mcast_address );
+ break;
+ case PXENV_UNDI_SET_STATION_ADDRESS:
+ pxenv_call.undi_set_station_address =
+ pxenv_undi_set_station_address;
+ param_len = sizeof ( pxenv_any.undi_set_station_address );
+ break;
+ case PXENV_UNDI_SET_PACKET_FILTER:
+ pxenv_call.undi_set_packet_filter =
+ pxenv_undi_set_packet_filter;
+ param_len = sizeof ( pxenv_any.undi_set_packet_filter );
+ break;
+ case PXENV_UNDI_GET_INFORMATION:
+ pxenv_call.undi_get_information = pxenv_undi_get_information;
+ param_len = sizeof ( pxenv_any.undi_get_information );
+ break;
+ case PXENV_UNDI_GET_STATISTICS:
+ pxenv_call.undi_get_statistics = pxenv_undi_get_statistics;
+ param_len = sizeof ( pxenv_any.undi_get_statistics );
+ break;
+ case PXENV_UNDI_CLEAR_STATISTICS:
+ pxenv_call.undi_clear_statistics = pxenv_undi_clear_statistics;
+ param_len = sizeof ( pxenv_any.undi_clear_statistics );
+ break;
+ case PXENV_UNDI_INITIATE_DIAGS:
+ pxenv_call.undi_initiate_diags = pxenv_undi_initiate_diags;
+ param_len = sizeof ( pxenv_any.undi_initiate_diags );
+ break;
+ case PXENV_UNDI_FORCE_INTERRUPT:
+ pxenv_call.undi_force_interrupt = pxenv_undi_force_interrupt;
+ param_len = sizeof ( pxenv_any.undi_force_interrupt );
+ break;
+ case PXENV_UNDI_GET_MCAST_ADDRESS:
+ pxenv_call.undi_get_mcast_address =
+ pxenv_undi_get_mcast_address;
+ param_len = sizeof ( pxenv_any.undi_get_mcast_address );
+ break;
+ case PXENV_UNDI_GET_NIC_TYPE:
+ pxenv_call.undi_get_nic_type = pxenv_undi_get_nic_type;
+ param_len = sizeof ( pxenv_any.undi_get_nic_type );
+ break;
+ case PXENV_UNDI_GET_IFACE_INFO:
+ pxenv_call.undi_get_iface_info = pxenv_undi_get_iface_info;
+ param_len = sizeof ( pxenv_any.undi_get_iface_info );
+ break;
+ case PXENV_UNDI_ISR:
+ pxenv_call.undi_isr = pxenv_undi_isr;
+ param_len = sizeof ( pxenv_any.undi_isr );
+ break;
+ default:
+ DBG ( "PXENV_UNKNOWN_%hx", opcode );
+ pxenv_call.unknown = pxenv_unknown;
+ param_len = sizeof ( pxenv_any.unknown );
+ break;
+ }
+
+ /* Copy parameter block from caller */
+ copy_from_user ( &pxenv_any, parameters, 0, param_len );
+
+ /* Set default status in case child routine fails to do so */
+ pxenv_any.Status = PXENV_STATUS_FAILURE;
+
+ /* Hand off to relevant API routine */
+ DBG ( "[" );
+ ret = pxenv_call.any ( &pxenv_any );
+ if ( pxenv_any.Status != PXENV_STATUS_SUCCESS ) {
+ DBG ( " %02x", pxenv_any.Status );
+ }
+ if ( ret != PXENV_EXIT_SUCCESS ) {
+ DBG ( ret == PXENV_EXIT_FAILURE ? " err" : " ??" );
+ }
+ DBG ( "]" );
+
+ /* Copy modified parameter block back to caller and return */
+ copy_to_user ( parameters, 0, &pxenv_any, param_len );
+ ix86->regs.ax = ret;
+}
#include "dev.h"
#include "pxe.h"
+#if 0
+
/* Global pointer to currently installed PXE stack */
pxe_stack_t *pxe_stack = NULL;
return success;
}
-/* API call dispatcher
- *
- * Status: complete
- */
-PXENV_EXIT_t pxe_api_call ( int opcode, union u_PXENV_ANY *any ) {
- PXENV_EXIT_t ret = PXENV_EXIT_FAILURE;
-
- /* Set default status in case child routine fails to do so */
- any->Status = PXENV_STATUS_FAILURE;
-
- DBG ( "[" );
-
- /* Hand off to relevant API routine */
- switch ( opcode ) {
- case PXENV_START_UNDI:
- ret = pxenv_start_undi ( &any->start_undi );
- break;
- case PXENV_UNDI_STARTUP:
- ret = pxenv_undi_startup ( &any->undi_startup );
- break;
- case PXENV_UNDI_CLEANUP:
- ret = pxenv_undi_cleanup ( &any->undi_cleanup );
- break;
- case PXENV_UNDI_INITIALIZE:
- ret = pxenv_undi_initialize ( &any->undi_initialize );
- break;
- case PXENV_UNDI_RESET_ADAPTER:
- ret = pxenv_undi_reset_adapter ( &any->undi_reset_adapter );
- break;
- case PXENV_UNDI_SHUTDOWN:
- ret = pxenv_undi_shutdown ( &any->undi_shutdown );
- break;
- case PXENV_UNDI_OPEN:
- ret = pxenv_undi_open ( &any->undi_open );
- break;
- case PXENV_UNDI_CLOSE:
- ret = pxenv_undi_close ( &any->undi_close );
- break;
- case PXENV_UNDI_TRANSMIT:
- ret = pxenv_undi_transmit ( &any->undi_transmit );
- break;
- case PXENV_UNDI_SET_MCAST_ADDRESS:
- ret = pxenv_undi_set_mcast_address (
- &any->undi_set_mcast_address );
- break;
- case PXENV_UNDI_SET_STATION_ADDRESS:
- ret = pxenv_undi_set_station_address (
- &any->undi_set_station_address );
- break;
- case PXENV_UNDI_SET_PACKET_FILTER:
- ret = pxenv_undi_set_packet_filter (
- &any->undi_set_packet_filter );
- break;
- case PXENV_UNDI_GET_INFORMATION:
- ret = pxenv_undi_get_information (
- &any->undi_get_information );
- break;
- case PXENV_UNDI_GET_STATISTICS:
- ret = pxenv_undi_get_statistics ( &any->undi_get_statistics );
- break;
- case PXENV_UNDI_CLEAR_STATISTICS:
- ret = pxenv_undi_clear_statistics (
- &any->undi_clear_statistics );
- break;
- case PXENV_UNDI_INITIATE_DIAGS:
- ret = pxenv_undi_initiate_diags ( &any->undi_initiate_diags );
-
- break;
- case PXENV_UNDI_FORCE_INTERRUPT:
- ret = pxenv_undi_force_interrupt (
- &any->undi_force_interrupt );
- break;
- case PXENV_UNDI_GET_MCAST_ADDRESS:
- ret = pxenv_undi_get_mcast_address (
- &any->undi_get_mcast_address );
- break;
- case PXENV_UNDI_GET_NIC_TYPE:
- ret = pxenv_undi_get_nic_type ( &any->undi_get_nic_type );
- break;
- case PXENV_UNDI_GET_IFACE_INFO:
- ret = pxenv_undi_get_iface_info ( &any->undi_get_iface_info );
- break;
- case PXENV_UNDI_ISR:
- ret = pxenv_undi_isr ( &any->undi_isr );
- break;
- case PXENV_STOP_UNDI:
- ret = pxenv_stop_undi ( &any->stop_undi );
- break;
- case PXENV_TFTP_OPEN:
- ret = pxenv_tftp_open ( &any->tftp_open );
- break;
- case PXENV_TFTP_CLOSE:
- ret = pxenv_tftp_close ( &any->tftp_close );
- break;
- case PXENV_TFTP_READ:
- ret = pxenv_tftp_read ( &any->tftp_read );
- break;
- case PXENV_TFTP_READ_FILE:
- ret = pxenv_tftp_read_file ( &any->tftp_read_file );
- break;
- case PXENV_TFTP_GET_FSIZE:
- ret = pxenv_tftp_get_fsize ( &any->tftp_get_fsize );
- break;
- case PXENV_UDP_OPEN:
- ret = pxenv_udp_open ( &any->udp_open );
- break;
- case PXENV_UDP_CLOSE:
- ret = pxenv_udp_close ( &any->udp_close );
- break;
- case PXENV_UDP_READ:
- ret = pxenv_udp_read ( &any->udp_read );
- break;
- case PXENV_UDP_WRITE:
- ret = pxenv_udp_write ( &any->udp_write );
- break;
- case PXENV_UNLOAD_STACK:
- ret = pxenv_unload_stack ( &any->unload_stack );
- break;
- case PXENV_GET_CACHED_INFO:
- ret = pxenv_get_cached_info ( &any->get_cached_info );
- break;
- case PXENV_RESTART_TFTP:
- ret = pxenv_restart_tftp ( &any->restart_tftp );
- break;
- case PXENV_START_BASE:
- ret = pxenv_start_base ( &any->start_base );
- break;
- case PXENV_STOP_BASE:
- ret = pxenv_stop_base ( &any->stop_base );
- break;
-
- default:
- DBG ( "PXENV_UNKNOWN_%hx", opcode );
- any->Status = PXENV_STATUS_UNSUPPORTED;
- ret = PXENV_EXIT_FAILURE;
- break;
- }
-
- if ( any->Status != PXENV_STATUS_SUCCESS ) {
- DBG ( " %hx", any->Status );
- }
- if ( ret != PXENV_EXIT_SUCCESS ) {
- DBG ( ret == PXENV_EXIT_FAILURE ? " err" : " ??" );
- }
- DBG ( "]" );
-
- return ret;
-}
+#endif
*
*/
-#include "pxe.h"
-#include "io.h"
-#include "string.h"
+#include <string.h>
+#include <byteswap.h>
+#include <gpxe/udp.h>
+#include <gpxe/uaccess.h>
+#include <gpxe/process.h>
+#include <pxe.h>
/*
* Copyright (C) 2004 Michael Brown <mbrown@fensystems.co.uk>.
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
+/** A PXE UDP connection */
+struct pxe_udp_connection {
+ /** Etherboot UDP connection */
+ struct udp_connection udp;
+ /** "Connection is open" flag */
+ int open;
+ /** Current pxenv_udp_read() operation, if any */
+ struct s_PXENV_UDP_READ *pxenv_udp_read;
+ /** Current pxenv_udp_write() operation, if any */
+ struct s_PXENV_UDP_WRITE *pxenv_udp_write;
+};
+
+static inline struct pxe_udp_connection *
+udp_to_pxe ( struct udp_connection *conn ) {
+ return container_of ( conn, struct pxe_udp_connection, udp );
+}
+
+/**
+ * Send PXE UDP data
+ *
+ * @v conn UDP connection
+ * @v data Temporary data buffer
+ * @v len Size of temporary data buffer
+ *
+ * Sends the packet belonging to the current pxenv_udp_write()
+ * operation.
+ */
+static void pxe_udp_senddata ( struct udp_connection *conn, void *data,
+ size_t len ) {
+ struct pxe_udp_connection *pxe_udp = udp_to_pxe ( conn );
+ struct s_PXENV_UDP_WRITE *pxenv_udp_write = pxe_udp->pxenv_udp_write;
+ userptr_t buffer;
+
+ /* Transmit packet */
+ buffer = real_to_user ( pxenv_udp_write->buffer.segment,
+ pxenv_udp_write->buffer.offset );
+ if ( len > pxenv_udp_write->buffer_size )
+ len = pxenv_udp_write->buffer_size;
+ copy_from_user ( data, buffer, 0, len );
+ udp_send ( conn, data, len );
+}
+
+/**
+ * Receive PXE UDP data
+ *
+ * @v conn UDP connection
+ * @v data Received data
+ * @v len Length of received data
+ * @v st_src Source address
+ * @v st_dest Destination address
+ *
+ * Receives a packet as part of the current pxenv_udp_read()
+ * operation.
+ */
+static int pxe_udp_newdata ( struct udp_connection *conn, void *data,
+ size_t len, struct sockaddr_tcpip *st_src,
+ struct sockaddr_tcpip *st_dest ) {
+ struct pxe_udp_connection *pxe_udp = udp_to_pxe ( conn );
+ struct s_PXENV_UDP_READ *pxenv_udp_read = pxe_udp->pxenv_udp_read;
+ struct sockaddr_in *sin_src = ( ( struct sockaddr_in * ) st_src );
+ struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
+ userptr_t buffer;
+
+ if ( ! pxenv_udp_read ) {
+ DBG ( "PXE discarded UDP packet\n" );
+ return -ENOBUFS;
+ }
+
+ /* Copy packet to buffer and record length */
+ buffer = real_to_user ( pxenv_udp_read->buffer.segment,
+ pxenv_udp_read->buffer.offset );
+ if ( len > pxenv_udp_read->buffer_size )
+ len = pxenv_udp_read->buffer_size;
+ copy_to_user ( buffer, 0, data, len );
+ pxenv_udp_read->buffer_size = len;
+
+ /* Fill in source/dest information */
+ assert ( sin_src->sin_family == AF_INET );
+ pxenv_udp_read->src_ip = sin_src->sin_addr.s_addr;
+ pxenv_udp_read->s_port = sin_src->sin_port;
+ assert ( sin_dest->sin_family == AF_INET );
+ pxenv_udp_read->dest_ip = sin_dest->sin_addr.s_addr;
+ pxenv_udp_read->d_port = sin_dest->sin_port;
+
+ /* Mark as received */
+ pxe_udp->pxenv_udp_read = NULL;
+
+ return 0;
+}
+
+/** PXE UDP operations */
+static struct udp_operations pxe_udp_operations = {
+ .senddata = pxe_udp_senddata,
+ .newdata = pxe_udp_newdata,
+};
+
+/** The PXE UDP connection */
+static struct pxe_udp_connection pxe_udp = {
+ .udp.udp_op = &pxe_udp_operations,
+};
+
/**
* UDP OPEN
*
- * @v udp_open Pointer to a struct s_PXENV_UDP_OPEN
+ * @v pxenv_udp_open Pointer to a struct s_PXENV_UDP_OPEN
* @v s_PXENV_UDP_OPEN::src_ip IP address of this station, or 0.0.0.0
* @ret #PXENV_EXIT_SUCCESS Always
* @ret s_PXENV_UDP_OPEN::Status PXE status code
- * @err #PXENV_STATUS_UNDI_INVALID_STATE NIC could not be initialised
+ * @err #PXENV_STATUS_UDP_OPEN UDP connection already open
+ * @err #PXENV_STATUS_OUT_OF_RESOURCES Could not open connection
*
* Prepares the PXE stack for communication using pxenv_udp_write()
* and pxenv_udp_read().
* s_PXENV_UDP_OPEN::src_ip is 0.0.0.0, the local station's IP address
* will remain unchanged.)
*
- * You can only have one open UDP connection at a time. You cannot
- * have a UDP connection open at the same time as a TFTP connection.
- * (This is not strictly true for Etherboot; see the relevant @ref
- * pxe_note_udp "implementation note" for more details.)
+ * You can only have one open UDP connection at a time. This is not a
+ * meaningful restriction, since pxenv_udp_write() and
+ * pxenv_udp_read() allow you to specify arbitrary local and remote
+ * ports and an arbitrary remote address for each packet. According
+ * to the PXE specifiation, you cannot have a UDP connection open at
+ * the same time as a TFTP connection; this restriction does not apply
+ * to Etherboot.
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* for this UDP connection, or retained for all future communication.
* The latter seems more consistent with typical PXE stack behaviour.
*
+ * @note Etherboot currently ignores the s_PXENV_UDP_OPEN::src_ip
+ * parameter.
+ *
*/
-PXENV_EXIT_t pxenv_udp_open ( struct s_PXENV_UDP_OPEN *udp_open ) {
+PXENV_EXIT_t pxenv_udp_open ( struct s_PXENV_UDP_OPEN *pxenv_udp_open ) {
+ struct in_addr new_ip = { .s_addr = pxenv_udp_open->src_ip };
+
DBG ( "PXENV_UDP_OPEN" );
- ENSURE_READY ( udp_open );
- if ( udp_open->src_ip &&
- udp_open->src_ip != arptable[ARP_CLIENT].ipaddr.s_addr ) {
- /* Overwrite our IP address */
- DBG ( " with new IP %@", udp_open->src_ip );
- arptable[ARP_CLIENT].ipaddr.s_addr = udp_open->src_ip;
+ /* Check connection is not already open */
+ if ( pxe_udp.open ) {
+ pxenv_udp_open->Status = PXENV_STATUS_UDP_OPEN;
+ return PXENV_EXIT_FAILURE;
+ }
+
+ /* Set IP address if specified */
+ if ( new_ip.s_addr ) {
+ /* FIXME: actually do something here */
+ DBG ( " with new IP address %s", inet_ntoa ( new_ip ) );
+ }
+
+ /* Open UDP connection */
+ if ( udp_open ( &pxe_udp.udp, 0 ) != 0 ) {
+ pxenv_udp_open->Status = PXENV_STATUS_OUT_OF_RESOURCES;
+ return PXENV_EXIT_FAILURE;
}
+ pxe_udp.open = 1;
- udp_open->Status = PXENV_STATUS_SUCCESS;
+ pxenv_udp_open->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* UDP CLOSE
*
- * @v udp_close Pointer to a struct s_PXENV_UDP_CLOSE
+ * @v pxenv_udp_close Pointer to a struct s_PXENV_UDP_CLOSE
* @ret #PXENV_EXIT_SUCCESS Always
* @ret s_PXENV_UDP_CLOSE::Status PXE status code
* @err None -
*
- * Closes a UDP "connection" opened with pxenv_udp_open().
+ * Closes a UDP connection opened with pxenv_udp_open().
*
* You can only have one open UDP connection at a time. You cannot
* have a UDP connection open at the same time as a TFTP connection.
* You cannot use pxenv_udp_close() to close a TFTP connection; use
- * pxenv_tftp_close() instead. (This is not strictly true for
- * Etherboot; see the relevant @ref pxe_note_udp "implementation note"
- * for more details.)
+ * pxenv_tftp_close() instead.
*
* On x86, you must set the s_PXE::StatusCallout field to a nonzero
* value before calling this function in protected mode. You cannot
* @ref pxe_x86_pmode16 "implementation note" for more details.)
*
*/
-PXENV_EXIT_t pxenv_udp_close ( struct s_PXENV_UDP_CLOSE *udp_close __unused ) {
+PXENV_EXIT_t pxenv_udp_close ( struct s_PXENV_UDP_CLOSE *pxenv_udp_close ) {
DBG ( "PXENV_UDP_CLOSE" );
- udp_close->Status = PXENV_STATUS_SUCCESS;
+
+ /* Check connection is open */
+ if ( ! pxe_udp.open ) {
+ pxenv_udp_close->Status = PXENV_STATUS_UDP_CLOSED;
+ return PXENV_EXIT_SUCCESS; /* Well, it *is* closed */
+ }
+
+ /* Close UDP connection */
+ udp_close ( &pxe_udp.udp );
+ pxe_udp.open = 0;
+
+ pxenv_udp_close->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
/**
* UDP WRITE
*
- * @v udp_write Pointer to a struct s_PXENV_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
* @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_UNDI_INVALID_STATE NIC could not be initialised
- * @err #PXENV_STATUS_OUT_OF_RESOURCES Packet was too large to transmit
- * @err other Any error from pxenv_undi_transmit()
+ * @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
* 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(). (This is not strictly true for
- * Etherboot; see the relevant @ref pxe_note_udp "implementation note"
- * for more details.)
+ * 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 *udp_write ) {
- uint16_t src_port;
- uint16_t dst_port;
- struct udppacket *packet = (struct udppacket *)nic.packet;
- int packet_size;
+PXENV_EXIT_t pxenv_udp_write ( struct s_PXENV_UDP_WRITE *pxenv_udp_write ) {
+ union {
+ struct sockaddr_in sin;
+ struct sockaddr_tcpip st;
+ } dest;
DBG ( "PXENV_UDP_WRITE" );
- ENSURE_READY ( udp_write );
-
- /* PXE spec says source port is 2069 if not specified */
- src_port = ntohs(udp_write->src_port);
- if ( src_port == 0 ) src_port = 2069;
- dst_port = ntohs(udp_write->dst_port);
- DBG ( " %d->%@:%d (%d)", src_port, udp_write->ip, dst_port,
- udp_write->buffer_size );
-
+
+ /* Check connection is open */
+ if ( ! pxe_udp.open ) {
+ pxenv_udp_write->Status = PXENV_STATUS_UDP_CLOSED;
+ return PXENV_EXIT_FAILURE;
+ }
+
+ /* Construct destination socket address */
+ memset ( &dest, 0, sizeof ( dest ) );
+ dest.sin.sin_family = AF_INET;
+ dest.sin.sin_addr.s_addr = pxenv_udp_write->ip;
+ dest.sin.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.
+ */
+ if ( ! pxenv_udp_write->src_port )
+ pxenv_udp_write->src_port = htons ( 2069 );
+ udp_bind ( &pxe_udp.udp, pxenv_udp_write->src_port );
+
/* 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.
*/
- /* Copy payload to packet buffer */
- packet_size = ( (void*)&packet->payload - (void*)packet )
- + udp_write->buffer_size;
- if ( packet_size > ETH_FRAME_LEN ) {
- udp_write->Status = PXENV_STATUS_OUT_OF_RESOURCES;
- return PXENV_EXIT_FAILURE;
- }
- memcpy ( &packet->payload, SEGOFF16_TO_PTR(udp_write->buffer),
- udp_write->buffer_size );
-
/* Transmit packet */
- if ( ! udp_transmit ( udp_write->ip, src_port, dst_port,
- packet_size, packet ) ) {
- udp_write->Status = errno;
+ if ( udp_senddata ( &pxe_udp.udp ) != 0 ) {
+ pxenv_udp_write->Status = PXENV_STATUS_UNDI_TRANSMIT_ERROR;
return PXENV_EXIT_FAILURE;
}
- udp_write->Status = PXENV_STATUS_SUCCESS;
+ pxenv_udp_write->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
}
-/* Utility function for pxenv_udp_read() */
-static int await_pxe_udp ( int ival __unused, void *ptr,
- unsigned short ptype __unused,
- struct iphdr *ip, struct udphdr *udp,
- struct tcphdr *tcp __unused ) {
- struct s_PXENV_UDP_READ *udp_read = (struct s_PXENV_UDP_READ*)ptr;
- uint16_t d_port;
- size_t size;
-
- /* Ignore non-UDP packets */
- if ( !udp ) {
- DBG ( " non-UDP" );
- return 0;
- }
-
- /* Check dest_ip */
- if ( udp_read->dest_ip && ( udp_read->dest_ip != ip->dest.s_addr ) ) {
- DBG ( " wrong dest IP (got %@, wanted %@)",
- ip->dest.s_addr, udp_read->dest_ip );
- return 0;
- }
-
- /* Check dest_port */
- d_port = ntohs ( udp_read->d_port );
- if ( d_port && ( d_port != ntohs(udp->dest) ) ) {
- DBG ( " wrong dest port (got %d, wanted %d)",
- ntohs(udp->dest), d_port );
- return 0;
- }
-
- /* Copy packet to buffer and fill in information */
- udp_read->src_ip = ip->src.s_addr;
- udp_read->s_port = udp->src; /* Both in network order */
- size = ntohs(udp->len) - sizeof(*udp);
- /* Workaround: NTLDR expects us to fill these in, even though
- * PXESPEC clearly defines them as input parameters.
- */
- udp_read->dest_ip = ip->dest.s_addr;
- udp_read->d_port = udp->dest;
- DBG ( " %@:%d->%@:%d (%d)",
- udp_read->src_ip, ntohs(udp_read->s_port),
- udp_read->dest_ip, ntohs(udp_read->d_port), size );
- if ( udp_read->buffer_size < size ) {
- /* PXESPEC: what error code should we actually return? */
- DBG ( " buffer too small (%d)", udp_read->buffer_size );
- udp_read->Status = PXENV_STATUS_OUT_OF_RESOURCES;
- return 0;
- }
- memcpy ( SEGOFF16_TO_PTR ( udp_read->buffer ), &udp->payload, size );
- udp_read->buffer_size = size;
-
- return 1;
-}
-
/**
* UDP READ
*
- * @v udp_read Pointer to a struct s_PXENV_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
* @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_UNDI_INVALID_STATE NIC could not be initialised
- * @err #PXENV_STATUS_OUT_OF_RESOURCES Buffer was too small for 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
* 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(). (This is not strictly true for
- * Etherboot; see the relevant @ref pxe_note_udp "implementation note"
- * for more details.)
+ * 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
* expects us to do so, and will fail if we don't.
*
*/
-PXENV_EXIT_t pxenv_udp_read ( struct s_PXENV_UDP_READ *udp_read ) {
+PXENV_EXIT_t pxenv_udp_read ( struct s_PXENV_UDP_READ *pxenv_udp_read ) {
+ struct in_addr dest_ip = { .s_addr = pxenv_udp_read->dest_ip };
+ uint16_t d_port = pxenv_udp_read->d_port;
+
DBG ( "PXENV_UDP_READ" );
- ENSURE_READY ( udp_read );
- /* Use await_reply with a timeout of zero */
- /* Allow await_reply to change Status if necessary */
- udp_read->Status = PXENV_STATUS_FAILURE;
- if ( ! await_reply ( await_pxe_udp, 0, udp_read, 0 ) ) {
+ /* Check connection is open */
+ if ( ! pxe_udp.open ) {
+ pxenv_udp_read->Status = PXENV_STATUS_UDP_CLOSED;
return PXENV_EXIT_FAILURE;
}
- udp_read->Status = PXENV_STATUS_SUCCESS;
+ /* Bind promiscuously; we will do our own filtering */
+ udp_bind_promisc ( &pxe_udp.udp );
+
+ /* Try receiving a packet */
+ pxe_udp.pxenv_udp_read = pxenv_udp_read;
+ step();
+ if ( pxe_udp.pxenv_udp_read ) {
+ /* No packet received */
+ pxe_udp.pxenv_udp_read = NULL;
+ goto no_packet;
+ }
+
+ /* Filter on destination address and/or port */
+ if ( dest_ip.s_addr && ( dest_ip.s_addr != pxenv_udp_read->dest_ip ) )
+ goto no_packet;
+ if ( d_port && ( d_port != pxenv_udp_read->d_port ) )
+ goto no_packet;
+
+ pxenv_udp_read->Status = PXENV_STATUS_SUCCESS;
return PXENV_EXIT_SUCCESS;
-}
-/** @page pxe_notes Etherboot PXE implementation notes
-
-@section pxe_note_udp The connectionless nature of UDP
-
-The PXE specification states that it is possible to have only one open
-UDP or TFTP connection at any one time. Etherboot does not
-rigourously enforce this restriction, on the UNIX principle that the
-code should not prevent the user from doing stupid things, because
-that would also prevent the user from doing clever things. Since UDP
-is a connectionless protocol, it is perfectly possible to have
-multiple concurrent UDP "connections" open, provided that you take the
-multiplicity of connections into account when calling
-pxenv_udp_read(). Similarly, there is no technical reason that
-prevents you from calling pxenv_udp_write() in the middle of a TFTP
-download.
-
-Etherboot will therefore never return error codes indicating "a
-connection is already open", such as #PXENV_STATUS_UDP_OPEN. If you
-want to have multiple concurrent connections, go for it (but don't
-expect your perfectly sensible code to work with any other PXE stack).
-
-Since Etherboot treats UDP as the connectionless protocol that it
-really is, pxenv_udp_close() is actually a no-op, and there is no need
-to call pxenv_udp_open() before using pxenv_udp_write() or
-pxenv_udp_read().
-
-*/
+ no_packet:
+ pxenv_udp_read->Status = PXENV_STATUS_FAILURE;
+ return PXENV_EXIT_FAILURE;
+}
http://git.etherboot.org / people / xl0 / gpxe.git / commitdiff