diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-27 10:54:18 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-27 10:54:18 +0000 |
| commit | 8e67fbf68ffeb9eb5f026dd482d73b021660bf9b (patch) | |
| tree | bb573facd5d02096f9956b2617a722b88acaa8af /debian/grub-extras/disabled/gpxe/src/include | |
| parent | Adding upstream version 2.06. (diff) | |
| download | grub2-8e67fbf68ffeb9eb5f026dd482d73b021660bf9b.tar.xz grub2-8e67fbf68ffeb9eb5f026dd482d73b021660bf9b.zip | |
Adding debian version 2.06-3~deb11u6.debian/2.06-3_deb11u6debian
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'debian/grub-extras/disabled/gpxe/src/include')
125 files changed, 16402 insertions, 0 deletions
diff --git a/debian/grub-extras/disabled/gpxe/src/include/etherboot.h b/debian/grub-extras/disabled/gpxe/src/include/etherboot.h new file mode 100644 index 0000000..ad44e8a --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/etherboot.h @@ -0,0 +1,44 @@ +#ifndef ETHERBOOT_H +#define ETHERBOOT_H + +/* + * Standard includes that we always want + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stddef.h> +#include <stdint.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <strings.h> +#include <console.h> +#include <gpxe/timer.h> +#include <gpxe/if_arp.h> +#include <gpxe/if_ether.h> + +typedef unsigned long Address; + +/* + * IMPORTANT!!!!!!!!!!!!!! + * + * Everything below this point is cruft left over from older versions + * of Etherboot. Do not add *anything* below this point. Things are + * gradually being moved to individual header files. + * + */ + +/* Link configuration time in tenths of a second */ +#ifndef VALID_LINK_TIMEOUT +#define VALID_LINK_TIMEOUT 100 /* 10.0 seconds */ +#endif + +/* + * Local variables: + * c-basic-offset: 8 + * End: + */ + +#endif /* ETHERBOOT_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/acpi.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/acpi.h new file mode 100644 index 0000000..12edda9 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/acpi.h @@ -0,0 +1,43 @@ +#ifndef _GPXE_ACPI_H +#define _GPXE_ACPI_H + +/** @file + * + * ACPI data structures + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/** + * An ACPI description header + * + * This is the structure common to the start of all ACPI system + * description tables. + */ +struct acpi_description_header { + /** ACPI signature (4 ASCII characters) */ + char signature[4]; + /** Length of table, in bytes, including header */ + uint32_t length; + /** ACPI Specification minor version number */ + uint8_t revision; + /** To make sum of entire table == 0 */ + uint8_t checksum; + /** OEM identification */ + char oem_id[6]; + /** OEM table identification */ + char oem_table_id[8]; + /** OEM revision number */ + uint32_t oem_revision; + /** ASL compiler vendor ID */ + char asl_compiler_id[4]; + /** ASL compiler revision number */ + uint32_t asl_compiler_revision; +} __attribute__ (( packed )); + +extern void acpi_fix_checksum ( struct acpi_description_header *acpi ); + +#endif /* _GPXE_ACPI_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/aes.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/aes.h new file mode 100644 index 0000000..bdc32bd --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/aes.h @@ -0,0 +1,10 @@ +#ifndef _GPXE_AES_H +#define _GPXE_AES_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct cipher_algorithm; + +extern struct cipher_algorithm aes_cbc_algorithm; + +#endif /* _GPXE_AES_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ansiesc.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ansiesc.h new file mode 100644 index 0000000..85f7a9f --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ansiesc.h @@ -0,0 +1,120 @@ +#ifndef _GPXE_ANSIESC_H +#define _GPXE_ANSIESC_H + +/** @file + * + * ANSI escape sequences + * + * ANSI X3.64 (aka ECMA-48 or ISO/IEC 6429, available from + * http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-048.pdf) + * defines escape sequences consisting of: + * + * A Control Sequence Introducer (CSI) + * + * Zero or more Parameter Bytes (P) + * + * Zero or more Intermediate Bytes (I) + * + * A Final Byte (F) + * + * The CSI consists of ESC (0x1b) followed by "[" (0x5b). The + * Parameter Bytes, for a standardised (i.e. not private or + * experimental) sequence, consist of a list of ASCII decimal integers + * separated by semicolons. The Intermediate Bytes (in the range 0x20 + * to 0x2f) and the Final Byte (in the range 0x40 to 0x4f) determine + * the control function. + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** A handler for an escape sequence */ +struct ansiesc_handler { + /** The control function identifier + * + * The control function identifier consists of the + * Intermediate Bytes (if any) and the Final Byte. In + * practice, no more than one immediate byte is ever used, so + * the byte combination can be efficiently expressed as a + * single integer, in the obvious way (with the Final Byte + * being the least significant byte). + */ + unsigned int function; + /** Handle escape sequence + * + * @v count Parameter count + * @v params Parameter list + * + * A negative parameter value indicates that the parameter was + * omitted and that the default value for this control + * function should be used. + * + * Since all parameters are optional, there is no way to + * distinguish between "zero parameters" and "single parameter + * omitted". Consequently, the parameter list will always + * contain at least one item. + */ + void ( * handle ) ( unsigned int count, int params[] ); +}; + +/** Maximum number of parameters within a single escape sequence */ +#define ANSIESC_MAX_PARAMS 4 + +/** + * ANSI escape sequence context + * + * This provides temporary storage for processing escape sequences, + * and points to the list of escape sequence handlers. + */ +struct ansiesc_context { + /** Array of handlers + * + * Must be terminated by a handler with @c function set to + * zero. + */ + struct ansiesc_handler *handlers; + /** Parameter count + * + * Will be zero when not currently in an escape sequence. + */ + unsigned int count; + /** Parameter list */ + int params[ANSIESC_MAX_PARAMS]; + /** Control function identifier */ + unsigned int function; +}; + +/** Escape character */ +#define ESC 0x1b + +/** Control Sequence Introducer */ +#define CSI "\033[" + +/** + * @defgroup ansifuncs ANSI escape sequence function identifiers + * @{ + */ + +/** Cursor position */ +#define ANSIESC_CUP 'H' + +/** Erase in page */ +#define ANSIESC_ED 'J' + +/** Erase from cursor to end of page */ +#define ANSIESC_ED_TO_END 0 + +/** Erase from start of page to cursor */ +#define ANSIESC_ED_FROM_START 1 + +/** Erase whole page */ +#define ANSIESC_ED_ALL 2 + +/** Select graphic rendition */ +#define ANSIESC_SGR 'm' + +/** @} */ + +extern int ansiesc_process ( struct ansiesc_context *ctx, int c ); + +#endif /* _GPXE_ANSIESC_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/aoe.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/aoe.h new file mode 100644 index 0000000..6b42fd5 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/aoe.h @@ -0,0 +1,150 @@ +#ifndef _GPXE_AOE_H +#define _GPXE_AOE_H + +/** @file + * + * AoE protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/list.h> +#include <gpxe/if_ether.h> +#include <gpxe/retry.h> +#include <gpxe/ata.h> + +/** An AoE config command */ +struct aoecfg { + /** AoE Queue depth */ + uint16_t bufcnt; + /** ATA target firmware version */ + uint16_t fwver; + /** ATA target sector count */ + uint8_t scnt; + /** AoE config string subcommand */ + uint8_t aoeccmd; + /** AoE config string length */ + uint16_t cfglen; + /** AoE config string */ + uint8_t data[0]; +} __attribute__ (( packed )); + +/** An AoE ATA command */ +struct aoeata { + /** AoE command flags */ + uint8_t aflags; + /** ATA error/feature register */ + uint8_t err_feat; + /** ATA sector count register */ + uint8_t count; + /** ATA command/status register */ + uint8_t cmd_stat; + /** Logical block address, in little-endian order */ + union { + uint64_t u64; + uint8_t bytes[6]; + } lba; + /** Data payload */ + uint8_t data[0]; +} __attribute__ (( packed )); + +#define AOE_FL_EXTENDED 0x40 /**< LBA48 extended addressing */ +#define AOE_FL_DEV_HEAD 0x10 /**< Device/head flag */ +#define AOE_FL_ASYNC 0x02 /**< Asynchronous write */ +#define AOE_FL_WRITE 0x01 /**< Write command */ + +/** An AoE command */ +union aoecmd { + /** Config command */ + struct aoecfg cfg; + /** ATA command */ + struct aoeata ata; +}; + +/** An AoE header */ +struct aoehdr { + /** Protocol version number and flags */ + uint8_t ver_flags; + /** Error code */ + uint8_t error; + /** Major device number, in network byte order */ + uint16_t major; + /** Minor device number */ + uint8_t minor; + /** Command number */ + uint8_t command; + /** Tag, in network byte order */ + uint32_t tag; + /** Payload */ + union aoecmd cmd[0]; +} __attribute__ (( packed )); + +#define AOE_VERSION 0x10 /**< Version 1 */ +#define AOE_VERSION_MASK 0xf0 /**< Version part of ver_flags field */ + +#define AOE_FL_RESPONSE 0x08 /**< Message is a response */ +#define AOE_FL_ERROR 0x04 /**< Command generated an error */ + +#define AOE_MAJOR_BROADCAST 0xffff +#define AOE_MINOR_BROADCAST 0xff + +#define AOE_CMD_ATA 0x00 /**< Issue ATA command */ +#define AOE_CMD_CONFIG 0x01 /**< Query Config Information */ + +#define AOE_TAG_MAGIC 0xebeb0000 + +#define AOE_ERR_BAD_COMMAND 1 /**< Unrecognised command code */ +#define AOE_ERR_BAD_PARAMETER 2 /**< Bad argument parameter */ +#define AOE_ERR_UNAVAILABLE 3 /**< Device unavailable */ +#define AOE_ERR_CONFIG_EXISTS 4 /**< Config string present */ +#define AOE_ERR_BAD_VERSION 5 /**< Unsupported version */ + +/** An AoE session */ +struct aoe_session { + /** Reference counter */ + struct refcnt refcnt; + + /** List of all AoE sessions */ + struct list_head list; + + /** Network device */ + struct net_device *netdev; + + /** Major number */ + uint16_t major; + /** Minor number */ + uint8_t minor; + /** Target MAC address */ + uint8_t target[ETH_ALEN]; + + /** Tag for current AoE command */ + uint32_t tag; + + /** Current AOE command */ + uint8_t aoe_cmd_type; + /** Current ATA command */ + struct ata_command *command; + /** Overall status of current ATA command */ + unsigned int status; + /** Byte offset within command's data buffer */ + unsigned int command_offset; + /** Return status code for command */ + int rc; + + /** Retransmission timer */ + struct retry_timer timer; +}; + +#define AOE_STATUS_ERR_MASK 0x0f /**< Error portion of status code */ +#define AOE_STATUS_PENDING 0x80 /**< Command pending */ + +/** Maximum number of sectors per packet */ +#define AOE_MAX_COUNT 2 + +extern void aoe_detach ( struct ata_device *ata ); +extern int aoe_attach ( struct ata_device *ata, struct net_device *netdev, + const char *root_path ); + +#endif /* _GPXE_AOE_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/api.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/api.h new file mode 100644 index 0000000..ff2ba59 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/api.h @@ -0,0 +1,84 @@ +#ifndef _GPXE_API_H +#define _GPXE_API_H + +/** @file + * + * gPXE internal APIs + * + * There are various formally-defined APIs internal to gPXE, with + * several differing implementations specific to particular execution + * environments (e.g. PC BIOS, EFI, LinuxBIOS). + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** @defgroup Single-implementation APIs + * + * These are APIs for which only a single implementation may be + * compiled in at any given time. + * + * @{ + */ + +/** + * Calculate function implementation name + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @ret _subsys_func Subsystem API function + * + * The subsystem prefix should be an empty string for the currently + * selected subsystem, and should be a subsystem-unique string for all + * other subsystems. + */ +#define SINGLE_API_NAME( _prefix, _api_func ) _prefix ## _api_func + +/** + * Calculate static inline function name + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @ret _subsys_func Subsystem API function + */ +#define SINGLE_API_INLINE( _prefix, _api_func ) \ + SINGLE_API_NAME ( _prefix, _api_func ) + +/** + * Provide an API implementation + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @v _func Implementing function + */ +#define PROVIDE_SINGLE_API( _prefix, _api_func, _func ) \ + /* Ensure that _api_func exists */ \ + typeof ( _api_func ) _api_func; \ + /* Ensure that _func exists */ \ + typeof ( _func ) _func; \ + /* Ensure that _func is type-compatible with _api_func */ \ + typeof ( _api_func ) _func; \ + /* Ensure that _subsys_func is non-static */ \ + extern typeof ( _api_func ) SINGLE_API_NAME ( _prefix, _api_func ); \ + /* Provide symbol alias from _subsys_func to _func */ \ + typeof ( _api_func ) SINGLE_API_NAME ( _prefix, _api_func ) \ + __attribute__ (( alias ( #_func ) )); + +/** + * Provide a static inline API implementation + * + * @v _prefix Subsystem prefix + * @v _api_func API function + */ +#define PROVIDE_SINGLE_API_INLINE( _prefix, _api_func ) \ + /* Ensure that _api_func exists */ \ + typeof ( _api_func ) _api_func; \ + /* Ensure that _subsys_func exists and is static */ \ + static typeof ( SINGLE_API_INLINE ( _prefix, _api_func ) ) \ + SINGLE_API_INLINE ( _prefix, _api_func ); \ + /* Ensure that _subsys_func is type-compatible with _api_func */ \ + typeof ( _api_func ) SINGLE_API_INLINE ( _prefix, _api_func ); + +/** @} */ + +#endif /* _GPXE_API_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/arp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/arp.h new file mode 100644 index 0000000..0623d35 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/arp.h @@ -0,0 +1,46 @@ +#ifndef _GPXE_ARP_H +#define _GPXE_ARP_H + +/** @file + * + * Address Resolution Protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/tables.h> + +struct net_device; +struct net_protocol; + +/** A network-layer protocol that relies upon ARP */ +struct arp_net_protocol { + /** Network-layer protocol */ + struct net_protocol *net_protocol; + /** Check existence of address + * + * @v netdev Network device + * @v net_addr Network-layer address + * @ret rc Return status code + */ + int ( * check ) ( struct net_device *netdev, + const void *net_addr ); +}; + +/** ARP protocol table */ +#define ARP_NET_PROTOCOLS \ + __table ( struct arp_net_protocol, "arp_net_protocols" ) + +/** Declare an ARP protocol */ +#define __arp_net_protocol __table_entry ( ARP_NET_PROTOCOLS, 01 ) + +extern struct net_protocol arp_protocol; + +extern int arp_resolve ( struct net_device *netdev, + struct net_protocol *net_protocol, + const void *dest_net_addr, + const void *source_net_addr, + void *dest_ll_addr ); + +#endif /* _GPXE_ARP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/asn1.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/asn1.h new file mode 100644 index 0000000..477c209 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/asn1.h @@ -0,0 +1,34 @@ +#ifndef _GPXE_ASN1_H +#define _GPXE_ASN1_H + +/** @file + * + * ASN.1 encoding + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#define ASN1_INTEGER 0x02 +#define ASN1_BIT_STRING 0x03 +#define ASN1_OCTET_STRING 0x04 +#define ASN1_NULL 0x05 +#define ASN1_OID 0x06 +#define ASN1_SEQUENCE 0x30 +#define ASN1_IP_ADDRESS 0x40 +#define ASN1_EXPLICIT_TAG 0xa0 + +/** + * A DER-encoded ASN.1 object cursor + */ +struct asn1_cursor { + /** Start of data */ + void *data; + /** Length of data */ + size_t len; +}; + +extern int asn1_enter ( struct asn1_cursor *cursor, unsigned int type ); +extern int asn1_skip ( struct asn1_cursor *cursor, unsigned int type ); + +#endif /* _GPXE_ASN1_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ata.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ata.h new file mode 100644 index 0000000..3c56584 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ata.h @@ -0,0 +1,209 @@ +#ifndef _GPXE_ATA_H +#define _GPXE_ATA_H + +#include <stdint.h> +#include <gpxe/blockdev.h> +#include <gpxe/uaccess.h> +#include <gpxe/refcnt.h> + +/** @file + * + * ATA devices + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** + * An ATA Logical Block Address + * + * ATA controllers have three byte-wide registers for specifying the + * block address: LBA Low, LBA Mid and LBA High. This allows for a + * 24-bit address. Some devices support the "48-bit address feature + * set" (LBA48), in which case each of these byte-wide registers is + * actually a two-entry FIFO, and the "previous" byte pushed into the + * FIFO is used as the corresponding high-order byte. So, to set up + * the 48-bit address 0x123456abcdef, you would issue + * + * 0x56 -> LBA Low register + * 0xef -> LBA Low register + * 0x34 -> LBA Mid register + * 0xcd -> LBA Mid register + * 0x12 -> LBA High register + * 0xab -> LBA High register + * + * This structure encapsulates this information by providing a single + * 64-bit integer in native byte order, unioned with bytes named so + * that the sequence becomes + * + * low_prev -> LBA Low register + * low_cur -> LBA Low register + * mid_prev -> LBA Mid register + * mid_cur -> LBA Mid register + * high_prev -> LBA High register + * high_cur -> LBA High register + * + * Just to complicate matters further, in non-LBA48 mode it is + * possible to have a 28-bit address, in which case bits 27:24 must be + * written into the low four bits of the Device register. + */ +union ata_lba { + /** LBA as a 64-bit integer in native-endian order */ + uint64_t native; + /** ATA registers */ + struct { +#if __BYTE_ORDER == __LITTLE_ENDIAN + uint8_t low_cur; + uint8_t mid_cur; + uint8_t high_cur; + uint8_t low_prev; + uint8_t mid_prev; + uint8_t high_prev; + uint16_t pad; +#elif __BYTE_ORDER == __BIG_ENDIAN + uint16_t pad; + uint8_t high_prev; + uint8_t mid_prev; + uint8_t low_prev; + uint8_t high_cur; + uint8_t mid_cur; + uint8_t low_cur; +#else +#error "I need a byte order" +#endif + } bytes; +}; + +/** An ATA 2-byte FIFO register */ +union ata_fifo { + /** Value in native-endian order */ + uint16_t native; + /** ATA registers */ + struct { +#if __BYTE_ORDER == __LITTLE_ENDIAN + uint8_t cur; + uint8_t prev; +#elif __BYTE_ORDER == __BIG_ENDIAN + uint8_t prev; + uint8_t cur; +#else +#error "I need a byte order" +#endif + } bytes; +}; + +/** ATA command block */ +struct ata_cb { + /** Logical block address */ + union ata_lba lba; + /** Sector count */ + union ata_fifo count; + /** Error/feature register */ + union ata_fifo err_feat; + /** Device register */ + uint8_t device; + /** Command/status register */ + uint8_t cmd_stat; + /** LBA48 addressing flag */ + int lba48; +}; + +/** Obsolete bits in the ATA device register */ +#define ATA_DEV_OBSOLETE 0xa0 + +/** LBA flag in the ATA device register */ +#define ATA_DEV_LBA 0x40 + +/** Slave ("device 1") flag in the ATA device register */ +#define ATA_DEV_SLAVE 0x10 + +/** Master ("device 0") flag in the ATA device register */ +#define ATA_DEV_MASTER 0x00 + +/** Mask of non-LBA portion of device register */ +#define ATA_DEV_MASK 0xf0 + +/** "Read sectors" command */ +#define ATA_CMD_READ 0x20 + +/** "Read sectors (ext)" command */ +#define ATA_CMD_READ_EXT 0x24 + +/** "Write sectors" command */ +#define ATA_CMD_WRITE 0x30 + +/** "Write sectors (ext)" command */ +#define ATA_CMD_WRITE_EXT 0x34 + +/** "Identify" command */ +#define ATA_CMD_IDENTIFY 0xec + +/** An ATA command */ +struct ata_command { + /** ATA command block */ + struct ata_cb cb; + /** Data-out buffer (may be NULL) + * + * If non-NULL, this buffer must be ata_command::cb::count + * sectors in size. + */ + userptr_t data_out; + /** Data-in buffer (may be NULL) + * + * If non-NULL, this buffer must be ata_command::cb::count + * sectors in size. + */ + userptr_t data_in; + /** Command status code */ + int rc; +}; + +/** + * Structure returned by ATA IDENTIFY command + * + * This is a huge structure with many fields that we don't care about, + * so we implement only a few fields. + */ +struct ata_identity { + uint16_t ignore_a[60]; /* words 0-59 */ + uint32_t lba_sectors; /* words 60-61 */ + uint16_t ignore_b[21]; /* words 62-82 */ + uint16_t supports_lba48; /* word 83 */ + uint16_t ignore_c[16]; /* words 84-99 */ + uint64_t lba48_sectors; /* words 100-103 */ + uint16_t ignore_d[152]; /* words 104-255 */ +}; + +/** Supports LBA48 flag */ +#define ATA_SUPPORTS_LBA48 ( 1 << 10 ) + +/** ATA sector size */ +#define ATA_SECTOR_SIZE 512 + +/** An ATA device */ +struct ata_device { + /** Block device interface */ + struct block_device blockdev; + /** Device number + * + * Must be ATA_DEV_MASTER or ATA_DEV_SLAVE. + */ + int device; + /** LBA48 extended addressing */ + int lba48; + /** + * Issue ATA command + * + * @v ata ATA device + * @v command ATA command + * @ret rc Return status code + */ + int ( * command ) ( struct ata_device *ata, + struct ata_command *command ); + /** Backing device */ + struct refcnt *backend; +}; + +extern int init_atadev ( struct ata_device *ata ); + +#endif /* _GPXE_ATA_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/base64.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/base64.h new file mode 100644 index 0000000..e38bef0 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/base64.h @@ -0,0 +1,26 @@ +#ifndef _GPXE_BASE64_H +#define _GPXE_BASE64_H + +/** @file + * + * Base64 encoding + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/** + * Calculate length of base64-encoded string + * + * @v raw_len Raw string length (excluding NUL) + * @ret encoded_len Encoded string length (excluding NUL) + */ +static inline size_t base64_encoded_len ( size_t raw_len ) { + return ( ( ( raw_len + 3 - 1 ) / 3 ) * 4 ); +} + +extern void base64_encode ( const char *raw, char *encoded ); + +#endif /* _GPXE_BASE64_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitbash.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitbash.h new file mode 100644 index 0000000..f2ba9f7 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitbash.h @@ -0,0 +1,52 @@ +#ifndef _GPXE_BITBASH_H +#define _GPXE_BITBASH_H + +/** @file + * + * Bit-bashing interfaces + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct bit_basher; + +/** Bit-bashing operations */ +struct bit_basher_operations { + /** + * Set/clear output bit + * + * @v basher Bit-bashing interface + * @v bit_id Bit number + * @v data Value to write + * + * @c data will be 0 if a logic 0 should be written (i.e. the + * bit should be cleared), or -1UL if a logic 1 should be + * written (i.e. the bit should be set). This is done so that + * the method may simply binary-AND @c data with the + * appropriate bit mask. + */ + void ( * write ) ( struct bit_basher *basher, unsigned int bit_id, + unsigned long data ); + /** + * Read input bit + * + * @v basher Bit-bashing interface + * @v bit_id Bit number + * @ret zero Input is a logic 0 + * @ret non-zero Input is a logic 1 + */ + int ( * read ) ( struct bit_basher *basher, unsigned int bit_id ); +}; + +/** A bit-bashing interface */ +struct bit_basher { + /** Bit-bashing operations */ + struct bit_basher_operations *op; +}; + +extern void write_bit ( struct bit_basher *basher, unsigned int bit_id, + unsigned long data ); +extern int read_bit ( struct bit_basher *basher, unsigned int bit_id ); + +#endif /* _GPXE_BITBASH_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitmap.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitmap.h new file mode 100644 index 0000000..d6911a5 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitmap.h @@ -0,0 +1,85 @@ +#ifndef _GPXE_BITMAP_H +#define _GPXE_BITMAP_H + +/** @file + * + * Bitmaps for multicast downloads + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <stddef.h> +#include <stdlib.h> + +/** A single block of bits within a bitmap */ +typedef unsigned long bitmap_block_t; + +/** Size of a block of bits (in bits) */ +#define BITMAP_BLKSIZE ( sizeof ( bitmap_block_t ) * 8 ) + +/** + * Block index within bitmap + * + * @v bit Bit index + * @ret index Block index + */ +#define BITMAP_INDEX( bit ) ( (bit) / BITMAP_BLKSIZE ) + +/** + * Block mask within bitmap + * + * @v bit Bit index + * @ret mask Block mask + */ +#define BITMAP_MASK( bit ) ( 1 << ( (bit) % BITMAP_BLKSIZE ) ) + +/** A bitmap */ +struct bitmap { + /** Bitmap data */ + bitmap_block_t *blocks; + /** Length of the bitmap, in bits */ + unsigned int length; + /** Index of first gap in the bitmap */ + unsigned int first_gap; +}; + +extern int bitmap_resize ( struct bitmap *bitmap, unsigned int new_length ); +extern int bitmap_test ( struct bitmap *bitmap, unsigned int bit ); +extern void bitmap_set ( struct bitmap *bitmap, unsigned int bit ); + +/** + * Free bitmap resources + * + * @v bitmap Bitmap + */ +static inline void bitmap_free ( struct bitmap *bitmap ) { + free ( bitmap->blocks ); +} + +/** + * Get first gap within bitmap + * + * @v bitmap Bitmap + * @ret first_gap First gap + * + * The first gap is the first unset bit within the bitmap. + */ +static inline unsigned int bitmap_first_gap ( struct bitmap *bitmap ) { + return bitmap->first_gap; +} + +/** + * Check to see if bitmap is full + * + * @v bitmap Bitmap + * @ret is_full Bitmap is full + * + * The bitmap is full if it has no gaps (i.e. no unset bits). + */ +static inline int bitmap_full ( struct bitmap *bitmap ) { + return ( bitmap->first_gap == bitmap->length ); +} + +#endif /* _GPXE_BITMAP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitops.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitops.h new file mode 100644 index 0000000..8db3431 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/bitops.h @@ -0,0 +1,230 @@ +#ifndef _GPXE_BITOPS_H +#define _GPXE_BITOPS_H + +/* + * Copyright (C) 2008 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. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** + * @file + * + * Bit operations + * + */ + +#include <stdint.h> +#include <byteswap.h> + +/* Endianness selection. + * + * This is a property of the NIC, not a property of the host CPU. + */ +#ifdef BITOPS_LITTLE_ENDIAN +#define cpu_to_BIT64 cpu_to_le64 +#define cpu_to_BIT32 cpu_to_le32 +#define BIT64_to_cpu le64_to_cpu +#define BIT32_to_cpu le32_to_cpu +#endif +#ifdef BITOPS_BIG_ENDIAN +#define cpu_to_BIT64 cpu_to_be64 +#define cpu_to_BIT32 cpu_to_be32 +#define BIT64_to_cpu be64_to_cpu +#define BIT32_to_cpu be32_to_cpu +#endif + +/** Datatype used to represent a bit in the pseudo-structures */ +typedef unsigned char pseudo_bit_t; + +/** + * Wrapper structure for pseudo_bit_t structures + * + * This structure provides a wrapper around pseudo_bit_t structures. + * It has the correct size, and also encapsulates type information + * about the underlying pseudo_bit_t-based structure, which allows the + * BIT_FILL() etc. macros to work without requiring explicit type + * information. + */ +#define PSEUDO_BIT_STRUCT( _structure ) \ + union { \ + uint8_t bytes[ sizeof ( _structure ) / 8 ]; \ + uint32_t dwords[ sizeof ( _structure ) / 32 ]; \ + uint64_t qwords[ sizeof ( _structure ) / 64 ]; \ + _structure *dummy[0]; \ + } u + +/** Get pseudo_bit_t structure type from wrapper structure pointer */ +#define PSEUDO_BIT_STRUCT_TYPE( _ptr ) \ + typeof ( *((_ptr)->u.dummy[0]) ) + +/** Bit offset of a field within a pseudo_bit_t structure */ +#define BIT_OFFSET( _ptr, _field ) \ + offsetof ( PSEUDO_BIT_STRUCT_TYPE ( _ptr ), _field ) + +/** Bit width of a field within a pseudo_bit_t structure */ +#define BIT_WIDTH( _ptr, _field ) \ + sizeof ( ( ( PSEUDO_BIT_STRUCT_TYPE ( _ptr ) * ) NULL )->_field ) + +/** Qword offset of a field within a pseudo_bit_t structure */ +#define QWORD_OFFSET( _ptr, _field ) \ + ( BIT_OFFSET ( _ptr, _field ) / 64 ) + +/** Qword bit offset of a field within a pseudo_bit_t structure */ +#define QWORD_BIT_OFFSET( _ptr, _index, _field ) \ + ( BIT_OFFSET ( _ptr, _field ) - ( 64 * (_index) ) ) + +/** Bit mask for a field within a pseudo_bit_t structure */ +#define BIT_MASK( _ptr, _field ) \ + ( ( ~( ( uint64_t ) 0 ) ) >> \ + ( 64 - BIT_WIDTH ( _ptr, _field ) ) ) + +/* + * Assemble native-endian qword from named fields and values + * + */ + +#define BIT_ASSEMBLE_1( _ptr, _index, _field, _value ) \ + ( ( ( uint64_t) (_value) ) << \ + QWORD_BIT_OFFSET ( _ptr, _index, _field ) ) + +#define BIT_ASSEMBLE_2( _ptr, _index, _field, _value, ... ) \ + ( BIT_ASSEMBLE_1 ( _ptr, _index, _field, _value ) | \ + BIT_ASSEMBLE_1 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_ASSEMBLE_3( _ptr, _index, _field, _value, ... ) \ + ( BIT_ASSEMBLE_1 ( _ptr, _index, _field, _value ) | \ + BIT_ASSEMBLE_2 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_ASSEMBLE_4( _ptr, _index, _field, _value, ... ) \ + ( BIT_ASSEMBLE_1 ( _ptr, _index, _field, _value ) | \ + BIT_ASSEMBLE_3 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_ASSEMBLE_5( _ptr, _index, _field, _value, ... ) \ + ( BIT_ASSEMBLE_1 ( _ptr, _index, _field, _value ) | \ + BIT_ASSEMBLE_4 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_ASSEMBLE_6( _ptr, _index, _field, _value, ... ) \ + ( BIT_ASSEMBLE_1 ( _ptr, _index, _field, _value ) | \ + BIT_ASSEMBLE_5 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_ASSEMBLE_7( _ptr, _index, _field, _value, ... ) \ + ( BIT_ASSEMBLE_1 ( _ptr, _index, _field, _value ) | \ + BIT_ASSEMBLE_6 ( _ptr, _index, __VA_ARGS__ ) ) + +/* + * Build native-endian (positive) qword bitmasks from named fields + * + */ + +#define BIT_MASK_1( _ptr, _index, _field ) \ + ( BIT_MASK ( _ptr, _field ) << \ + QWORD_BIT_OFFSET ( _ptr, _index, _field ) ) + +#define BIT_MASK_2( _ptr, _index, _field, ... ) \ + ( BIT_MASK_1 ( _ptr, _index, _field ) | \ + BIT_MASK_1 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_MASK_3( _ptr, _index, _field, ... ) \ + ( BIT_MASK_1 ( _ptr, _index, _field ) | \ + BIT_MASK_2 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_MASK_4( _ptr, _index, _field, ... ) \ + ( BIT_MASK_1 ( _ptr, _index, _field ) | \ + BIT_MASK_3 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_MASK_5( _ptr, _index, _field, ... ) \ + ( BIT_MASK_1 ( _ptr, _index, _field ) | \ + BIT_MASK_4 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_MASK_6( _ptr, _index, _field, ... ) \ + ( BIT_MASK_1 ( _ptr, _index, _field ) | \ + BIT_MASK_5 ( _ptr, _index, __VA_ARGS__ ) ) + +#define BIT_MASK_7( _ptr, _index, _field, ... ) \ + ( BIT_MASK_1 ( _ptr, _index, _field ) | \ + BIT_MASK_6 ( _ptr, _index, __VA_ARGS__ ) ) + +/* + * Populate little-endian qwords from named fields and values + * + */ + +#define BIT_FILL( _ptr, _index, _assembled ) do { \ + uint64_t *__ptr = &(_ptr)->u.qwords[(_index)]; \ + uint64_t __assembled = (_assembled); \ + *__ptr = cpu_to_BIT64 ( __assembled ); \ + } while ( 0 ) + +#define BIT_FILL_1( _ptr, _field1, ... ) \ + BIT_FILL ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + BIT_ASSEMBLE_1 ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + _field1, __VA_ARGS__ ) ) + +#define BIT_FILL_2( _ptr, _field1, ... ) \ + BIT_FILL ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + BIT_ASSEMBLE_2 ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + _field1, __VA_ARGS__ ) ) + +#define BIT_FILL_3( _ptr, _field1, ... ) \ + BIT_FILL ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + BIT_ASSEMBLE_3 ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + _field1, __VA_ARGS__ ) ) + +#define BIT_FILL_4( _ptr, _field1, ... ) \ + BIT_FILL ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + BIT_ASSEMBLE_4 ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + _field1, __VA_ARGS__ ) ) + +#define BIT_FILL_5( _ptr, _field1, ... ) \ + BIT_FILL ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + BIT_ASSEMBLE_5 ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + _field1, __VA_ARGS__ ) ) + +#define BIT_FILL_6( _ptr, _field1, ... ) \ + BIT_FILL ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + BIT_ASSEMBLE_6 ( _ptr, QWORD_OFFSET ( _ptr, _field1 ), \ + _field1, __VA_ARGS__ ) ) + +/** Extract value of named field */ +#define BIT_GET64( _ptr, _field ) \ + ( { \ + unsigned int __index = QWORD_OFFSET ( _ptr, _field ); \ + uint64_t *__ptr = &(_ptr)->u.qwords[__index]; \ + uint64_t __value = BIT64_to_cpu ( *__ptr ); \ + __value >>= \ + QWORD_BIT_OFFSET ( _ptr, __index, _field ); \ + __value &= BIT_MASK ( _ptr, _field ); \ + __value; \ + } ) + +/** Extract value of named field (for fields up to the size of a long) */ +#define BIT_GET( _ptr, _field ) \ + ( ( unsigned long ) BIT_GET64 ( _ptr, _field ) ) + +#define BIT_SET( _ptr, _field, _value ) do { \ + unsigned int __index = QWORD_OFFSET ( _ptr, _field ); \ + uint64_t *__ptr = &(_ptr)->u.qwords[__index]; \ + unsigned int __shift = \ + QWORD_BIT_OFFSET ( _ptr, __index, _field ); \ + uint64_t __value = (_value); \ + *__ptr &= cpu_to_BIT64 ( ~( BIT_MASK ( _ptr, _field ) << \ + __shift ) ); \ + *__ptr |= cpu_to_BIT64 ( __value << __shift ); \ + } while ( 0 ) + +#endif /* _GPXE_BITOPS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/blockdev.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/blockdev.h new file mode 100644 index 0000000..cf28524 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/blockdev.h @@ -0,0 +1,53 @@ +#ifndef _GPXE_BLOCKDEV_H +#define _GPXE_BLOCKDEV_H + +/** + * @file + * + * Block devices + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/uaccess.h> + +struct block_device; + +/** Block device operations */ +struct block_device_operations { + /** + * Read block + * + * @v blockdev Block device + * @v block Block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ + int ( * read ) ( struct block_device *blockdev, uint64_t block, + unsigned long count, userptr_t buffer ); + /** + * Write block + * + * @v blockdev Block device + * @v block Block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ + int ( * write ) ( struct block_device *blockdev, uint64_t block, + unsigned long count, userptr_t buffer ); +}; + +/** A block device */ +struct block_device { + /** Block device operations */ + struct block_device_operations *op; + /** Block size */ + size_t blksize; + /** Total number of blocks */ + uint64_t blocks; +}; + +#endif /* _GPXE_BLOCKDEV_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/cbc.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/cbc.h new file mode 100644 index 0000000..1262f1d --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/cbc.h @@ -0,0 +1,100 @@ +#ifndef _GPXE_CBC_H +#define _GPXE_CBC_H + +/** @file + * + * Cipher-block chaining + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/crypto.h> + +/** + * Set key + * + * @v ctx Context + * @v key Key + * @v keylen Key length + * @v raw_cipher Underlying cipher algorithm + * @v cbc_ctx CBC context + * @ret rc Return status code + */ +static inline int cbc_setkey ( void *ctx, const void *key, size_t keylen, + struct cipher_algorithm *raw_cipher, + void *cbc_ctx __unused ) { + + return cipher_setkey ( raw_cipher, ctx, key, keylen ); +} + +/** + * Set initialisation vector + * + * @v ctx Context + * @v iv Initialisation vector + * @v raw_cipher Underlying cipher algorithm + * @v cbc_ctx CBC context + */ +static inline void cbc_setiv ( void *ctx __unused, const void *iv, + struct cipher_algorithm *raw_cipher, + void *cbc_ctx ) { + memcpy ( cbc_ctx, iv, raw_cipher->blocksize ); +} + +extern void cbc_encrypt ( void *ctx, const void *src, void *dst, + size_t len, struct cipher_algorithm *raw_cipher, + void *cbc_ctx ); +extern void cbc_decrypt ( void *ctx, const void *src, void *dst, + size_t len, struct cipher_algorithm *raw_cipher, + void *cbc_ctx ); + +/** + * Create a cipher-block chaining mode of behaviour of an existing cipher + * + * @v _cbc_name Name for the new CBC cipher + * @v _cbc_cipher New cipher algorithm + * @v _raw_cipher Underlying cipher algorithm + * @v _raw_context Context structure for the underlying cipher + * @v _blocksize Cipher block size + */ +#define CBC_CIPHER( _cbc_name, _cbc_cipher, _raw_cipher, _raw_context, \ + _blocksize ) \ +struct _cbc_name ## _context { \ + _raw_context raw_ctx; \ + uint8_t cbc_ctx[_blocksize]; \ +}; \ +static int _cbc_name ## _setkey ( void *ctx, const void *key, \ + size_t keylen ) { \ + struct _cbc_name ## _context * _cbc_name ## _ctx = ctx; \ + return cbc_setkey ( &_cbc_name ## _ctx->raw_ctx, key, keylen, \ + &_raw_cipher, &_cbc_name ## _ctx->cbc_ctx );\ +} \ +static void _cbc_name ## _setiv ( void *ctx, const void *iv ) { \ + struct _cbc_name ## _context * _cbc_name ## _ctx = ctx; \ + cbc_setiv ( &_cbc_name ## _ctx->raw_ctx, iv, \ + &_raw_cipher, &aes_cbc_ctx->cbc_ctx ); \ +} \ +static void _cbc_name ## _encrypt ( void *ctx, const void *src, \ + void *dst, size_t len ) { \ + struct _cbc_name ## _context * _cbc_name ## _ctx = ctx; \ + cbc_encrypt ( &_cbc_name ## _ctx->raw_ctx, src, dst, len, \ + &_raw_cipher, &aes_cbc_ctx->cbc_ctx ); \ +} \ +static void _cbc_name ## _decrypt ( void *ctx, const void *src, \ + void *dst, size_t len ) { \ + struct _cbc_name ## _context * _cbc_name ## _ctx = ctx; \ + cbc_decrypt ( &_cbc_name ## _ctx->raw_ctx, src, dst, len, \ + &_raw_cipher, &aes_cbc_ctx->cbc_ctx ); \ +} \ +struct cipher_algorithm _cbc_cipher = { \ + .name = #_cbc_name, \ + .ctxsize = sizeof ( struct _cbc_name ## _context ), \ + .blocksize = _blocksize, \ + .setkey = _cbc_name ## _setkey, \ + .setiv = _cbc_name ## _setiv, \ + .encrypt = _cbc_name ## _encrypt, \ + .decrypt = _cbc_name ## _decrypt, \ +}; + +#endif /* _GPXE_CBC_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/chap.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/chap.h new file mode 100644 index 0000000..e86ede3 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/chap.h @@ -0,0 +1,53 @@ +#ifndef _GPXE_CHAP_H +#define _GPXE_CHAP_H + +/** @file + * + * CHAP protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/md5.h> + +struct digest_algorithm; + +/** A CHAP response */ +struct chap_response { + /** Digest algorithm used for the response */ + struct digest_algorithm *digest; + /** Context used by the digest algorithm */ + uint8_t *digest_context; + /** CHAP response */ + uint8_t *response; + /** Length of CHAP response */ + size_t response_len; +}; + +extern int chap_init ( struct chap_response *chap, + struct digest_algorithm *digest ); +extern void chap_update ( struct chap_response *chap, const void *data, + size_t len ); +extern void chap_respond ( struct chap_response *chap ); +extern void chap_finish ( struct chap_response *chap ); + +/** + * Add identifier data to the CHAP challenge + * + * @v chap CHAP response + * @v identifier CHAP identifier + * + * The CHAP identifier is the first byte of the CHAP challenge. This + * function is a notational convenience for calling chap_update() for + * the identifier byte. + */ +static inline void chap_set_identifier ( struct chap_response *chap, + unsigned int identifier ) { + uint8_t ident_byte = identifier; + + chap_update ( chap, &ident_byte, sizeof ( ident_byte ) ); +} + +#endif /* _GPXE_CHAP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/command.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/command.h new file mode 100644 index 0000000..51ca6d6 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/command.h @@ -0,0 +1,26 @@ +#ifndef _GPXE_COMMAND_H +#define _GPXE_COMMAND_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/tables.h> + +/** A command-line command */ +struct command { + /** Name of the command */ + const char *name; + /** + * Function implementing the command + * + * @v argc Argument count + * @v argv Argument list + * @ret rc Return status code + */ + int ( * exec ) ( int argc, char **argv ); +}; + +#define COMMANDS __table ( struct command, "commands" ) + +#define __command __table_entry ( COMMANDS, 01 ) + +#endif /* _GPXE_COMMAND_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/cpio.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/cpio.h new file mode 100644 index 0000000..f462cec --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/cpio.h @@ -0,0 +1,53 @@ +#ifndef _GPXE_CPIO_H +#define _GPXE_CPIO_H + +/** @file + * + * CPIO archives + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** A CPIO archive header + * + * All field are hexadecimal ASCII numbers padded with '0' on the + * left to the full width of the field. + */ +struct cpio_header { + /** The string "070701" or "070702" */ + char c_magic[6]; + /** File inode number */ + char c_ino[8]; + /** File mode and permissions */ + char c_mode[8]; + /** File uid */ + char c_uid[8]; + /** File gid */ + char c_gid[8]; + /** Number of links */ + char c_nlink[8]; + /** Modification time */ + char c_mtime[8]; + /** Size of data field */ + char c_filesize[8]; + /** Major part of file device number */ + char c_maj[8]; + /** Minor part of file device number */ + char c_min[8]; + /** Major part of device node reference */ + char c_rmaj[8]; + /** Minor part of device node reference */ + char c_rmin[8]; + /** Length of filename, including final NUL */ + char c_namesize[8]; + /** Checksum of data field if c_magic is 070702, othersize zero */ + char c_chksum[8]; +} __attribute__ (( packed )); + +/** CPIO magic */ +#define CPIO_MAGIC "070701" + +extern void cpio_set_field ( char *field, unsigned long value ); + +#endif /* _GPXE_CPIO_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/crypto.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/crypto.h new file mode 100644 index 0000000..3831b79 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/crypto.h @@ -0,0 +1,154 @@ +#ifndef _GPXE_CRYPTO_H +#define _GPXE_CRYPTO_H + +/** @file + * + * Cryptographic API + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <stddef.h> + +/** A message digest algorithm */ +struct digest_algorithm { + /** Algorithm name */ + const char *name; + /** Context size */ + size_t ctxsize; + /** Block size */ + size_t blocksize; + /** Digest size */ + size_t digestsize; + /** Initialise digest + * + * @v ctx Context + */ + void ( * init ) ( void *ctx ); + /** Update digest with new data + * + * @v ctx Context + * @v src Data to digest + * @v len Length of data + * + * @v len is not necessarily a multiple of @c blocksize. + */ + void ( * update ) ( void *ctx, const void *src, size_t len ); + /** Finalise digest + * + * @v ctx Context + * @v out Buffer for digest output + */ + void ( * final ) ( void *ctx, void *out ); +}; + +/** A cipher algorithm */ +struct cipher_algorithm { + /** Algorithm name */ + const char *name; + /** Context size */ + size_t ctxsize; + /** Block size */ + size_t blocksize; + /** Set key + * + * @v ctx Context + * @v key Key + * @v keylen Key length + * @ret rc Return status code + */ + int ( * setkey ) ( void *ctx, const void *key, size_t keylen ); + /** Set initialisation vector + * + * @v ctx Context + * @v iv Initialisation vector + */ + void ( * setiv ) ( void *ctx, const void *iv ); + /** Encrypt data + * + * @v ctx Context + * @v src Data to encrypt + * @v dst Buffer for encrypted data + * @v len Length of data + * + * @v len is guaranteed to be a multiple of @c blocksize. + */ + void ( * encrypt ) ( void *ctx, const void *src, void *dst, + size_t len ); + /** Decrypt data + * + * @v ctx Context + * @v src Data to decrypt + * @v dst Buffer for decrypted data + * @v len Length of data + * + * @v len is guaranteed to be a multiple of @c blocksize. + */ + void ( * decrypt ) ( void *ctx, const void *src, void *dst, + size_t len ); +}; + +/** A public key algorithm */ +struct pubkey_algorithm { + /** Algorithm name */ + const char *name; + /** Context size */ + size_t ctxsize; +}; + +static inline void digest_init ( struct digest_algorithm *digest, + void *ctx ) { + digest->init ( ctx ); +} + +static inline void digest_update ( struct digest_algorithm *digest, + void *ctx, const void *data, size_t len ) { + digest->update ( ctx, data, len ); +} + +static inline void digest_final ( struct digest_algorithm *digest, + void *ctx, void *out ) { + digest->final ( ctx, out ); +} + +static inline int cipher_setkey ( struct cipher_algorithm *cipher, + void *ctx, const void *key, size_t keylen ) { + return cipher->setkey ( ctx, key, keylen ); +} + +static inline void cipher_setiv ( struct cipher_algorithm *cipher, + void *ctx, const void *iv ) { + cipher->setiv ( ctx, iv ); +} + +static inline void cipher_encrypt ( struct cipher_algorithm *cipher, + void *ctx, const void *src, void *dst, + size_t len ) { + cipher->encrypt ( ctx, src, dst, len ); +} +#define cipher_encrypt( cipher, ctx, src, dst, len ) do { \ + assert ( ( len & ( (cipher)->blocksize - 1 ) ) == 0 ); \ + cipher_encrypt ( (cipher), (ctx), (src), (dst), (len) ); \ + } while ( 0 ) + +static inline void cipher_decrypt ( struct cipher_algorithm *cipher, + void *ctx, const void *src, void *dst, + size_t len ) { + cipher->decrypt ( ctx, src, dst, len ); +} +#define cipher_decrypt( cipher, ctx, src, dst, len ) do { \ + assert ( ( len & ( (cipher)->blocksize - 1 ) ) == 0 ); \ + cipher_decrypt ( (cipher), (ctx), (src), (dst), (len) ); \ + } while ( 0 ) + +static inline int is_stream_cipher ( struct cipher_algorithm *cipher ) { + return ( cipher->blocksize == 1 ); +} + +extern struct digest_algorithm digest_null; +extern struct cipher_algorithm cipher_null; +extern struct pubkey_algorithm pubkey_null; + +#endif /* _GPXE_CRYPTO_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcp.h new file mode 100644 index 0000000..2d9f885 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcp.h @@ -0,0 +1,618 @@ +#ifndef _GPXE_DHCP_H +#define _GPXE_DHCP_H + +/** @file + * + * Dynamic Host Configuration Protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/in.h> +#include <gpxe/list.h> +#include <gpxe/refcnt.h> +#include <gpxe/tables.h> +#include <gpxe/uuid.h> +#include <gpxe/netdevice.h> + +struct job_interface; +struct dhcp_options; +struct dhcp_packet; + +/** BOOTP/DHCP server port */ +#define BOOTPS_PORT 67 + +/** BOOTP/DHCP client port */ +#define BOOTPC_PORT 68 + +/** PXE server port */ +#define PXE_PORT 4011 + +/** Construct a tag value for an encapsulated option + * + * This tag value can be passed to Etherboot functions when searching + * for DHCP options in order to search for a tag within an + * encapsulated options block. + */ +#define DHCP_ENCAP_OPT( encapsulator, encapsulated ) \ + ( ( (encapsulator) << 8 ) | (encapsulated) ) +/** Extract encapsulating option block tag from encapsulated tag value */ +#define DHCP_ENCAPSULATOR( encap_opt ) ( (encap_opt) >> 8 ) +/** Extract encapsulated option tag from encapsulated tag value */ +#define DHCP_ENCAPSULATED( encap_opt ) ( (encap_opt) & 0xff ) +/** Option is encapsulated */ +#define DHCP_IS_ENCAP_OPT( opt ) DHCP_ENCAPSULATOR( opt ) + +/** + * @defgroup dhcpopts DHCP option tags + * @{ + */ + +/** Padding + * + * This tag does not have a length field; it is always only a single + * byte in length. + */ +#define DHCP_PAD 0 + +/** Minimum normal DHCP option */ +#define DHCP_MIN_OPTION 1 + +/** Subnet mask */ +#define DHCP_SUBNET_MASK 1 + +/** Routers */ +#define DHCP_ROUTERS 3 + +/** DNS servers */ +#define DHCP_DNS_SERVERS 6 + +/** Syslog servers */ +#define DHCP_LOG_SERVERS 7 + +/** Host name */ +#define DHCP_HOST_NAME 12 + +/** Domain name */ +#define DHCP_DOMAIN_NAME 15 + +/** Root path */ +#define DHCP_ROOT_PATH 17 + +/** Vendor encapsulated options */ +#define DHCP_VENDOR_ENCAP 43 + +/** PXE boot server discovery control */ +#define DHCP_PXE_DISCOVERY_CONTROL DHCP_ENCAP_OPT ( DHCP_VENDOR_ENCAP, 6 ) + +/** PXE boot server discovery control bits */ +enum dhcp_pxe_discovery_control { + /** Inhibit broadcast discovery */ + PXEBS_NO_BROADCAST = 1, + /** Inhibit multicast discovery */ + PXEBS_NO_MULTICAST = 2, + /** Accept only servers in DHCP_PXE_BOOT_SERVERS list */ + PXEBS_NO_UNKNOWN_SERVERS = 4, + /** Skip discovery if filename present */ + PXEBS_SKIP = 8, +}; + +/** PXE boot server multicast address */ +#define DHCP_PXE_BOOT_SERVER_MCAST DHCP_ENCAP_OPT ( DHCP_VENDOR_ENCAP, 7 ) + +/** PXE boot servers */ +#define DHCP_PXE_BOOT_SERVERS DHCP_ENCAP_OPT ( DHCP_VENDOR_ENCAP, 8 ) + +/** PXE boot server */ +struct dhcp_pxe_boot_server { + /** "Type" */ + uint16_t type; + /** Number of IPv4 addresses */ + uint8_t num_ip; + /** IPv4 addresses */ + struct in_addr ip[0]; +} __attribute__ (( packed )); + +/** PXE boot menu */ +#define DHCP_PXE_BOOT_MENU DHCP_ENCAP_OPT ( DHCP_VENDOR_ENCAP, 9 ) + +/** PXE boot menu */ +struct dhcp_pxe_boot_menu { + /** "Type" */ + uint16_t type; + /** Description length */ + uint8_t desc_len; + /** Description */ + char desc[0]; +} __attribute__ (( packed )); + +/** PXE boot menu prompt */ +#define DHCP_PXE_BOOT_MENU_PROMPT DHCP_ENCAP_OPT ( DHCP_VENDOR_ENCAP, 10 ) + +/** PXE boot menu prompt */ +struct dhcp_pxe_boot_menu_prompt { + /** Timeout + * + * A value of 0 means "time out immediately and select first + * boot item, without displaying the prompt". A value of 255 + * means "display menu immediately with no timeout". Any + * other value means "display prompt, wait this many seconds + * for keypress, if key is F8, display menu, otherwise select + * first boot item". + */ + uint8_t timeout; + /** Prompt to press F8 */ + char prompt[0]; +} __attribute__ (( packed )); + +/** PXE boot menu item */ +#define DHCP_PXE_BOOT_MENU_ITEM DHCP_ENCAP_OPT ( DHCP_VENDOR_ENCAP, 71 ) + +/** PXE boot menu item */ +struct dhcp_pxe_boot_menu_item { + /** "Type" + * + * This field actually identifies the specific boot server (or + * cluster of boot servers offering identical boot files). + */ + uint16_t type; + /** "Layer" + * + * Just don't ask. + */ + uint16_t layer; +} __attribute__ (( packed )); + +/** Requested IP address */ +#define DHCP_REQUESTED_ADDRESS 50 + +/** Lease time */ +#define DHCP_LEASE_TIME 51 + +/** Option overloading + * + * The value of this option is the bitwise-OR of zero or more + * DHCP_OPTION_OVERLOAD_XXX constants. + */ +#define DHCP_OPTION_OVERLOAD 52 + +/** The "file" field is overloaded to contain extra DHCP options */ +#define DHCP_OPTION_OVERLOAD_FILE 1 + +/** The "sname" field is overloaded to contain extra DHCP options */ +#define DHCP_OPTION_OVERLOAD_SNAME 2 + +/** DHCP message type */ +#define DHCP_MESSAGE_TYPE 53 +#define DHCPNONE 0 +#define DHCPDISCOVER 1 +#define DHCPOFFER 2 +#define DHCPREQUEST 3 +#define DHCPDECLINE 4 +#define DHCPACK 5 +#define DHCPNAK 6 +#define DHCPRELEASE 7 +#define DHCPINFORM 8 + +/** DHCP server identifier */ +#define DHCP_SERVER_IDENTIFIER 54 + +/** Parameter request list */ +#define DHCP_PARAMETER_REQUEST_LIST 55 + +/** Maximum DHCP message size */ +#define DHCP_MAX_MESSAGE_SIZE 57 + +/** Vendor class identifier */ +#define DHCP_VENDOR_CLASS_ID 60 + +/** Client identifier */ +#define DHCP_CLIENT_ID 61 + +/** Client identifier */ +struct dhcp_client_id { + /** Link-layer protocol */ + uint8_t ll_proto; + /** Link-layer address */ + uint8_t ll_addr[MAX_LL_ADDR_LEN]; +} __attribute__ (( packed )); + +/** TFTP server name + * + * This option replaces the fixed "sname" field, when that field is + * used to contain overloaded options. + */ +#define DHCP_TFTP_SERVER_NAME 66 + +/** Bootfile name + * + * This option replaces the fixed "file" field, when that field is + * used to contain overloaded options. + */ +#define DHCP_BOOTFILE_NAME 67 + +/** User class identifier */ +#define DHCP_USER_CLASS_ID 77 + +/** Client system architecture */ +#define DHCP_CLIENT_ARCHITECTURE 93 + +/** Client network device interface */ +#define DHCP_CLIENT_NDI 94 + +/** UUID client identifier */ +#define DHCP_CLIENT_UUID 97 + +/** UUID client identifier */ +struct dhcp_client_uuid { + /** Identifier type */ + uint8_t type; + /** UUID */ + union uuid uuid; +} __attribute__ (( packed )); + +#define DHCP_CLIENT_UUID_TYPE 0 + +/** Etherboot-specific encapsulated options + * + * This encapsulated options field is used to contain all options + * specific to Etherboot (i.e. not assigned by IANA or other standards + * bodies). + */ +#define DHCP_EB_ENCAP 175 + +/** Priority of this options block + * + * This is a signed 8-bit integer field indicating the priority of + * this block of options. It can be used to specify the relative + * priority of multiple option blocks (e.g. options from non-volatile + * storage versus options from a DHCP server). + */ +#define DHCP_EB_PRIORITY DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0x01 ) + +/** "Your" IP address + * + * This option is used internally to contain the value of the "yiaddr" + * field, in order to provide a consistent approach to storing and + * processing options. It should never be present in a DHCP packet. + */ +#define DHCP_EB_YIADDR DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0x02 ) + +/** "Server" IP address + * + * This option is used internally to contain the value of the "siaddr" + * field, in order to provide a consistent approach to storing and + * processing options. It should never be present in a DHCP packet. + */ +#define DHCP_EB_SIADDR DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0x03 ) + +/** Keep SAN drive registered + * + * If set to a non-zero value, gPXE will not detach any SAN drive + * after failing to boot from it. (This option is required in order + * to perform a Windows Server 2008 installation direct to an iSCSI + * target.) + */ +#define DHCP_EB_KEEP_SAN DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0x08 ) + +/* + * Tags in the range 0x10-0x7f are reserved for feature markers + * + */ + +/** Skip PXE DHCP protocol extensions such as ProxyDHCP + * + * If set to a non-zero value, gPXE will not wait for ProxyDHCP offers + * and will ignore any PXE-specific DHCP options that it receives. + */ +#define DHCP_EB_NO_PXEDHCP DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xb0 ) + +/** Network device descriptor + * + * Byte 0 is the bus type ID; remaining bytes depend on the bus type. + * + * PCI devices: + * Byte 0 : 1 (PCI) + * Byte 1 : PCI vendor ID MSB + * Byte 2 : PCI vendor ID LSB + * Byte 3 : PCI device ID MSB + * Byte 4 : PCI device ID LSB + */ +#define DHCP_EB_BUS_ID DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xb1 ) + +/** Network device descriptor */ +struct dhcp_netdev_desc { + /** Bus type ID */ + uint8_t type; + /** Vendor ID */ + uint16_t vendor; + /** Device ID */ + uint16_t device; +} __attribute__ (( packed )); + +/** BIOS drive number + * + * This is the drive number for a drive emulated via INT 13. 0x80 is + * the first hard disk, 0x81 is the second hard disk, etc. + */ +#define DHCP_EB_BIOS_DRIVE DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xbd ) + +/** Username + * + * This will be used as the username for any required authentication. + * It is expected that this option's value will be held in + * non-volatile storage, rather than transmitted as part of a DHCP + * packet. + */ +#define DHCP_EB_USERNAME DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xbe ) + +/** Password + * + * This will be used as the password for any required authentication. + * It is expected that this option's value will be held in + * non-volatile storage, rather than transmitted as part of a DHCP + * packet. + */ +#define DHCP_EB_PASSWORD DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xbf ) + +/** Reverse username + * + * This will be used as the reverse username (i.e. the username + * provided by the server) for any required authentication. It is + * expected that this option's value will be held in non-volatile + * storage, rather than transmitted as part of a DHCP packet. + */ +#define DHCP_EB_REVERSE_USERNAME DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xc0 ) + +/** Reverse password + * + * This will be used as the reverse password (i.e. the password + * provided by the server) for any required authentication. It is + * expected that this option's value will be held in non-volatile + * storage, rather than transmitted as part of a DHCP packet. + */ +#define DHCP_EB_REVERSE_PASSWORD DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xc1 ) + +/** gPXE version number */ +#define DHCP_EB_VERSION DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xeb ) + +/** iSCSI primary target IQN */ +#define DHCP_ISCSI_PRIMARY_TARGET_IQN 201 + +/** iSCSI secondary target IQN */ +#define DHCP_ISCSI_SECONDARY_TARGET_IQN 202 + +/** iSCSI initiator IQN */ +#define DHCP_ISCSI_INITIATOR_IQN 203 + +/** Maximum normal DHCP option */ +#define DHCP_MAX_OPTION 254 + +/** End of options + * + * This tag does not have a length field; it is always only a single + * byte in length. + */ +#define DHCP_END 255 + +/** @} */ + +/** + * Count number of arguments to a variadic macro + * + * This rather neat, non-iterative solution is courtesy of Laurent + * Deniau. + * + */ +#define _VA_ARG_COUNT( _1, _2, _3, _4, _5, _6, _7, _8, \ + _9, _10, _11, _12, _13, _14, _15, _16, \ + _17, _18, _19, _20, _21, _22, _23, _24, \ + _25, _26, _27, _28, _29, _30, _31, _32, \ + _33, _34, _35, _36, _37, _38, _39, _40, \ + _41, _42, _43, _44, _45, _46, _47, _48, \ + _49, _50, _51, _52, _53, _54, _55, _56, \ + _57, _58, _59, _60, _61, _62, _63, N, ... ) N +#define VA_ARG_COUNT( ... ) \ + _VA_ARG_COUNT ( __VA_ARGS__, \ + 63, 62, 61, 60, 59, 58, 57, 56, \ + 55, 54, 53, 52, 51, 50, 49, 48, \ + 47, 46, 45, 44, 43, 42, 41, 40, \ + 39, 38, 37, 36, 35, 34, 33, 32, \ + 31, 30, 29, 28, 27, 26, 25, 24, \ + 23, 22, 21, 20, 19, 18, 17, 16, \ + 15, 14, 13, 12, 11, 10, 9, 8, \ + 7, 6, 5, 4, 3, 2, 1, 0 ) + +/** Construct a DHCP option from a list of bytes */ +#define DHCP_OPTION( ... ) VA_ARG_COUNT ( __VA_ARGS__ ), __VA_ARGS__ + +/** Construct a DHCP option from a list of characters */ +#define DHCP_STRING( ... ) DHCP_OPTION ( __VA_ARGS__ ) + +/** Construct a byte-valued DHCP option */ +#define DHCP_BYTE( value ) DHCP_OPTION ( value ) + +/** Construct a word-valued DHCP option */ +#define DHCP_WORD( value ) DHCP_OPTION ( ( ( (value) >> 8 ) & 0xff ), \ + ( ( (value) >> 0 ) & 0xff ) ) + +/** Construct a dword-valued DHCP option */ +#define DHCP_DWORD( value ) DHCP_OPTION ( ( ( (value) >> 24 ) & 0xff ), \ + ( ( (value) >> 16 ) & 0xff ), \ + ( ( (value) >> 8 ) & 0xff ), \ + ( ( (value) >> 0 ) & 0xff ) ) + +/** Construct a DHCP encapsulated options field */ +#define DHCP_ENCAP( ... ) DHCP_OPTION ( __VA_ARGS__, DHCP_END ) + +/** + * A DHCP option + * + * DHCP options consist of a mandatory tag, a length field that is + * mandatory for all options except @c DHCP_PAD and @c DHCP_END, and a + * payload. + */ +struct dhcp_option { + /** Tag + * + * Must be a @c DHCP_XXX value. + */ + uint8_t tag; + /** Length + * + * This is the length of the data field (i.e. excluding the + * tag and length fields). For the two tags @c DHCP_PAD and + * @c DHCP_END, the length field is implicitly zero and is + * also missing, i.e. these DHCP options are only a single + * byte in length. + */ + uint8_t len; + /** Option data */ + uint8_t data[0]; +} __attribute__ (( packed )); + +/** + * Length of a DHCP option header + * + * The header is the portion excluding the data, i.e. the tag and the + * length. + */ +#define DHCP_OPTION_HEADER_LEN ( offsetof ( struct dhcp_option, data ) ) + +/** Maximum length for a single DHCP option */ +#define DHCP_MAX_LEN 0xff + +/** + * A DHCP header + * + */ +struct dhcphdr { + /** Operation + * + * This must be either @c BOOTP_REQUEST or @c BOOTP_REPLY. + */ + uint8_t op; + /** Hardware address type + * + * This is an ARPHRD_XXX constant. Note that ARPHRD_XXX + * constants are nominally 16 bits wide; this could be + * considered to be a bug in the BOOTP/DHCP specification. + */ + uint8_t htype; + /** Hardware address length */ + uint8_t hlen; + /** Number of hops from server */ + uint8_t hops; + /** Transaction ID */ + uint32_t xid; + /** Seconds since start of acquisition */ + uint16_t secs; + /** Flags */ + uint16_t flags; + /** "Client" IP address + * + * This is filled in if the client already has an IP address + * assigned and can respond to ARP requests. + */ + struct in_addr ciaddr; + /** "Your" IP address + * + * This is the IP address assigned by the server to the client. + */ + struct in_addr yiaddr; + /** "Server" IP address + * + * This is the IP address of the next server to be used in the + * boot process. + */ + struct in_addr siaddr; + /** "Gateway" IP address + * + * This is the IP address of the DHCP relay agent, if any. + */ + struct in_addr giaddr; + /** Client hardware address */ + uint8_t chaddr[16]; + /** Server host name (null terminated) + * + * This field may be overridden and contain DHCP options + */ + char sname[64]; + /** Boot file name (null terminated) + * + * This field may be overridden and contain DHCP options + */ + char file[128]; + /** DHCP magic cookie + * + * Must have the value @c DHCP_MAGIC_COOKIE. + */ + uint32_t magic; + /** DHCP options + * + * Variable length; extends to the end of the packet. Minimum + * length (for the sake of sanity) is 1, to allow for a single + * @c DHCP_END tag. + */ + uint8_t options[0]; +}; + +/** Opcode for a request from client to server */ +#define BOOTP_REQUEST 1 + +/** Opcode for a reply from server to client */ +#define BOOTP_REPLY 2 + +/** BOOTP reply must be broadcast + * + * Clients that cannot accept unicast BOOTP replies must set this + * flag. + */ +#define BOOTP_FL_BROADCAST 0x8000 + +/** DHCP magic cookie */ +#define DHCP_MAGIC_COOKIE 0x63825363UL + +/** DHCP minimum packet length + * + * This is the mandated minimum packet length that a DHCP participant + * must be prepared to receive. + */ +#define DHCP_MIN_LEN 552 + +/** Timeouts for sending DHCP packets */ +#define DHCP_MIN_TIMEOUT ( 1 * TICKS_PER_SEC ) +#define DHCP_MAX_TIMEOUT ( 10 * TICKS_PER_SEC ) + +/** Maximum time that we will wait for ProxyDHCP responses */ +#define PROXYDHCP_MAX_TIMEOUT ( 2 * TICKS_PER_SEC ) + +/** Maximum time that we will wait for Boot Server responses */ +#define PXEBS_MAX_TIMEOUT ( 3 * TICKS_PER_SEC ) + +/** Settings block name used for DHCP responses */ +#define DHCP_SETTINGS_NAME "dhcp" + +/** Settings block name used for ProxyDHCP responses */ +#define PROXYDHCP_SETTINGS_NAME "proxydhcp" + +/** Setting block name used for BootServerDHCP responses */ +#define PXEBS_SETTINGS_NAME "pxebs" + +extern void * dhcp_chaddr ( struct net_device *netdev, uint8_t *hlen, + uint16_t *flags ); +extern int dhcp_create_packet ( struct dhcp_packet *dhcppkt, + struct net_device *netdev, uint8_t msgtype, + const void *options, size_t options_len, + void *data, size_t max_len ); +extern int dhcp_create_request ( struct dhcp_packet *dhcppkt, + struct net_device *netdev, + unsigned int msgtype, struct in_addr ciaddr, + void *data, size_t max_len ); +extern int start_dhcp ( struct job_interface *job, struct net_device *netdev ); +extern int start_pxebs ( struct job_interface *job, struct net_device *netdev, + unsigned int pxe_type ); + +#endif /* _GPXE_DHCP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcpopts.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcpopts.h new file mode 100644 index 0000000..3d90f41 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcpopts.h @@ -0,0 +1,34 @@ +#ifndef _GPXE_DHCPOPTS_H +#define _GPXE_DHCPOPTS_H + +/** @file + * + * DHCP options + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/** A DHCP options block */ +struct dhcp_options { + /** Option block raw data */ + void *data; + /** Option block length */ + size_t len; + /** Option block maximum length */ + size_t max_len; +}; + +extern int dhcpopt_store ( struct dhcp_options *options, unsigned int tag, + const void *data, size_t len ); +extern int dhcpopt_extensible_store ( struct dhcp_options *options, + unsigned int tag, + const void *data, size_t len ); +extern int dhcpopt_fetch ( struct dhcp_options *options, unsigned int tag, + void *data, size_t len ); +extern void dhcpopt_init ( struct dhcp_options *options, + void *data, size_t max_len ); + +#endif /* _GPXE_DHCPOPTS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcppkt.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcppkt.h new file mode 100644 index 0000000..6007cca --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/dhcppkt.h @@ -0,0 +1,64 @@ +#ifndef _GPXE_DHCPPKT_H +#define _GPXE_DHCPPKT_H + +/** @file + * + * DHCP packets + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/dhcp.h> +#include <gpxe/dhcpopts.h> +#include <gpxe/refcnt.h> + +/** + * A DHCP packet + * + */ +struct dhcp_packet { + /** Reference counter */ + struct refcnt refcnt; + /** The DHCP packet contents */ + struct dhcphdr *dhcphdr; + /** Maximum length of the DHCP packet buffer */ + size_t max_len; + /** Used length of the DHCP packet buffer */ + size_t len; + /** DHCP options */ + struct dhcp_options options; + /** Settings interface */ + struct settings settings; +}; + +/** + * Increment reference count on DHCP packet + * + * @v dhcppkt DHCP packet + * @ret dhcppkt DHCP packet + */ +static inline __attribute__ (( always_inline )) struct dhcp_packet * +dhcppkt_get ( struct dhcp_packet *dhcppkt ) { + ref_get ( &dhcppkt->refcnt ); + return dhcppkt; +} + +/** + * Decrement reference count on DHCP packet + * + * @v dhcppkt DHCP packet + */ +static inline __attribute__ (( always_inline )) void +dhcppkt_put ( struct dhcp_packet *dhcppkt ) { + ref_put ( &dhcppkt->refcnt ); +} + +extern int dhcppkt_store ( struct dhcp_packet *dhcppkt, unsigned int tag, + const void *data, size_t len ); +extern int dhcppkt_fetch ( struct dhcp_packet *dhcppkt, unsigned int tag, + void *data, size_t len ); +extern void dhcppkt_init ( struct dhcp_packet *dhcppkt, + struct dhcphdr *data, size_t len ); + +#endif /* _GPXE_DHCPPKT_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/dns.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/dns.h new file mode 100644 index 0000000..9e5e874 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/dns.h @@ -0,0 +1,92 @@ +#ifndef _GPXE_DNS_H +#define _GPXE_DNS_H + +/** @file + * + * DNS protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/in.h> + +/* + * Constants + * + */ + +#define DNS_TYPE_A 1 +#define DNS_TYPE_CNAME 5 +#define DNS_TYPE_ANY 255 + +#define DNS_CLASS_IN 1 +#define DNS_CLASS_CS 2 +#define DNS_CLASS_CH 3 +#define DNS_CLASS_HS 4 + +#define DNS_FLAG_QUERY ( 0x00 << 15 ) +#define DNS_FLAG_RESPONSE ( 0x01 << 15 ) +#define DNS_FLAG_QR(flags) ( (flags) & ( 0x01 << 15 ) ) +#define DNS_FLAG_OPCODE_QUERY ( 0x00 << 11 ) +#define DNS_FLAG_OPCODE_IQUERY ( 0x01 << 11 ) +#define DNS_FLAG_OPCODE_STATUS ( 0x02 << 11 ) +#define DNS_FLAG_OPCODE(flags) ( (flags) & ( 0x0f << 11 ) ) +#define DNS_FLAG_RD ( 0x01 << 8 ) +#define DNS_FLAG_RA ( 0x01 << 7 ) +#define DNS_FLAG_RCODE_OK ( 0x00 << 0 ) +#define DNS_FLAG_RCODE_NX ( 0x03 << 0 ) +#define DNS_FLAG_RCODE(flags) ( (flags) & ( 0x0f << 0 ) ) + +#define DNS_PORT 53 +#define DNS_MAX_RETRIES 3 +#define DNS_MAX_CNAME_RECURSION 0x30 + +/* + * DNS protocol structures + * + */ +struct dns_header { + uint16_t id; + uint16_t flags; + uint16_t qdcount; + uint16_t ancount; + uint16_t nscount; + uint16_t arcount; +} __attribute__ (( packed )); + +struct dns_query_info { + uint16_t qtype; + uint16_t qclass; +} __attribute__ (( packed )); + +struct dns_query { + struct dns_header dns; + char payload[ 256 + sizeof ( struct dns_query_info ) ]; +} __attribute__ (( packed )); + +struct dns_rr_info_common { + uint16_t type; + uint16_t class; + uint32_t ttl; + uint16_t rdlength; +} __attribute__ (( packed )); + +struct dns_rr_info_a { + struct dns_rr_info_common common; + struct in_addr in_addr; +} __attribute__ (( packed )); + +struct dns_rr_info_cname { + struct dns_rr_info_common common; + char cname[0]; +} __attribute__ (( packed )); + +union dns_rr_info { + struct dns_rr_info_common common; + struct dns_rr_info_a a; + struct dns_rr_info_cname cname; +}; + +#endif /* _GPXE_DNS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/downloader.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/downloader.h new file mode 100644 index 0000000..7f21e07 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/downloader.h @@ -0,0 +1,19 @@ +#ifndef _GPXE_DOWNLOADER_H +#define _GPXE_DOWNLOADER_H + +/** @file + * + * Image downloader + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct job_interface; +struct image; + +extern int create_downloader ( struct job_interface *job, struct image *image, + int ( * register_image ) ( struct image *image ), + int type, ... ); + +#endif /* _GPXE_DOWNLOADER_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/editbox.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/editbox.h new file mode 100644 index 0000000..b7cc411 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/editbox.h @@ -0,0 +1,61 @@ +#ifndef _GPXE_EDITBOX_H +#define _GPXE_EDITBOX_H + +/** @file + * + * Editable text box widget + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <curses.h> +#include <gpxe/editstring.h> + +/** An editable text box widget */ +struct edit_box { + /** Editable string */ + struct edit_string string; + /** Containing window */ + WINDOW *win; + /** Row */ + unsigned int row; + /** Starting column */ + unsigned int col; + /** Width */ + unsigned int width; + /** First displayed character */ + unsigned int first; + /** Flags */ + unsigned int flags; +}; + +/** Editable text box widget flags */ +enum edit_box_flags { + /** Show stars instead of contents (for password widgets) */ + EDITBOX_STARS = 0x0001, +}; + +extern void init_editbox ( struct edit_box *box, char *buf, size_t len, + WINDOW *win, unsigned int row, unsigned int col, + unsigned int width, unsigned int flags ) + __attribute__ (( nonnull (1, 2) )); +extern void draw_editbox ( struct edit_box *box ) __nonnull; +static inline int edit_editbox ( struct edit_box *box, int key ) __nonnull; + +/** + * Edit text box widget + * + * @v box Editable text box widget + * @v key Key pressed by user + * @ret key Key returned to application, or zero + * + * You must call draw_editbox() to update the display after calling + * edit_editbox(). + * + */ +static inline int edit_editbox ( struct edit_box *box, int key ) { + return edit_string ( &box->string, key ); +} + +#endif /* _GPXE_EDITBOX_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/editstring.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/editstring.h new file mode 100644 index 0000000..48c1baa --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/editstring.h @@ -0,0 +1,33 @@ +#ifndef _GPXE_EDITSTRING_H +#define _GPXE_EDITSTRING_H + +/** @file + * + * Editable strings + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** An editable string */ +struct edit_string { + /** Buffer for string */ + char *buf; + /** Size of buffer (including terminating NUL) */ + size_t len; + /** Cursor position */ + unsigned int cursor; + + /* The following items are the edit history */ + + /** Last cursor position */ + unsigned int last_cursor; + /** Start of modified portion of string */ + unsigned int mod_start; + /** End of modified portion of string */ + unsigned int mod_end; +}; + +extern int edit_string ( struct edit_string *string, int key ) __nonnull; + +#endif /* _GPXE_EDITSTRING_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/eisa.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/eisa.h new file mode 100644 index 0000000..f76e4b9 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/eisa.h @@ -0,0 +1,130 @@ +#ifndef EISA_H +#define EISA_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/isa_ids.h> +#include <gpxe/device.h> +#include <gpxe/tables.h> + +/* + * EISA constants + * + */ + +#define EISA_MIN_SLOT (0x1) +#define EISA_MAX_SLOT (0xf) /* Must be 2^n - 1 */ +#define EISA_SLOT_BASE( n ) ( 0x1000 * (n) ) + +#define EISA_VENDOR_ID ( 0xc80 ) +#define EISA_PROD_ID ( 0xc82 ) +#define EISA_GLOBAL_CONFIG ( 0xc84 ) + +#define EISA_CMD_RESET ( 1 << 2 ) +#define EISA_CMD_ENABLE ( 1 << 0 ) + +/** An EISA device ID list entry */ +struct eisa_device_id { + /** Name */ + const char *name; + /** Manufacturer ID */ + uint16_t vendor_id; + /** Product ID */ + uint16_t prod_id; +}; + +/** An EISA device */ +struct eisa_device { + /** Generic device */ + struct device dev; + /** Slot number */ + unsigned int slot; + /** I/O address */ + uint16_t ioaddr; + /** Manufacturer ID */ + uint16_t vendor_id; + /** Product ID */ + uint16_t prod_id; + /** Driver for this device */ + struct eisa_driver *driver; + /** Driver-private data + * + * Use eisa_set_drvdata() and eisa_get_drvdata() to access + * this field. + */ + void *priv; + /** Driver name */ + const char *driver_name; +}; + +/** An EISA driver */ +struct eisa_driver { + /** EISA ID table */ + struct eisa_device_id *ids; + /** Number of entries in EISA ID table */ + unsigned int id_count; + /** + * Probe device + * + * @v eisa EISA device + * @v id Matching entry in ID table + * @ret rc Return status code + */ + int ( * probe ) ( struct eisa_device *eisa, + const struct eisa_device_id *id ); + /** + * Remove device + * + * @v eisa EISA device + */ + void ( * remove ) ( struct eisa_device *eisa ); +}; + +/** EISA driver table */ +#define EISA_DRIVERS __table ( struct eisa_driver, "eisa_drivers" ) + +/** Declare an EISA driver */ +#define __eisa_driver __table_entry ( EISA_DRIVERS, 01 ) + +extern void eisa_device_enabled ( struct eisa_device *eisa, int enabled ); + +/** + * Enable EISA device + * + * @v eisa EISA device + */ +static inline void enable_eisa_device ( struct eisa_device *eisa ) { + eisa_device_enabled ( eisa, 1 ); +} + +/** + * Disable EISA device + * + * @v eisa EISA device + */ +static inline void disable_eisa_device ( struct eisa_device *eisa ) { + eisa_device_enabled ( eisa, 0 ); +} + +/** + * Set EISA driver-private data + * + * @v eisa EISA device + * @v priv Private data + */ +static inline void eisa_set_drvdata ( struct eisa_device *eisa, void *priv ) { + eisa->priv = priv; +} + +/** + * Get EISA driver-private data + * + * @v eisa EISA device + * @ret priv Private data + */ +static inline void * eisa_get_drvdata ( struct eisa_device *eisa ) { + return eisa->priv; +} + +#endif /* EISA_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/elf.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/elf.h new file mode 100644 index 0000000..da9d2fc --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/elf.h @@ -0,0 +1,17 @@ +#ifndef _GPXE_ELF_H +#define _GPXE_ELF_H + +/** + * @file + * + * ELF image format + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <elf.h> + +extern int elf_load ( struct image *image ); + +#endif /* _GPXE_ELF_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/errfile.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/errfile.h new file mode 100644 index 0000000..482aa78 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/errfile.h @@ -0,0 +1,196 @@ +#ifndef _GPXE_ERRFILE_H +#define _GPXE_ERRFILE_H + +/** @file + * + * Error file identifiers + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <bits/errfile.h> + +/** + * @defgroup errfilecat Error file identifier categories + * + * @{ + */ + +#define ERRFILE_CORE 0x00002000 /**< Core code */ +#define ERRFILE_DRIVER 0x00004000 /**< Driver code */ +#define ERRFILE_NET 0x00006000 /**< Networking code */ +#define ERRFILE_IMAGE 0x00008000 /**< Image code */ +#define ERRFILE_OTHER 0x0000e000 /**< Any other code */ + +/** @} */ + +/** Flag for architecture-dependent error files */ +#define ERRFILE_ARCH 0x00800000 + +/** + * @defgroup errfile Error file identifiers + * + * These values are automatically incorporated into the definitions + * for error numbers such as EINVAL. + * + * @{ + */ + +#define ERRFILE_asprintf ( ERRFILE_CORE | 0x00000000 ) +#define ERRFILE_downloader ( ERRFILE_CORE | 0x00010000 ) +#define ERRFILE_exec ( ERRFILE_CORE | 0x00020000 ) +#define ERRFILE_hw ( ERRFILE_CORE | 0x00030000 ) +#define ERRFILE_iobuf ( ERRFILE_CORE | 0x00040000 ) +#define ERRFILE_job ( ERRFILE_CORE | 0x00050000 ) +#define ERRFILE_linebuf ( ERRFILE_CORE | 0x00060000 ) +#define ERRFILE_monojob ( ERRFILE_CORE | 0x00070000 ) +#define ERRFILE_nvo ( ERRFILE_CORE | 0x00080000 ) +#define ERRFILE_open ( ERRFILE_CORE | 0x00090000 ) +#define ERRFILE_posix_io ( ERRFILE_CORE | 0x000a0000 ) +#define ERRFILE_resolv ( ERRFILE_CORE | 0x000b0000 ) +#define ERRFILE_settings ( ERRFILE_CORE | 0x000c0000 ) +#define ERRFILE_vsprintf ( ERRFILE_CORE | 0x000d0000 ) +#define ERRFILE_xfer ( ERRFILE_CORE | 0x000e0000 ) +#define ERRFILE_bitmap ( ERRFILE_CORE | 0x000f0000 ) + +#define ERRFILE_eisa ( ERRFILE_DRIVER | 0x00000000 ) +#define ERRFILE_isa ( ERRFILE_DRIVER | 0x00010000 ) +#define ERRFILE_isapnp ( ERRFILE_DRIVER | 0x00020000 ) +#define ERRFILE_mca ( ERRFILE_DRIVER | 0x00030000 ) +#define ERRFILE_pci ( ERRFILE_DRIVER | 0x00040000 ) + +#define ERRFILE_nvs ( ERRFILE_DRIVER | 0x00100000 ) +#define ERRFILE_spi ( ERRFILE_DRIVER | 0x00110000 ) +#define ERRFILE_i2c_bit ( ERRFILE_DRIVER | 0x00120000 ) +#define ERRFILE_spi_bit ( ERRFILE_DRIVER | 0x00130000 ) + +#define ERRFILE_3c509 ( ERRFILE_DRIVER | 0x00200000 ) +#define ERRFILE_bnx2 ( ERRFILE_DRIVER | 0x00210000 ) +#define ERRFILE_cs89x0 ( ERRFILE_DRIVER | 0x00220000 ) +#define ERRFILE_eepro ( ERRFILE_DRIVER | 0x00230000 ) +#define ERRFILE_etherfabric ( ERRFILE_DRIVER | 0x00240000 ) +#define ERRFILE_legacy ( ERRFILE_DRIVER | 0x00250000 ) +#define ERRFILE_natsemi ( ERRFILE_DRIVER | 0x00260000 ) +#define ERRFILE_pnic ( ERRFILE_DRIVER | 0x00270000 ) +#define ERRFILE_prism2_pci ( ERRFILE_DRIVER | 0x00280000 ) +#define ERRFILE_prism2_plx ( ERRFILE_DRIVER | 0x00290000 ) +#define ERRFILE_rtl8139 ( ERRFILE_DRIVER | 0x002a0000 ) +#define ERRFILE_smc9000 ( ERRFILE_DRIVER | 0x002b0000 ) +#define ERRFILE_tg3 ( ERRFILE_DRIVER | 0x002c0000 ) +#define ERRFILE_3c509_eisa ( ERRFILE_DRIVER | 0x002d0000 ) +#define ERRFILE_3c515 ( ERRFILE_DRIVER | 0x002e0000 ) +#define ERRFILE_3c529 ( ERRFILE_DRIVER | 0x002f0000 ) +#define ERRFILE_3c595 ( ERRFILE_DRIVER | 0x00300000 ) +#define ERRFILE_3c5x9 ( ERRFILE_DRIVER | 0x00310000 ) +#define ERRFILE_3c90x ( ERRFILE_DRIVER | 0x00320000 ) +#define ERRFILE_amd8111e ( ERRFILE_DRIVER | 0x00330000 ) +#define ERRFILE_davicom ( ERRFILE_DRIVER | 0x00340000 ) +#define ERRFILE_depca ( ERRFILE_DRIVER | 0x00350000 ) +#define ERRFILE_dmfe ( ERRFILE_DRIVER | 0x00360000 ) +#define ERRFILE_eepro100 ( ERRFILE_DRIVER | 0x00380000 ) +#define ERRFILE_epic100 ( ERRFILE_DRIVER | 0x00390000 ) +#define ERRFILE_forcedeth ( ERRFILE_DRIVER | 0x003a0000 ) +#define ERRFILE_mtd80x ( ERRFILE_DRIVER | 0x003b0000 ) +#define ERRFILE_ns83820 ( ERRFILE_DRIVER | 0x003c0000 ) +#define ERRFILE_ns8390 ( ERRFILE_DRIVER | 0x003d0000 ) +#define ERRFILE_pcnet32 ( ERRFILE_DRIVER | 0x003e0000 ) +#define ERRFILE_r8169 ( ERRFILE_DRIVER | 0x003f0000 ) +#define ERRFILE_sis900 ( ERRFILE_DRIVER | 0x00400000 ) +#define ERRFILE_sundance ( ERRFILE_DRIVER | 0x00410000 ) +#define ERRFILE_tlan ( ERRFILE_DRIVER | 0x00420000 ) +#define ERRFILE_tulip ( ERRFILE_DRIVER | 0x00430000 ) +#define ERRFILE_via_rhine ( ERRFILE_DRIVER | 0x00440000 ) +#define ERRFILE_via_velocity ( ERRFILE_DRIVER | 0x00450000 ) +#define ERRFILE_w89c840 ( ERRFILE_DRIVER | 0x00460000 ) +#define ERRFILE_ipoib ( ERRFILE_DRIVER | 0x00470000 ) +#define ERRFILE_e1000 ( ERRFILE_DRIVER | 0x00480000 ) +#define ERRFILE_e1000_hw ( ERRFILE_DRIVER | 0x00490000 ) +#define ERRFILE_mtnic ( ERRFILE_DRIVER | 0x004a0000 ) +#define ERRFILE_phantom ( ERRFILE_DRIVER | 0x004b0000 ) +#define ERRFILE_ne2k_isa ( ERRFILE_DRIVER | 0x004c0000 ) +#define ERRFILE_b44 ( ERRFILE_DRIVER | 0x004d0000 ) +#define ERRFILE_rtl818x ( ERRFILE_DRIVER | 0x004e0000 ) +#define ERRFILE_sky2 ( ERRFILE_DRIVER | 0x004f0000 ) +#define ERRFILE_ath5k ( ERRFILE_DRIVER | 0x00500000 ) +#define ERRFILE_atl1e ( ERRFILE_DRIVER | 0x00510000 ) + +#define ERRFILE_scsi ( ERRFILE_DRIVER | 0x00700000 ) +#define ERRFILE_arbel ( ERRFILE_DRIVER | 0x00710000 ) +#define ERRFILE_hermon ( ERRFILE_DRIVER | 0x00720000 ) +#define ERRFILE_linda ( ERRFILE_DRIVER | 0x00730000 ) +#define ERRFILE_ata ( ERRFILE_DRIVER | 0x00740000 ) +#define ERRFILE_srp ( ERRFILE_DRIVER | 0x00750000 ) + +#define ERRFILE_aoe ( ERRFILE_NET | 0x00000000 ) +#define ERRFILE_arp ( ERRFILE_NET | 0x00010000 ) +#define ERRFILE_dhcpopts ( ERRFILE_NET | 0x00020000 ) +#define ERRFILE_ethernet ( ERRFILE_NET | 0x00030000 ) +#define ERRFILE_icmpv6 ( ERRFILE_NET | 0x00040000 ) +#define ERRFILE_ipv4 ( ERRFILE_NET | 0x00050000 ) +#define ERRFILE_ipv6 ( ERRFILE_NET | 0x00060000 ) +#define ERRFILE_ndp ( ERRFILE_NET | 0x00070000 ) +#define ERRFILE_netdevice ( ERRFILE_NET | 0x00080000 ) +#define ERRFILE_nullnet ( ERRFILE_NET | 0x00090000 ) +#define ERRFILE_tcp ( ERRFILE_NET | 0x000a0000 ) +#define ERRFILE_ftp ( ERRFILE_NET | 0x000b0000 ) +#define ERRFILE_http ( ERRFILE_NET | 0x000c0000 ) +#define ERRFILE_iscsi ( ERRFILE_NET | 0x000d0000 ) +#define ERRFILE_tcpip ( ERRFILE_NET | 0x000e0000 ) +#define ERRFILE_udp ( ERRFILE_NET | 0x000f0000 ) +#define ERRFILE_dhcp ( ERRFILE_NET | 0x00100000 ) +#define ERRFILE_dns ( ERRFILE_NET | 0x00110000 ) +#define ERRFILE_tftp ( ERRFILE_NET | 0x00120000 ) +#define ERRFILE_infiniband ( ERRFILE_NET | 0x00130000 ) +#define ERRFILE_netdev_settings ( ERRFILE_NET | 0x00140000 ) +#define ERRFILE_dhcppkt ( ERRFILE_NET | 0x00150000 ) +#define ERRFILE_slam ( ERRFILE_NET | 0x00160000 ) +#define ERRFILE_ib_sma ( ERRFILE_NET | 0x00170000 ) +#define ERRFILE_ib_packet ( ERRFILE_NET | 0x00180000 ) +#define ERRFILE_icmp ( ERRFILE_NET | 0x00190000 ) +#define ERRFILE_ib_qset ( ERRFILE_NET | 0x001a0000 ) +#define ERRFILE_ib_gma ( ERRFILE_NET | 0x001b0000 ) +#define ERRFILE_ib_pathrec ( ERRFILE_NET | 0x001c0000 ) +#define ERRFILE_ib_mcast ( ERRFILE_NET | 0x001d0000 ) +#define ERRFILE_ib_cm ( ERRFILE_NET | 0x001e0000 ) +#define ERRFILE_net80211 ( ERRFILE_NET | 0x001f0000 ) +#define ERRFILE_ib_mi ( ERRFILE_NET | 0x00200000 ) +#define ERRFILE_ib_cmrc ( ERRFILE_NET | 0x00210000 ) +#define ERRFILE_ib_srp ( ERRFILE_NET | 0x00220000 ) + +#define ERRFILE_image ( ERRFILE_IMAGE | 0x00000000 ) +#define ERRFILE_elf ( ERRFILE_IMAGE | 0x00010000 ) +#define ERRFILE_script ( ERRFILE_IMAGE | 0x00020000 ) +#define ERRFILE_segment ( ERRFILE_IMAGE | 0x00030000 ) +#define ERRFILE_efi_image ( ERRFILE_IMAGE | 0x00040000 ) +#define ERRFILE_embedded ( ERRFILE_IMAGE | 0x00050000 ) + +#define ERRFILE_asn1 ( ERRFILE_OTHER | 0x00000000 ) +#define ERRFILE_chap ( ERRFILE_OTHER | 0x00010000 ) +#define ERRFILE_aoeboot ( ERRFILE_OTHER | 0x00020000 ) +#define ERRFILE_autoboot ( ERRFILE_OTHER | 0x00030000 ) +#define ERRFILE_dhcpmgmt ( ERRFILE_OTHER | 0x00040000 ) +#define ERRFILE_imgmgmt ( ERRFILE_OTHER | 0x00050000 ) +#define ERRFILE_pxe_tftp ( ERRFILE_OTHER | 0x00060000 ) +#define ERRFILE_pxe_udp ( ERRFILE_OTHER | 0x00070000 ) +#define ERRFILE_axtls_aes ( ERRFILE_OTHER | 0x00080000 ) +#define ERRFILE_cipher ( ERRFILE_OTHER | 0x00090000 ) +#define ERRFILE_image_cmd ( ERRFILE_OTHER | 0x000a0000 ) +#define ERRFILE_uri_test ( ERRFILE_OTHER | 0x000b0000 ) +#define ERRFILE_ibft ( ERRFILE_OTHER | 0x000c0000 ) +#define ERRFILE_tls ( ERRFILE_OTHER | 0x000d0000 ) +#define ERRFILE_ifmgmt ( ERRFILE_OTHER | 0x000e0000 ) +#define ERRFILE_iscsiboot ( ERRFILE_OTHER | 0x000f0000 ) +#define ERRFILE_efi_pci ( ERRFILE_OTHER | 0x00100000 ) +#define ERRFILE_efi_snp ( ERRFILE_OTHER | 0x00110000 ) +#define ERRFILE_smbios ( ERRFILE_OTHER | 0x00120000 ) +#define ERRFILE_smbios_settings ( ERRFILE_OTHER | 0x00130000 ) +#define ERRFILE_efi_smbios ( ERRFILE_OTHER | 0x00140000 ) +#define ERRFILE_pxemenu ( ERRFILE_OTHER | 0x00150000 ) +#define ERRFILE_x509 ( ERRFILE_OTHER | 0x00160000 ) +#define ERRFILE_login_ui ( ERRFILE_OTHER | 0x00170000 ) +#define ERRFILE_ib_srpboot ( ERRFILE_OTHER | 0x00180000 ) + +/** @} */ + +#endif /* _GPXE_ERRFILE_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/errortab.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/errortab.h new file mode 100644 index 0000000..35765d4 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/errortab.h @@ -0,0 +1,23 @@ +#ifndef _GPXE_ERRORTAB_H +#define _GPXE_ERRORTAB_H + +/** @file + * + * Error message tables + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/tables.h> + +struct errortab { + int errno; + const char *text; +}; + +#define ERRORTAB __table ( struct errortab, "errortab" ) + +#define __errortab __table_entry ( ERRORTAB, 01 ) + +#endif /* _GPXE_ERRORTAB_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ethernet.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ethernet.h new file mode 100644 index 0000000..8cf6b1b --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ethernet.h @@ -0,0 +1,20 @@ +#ifndef _GPXE_ETHERNET_H +#define _GPXE_ETHERNET_H + +/** @file + * + * Ethernet protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +extern void eth_init_addr ( const void *hw_addr, void *ll_addr ); +extern const char * eth_ntoa ( const void *ll_addr ); +extern int eth_mc_hash ( unsigned int af, const void *net_addr, + void *ll_addr ); +extern struct net_device * alloc_etherdev ( size_t priv_size ); + +#endif /* _GPXE_ETHERNET_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/fakedhcp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/fakedhcp.h new file mode 100644 index 0000000..c603bdc --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/fakedhcp.h @@ -0,0 +1,23 @@ +#ifndef _GPXE_FAKEDHCP_H +#define _GPXE_FAKEDHCP_H + +/** @file + * + * Fake DHCP packets + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +struct net_device; + +extern int create_fakedhcpdiscover ( struct net_device *netdev, + void *data, size_t max_len ); +extern int create_fakedhcpack ( struct net_device *netdev, + void *data, size_t max_len ); +extern int create_fakepxebsack ( struct net_device *netdev, + void *data, size_t max_len ); + +#endif /* _GPXE_FAKEDHCP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/filter.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/filter.h new file mode 100644 index 0000000..1f59fcc --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/filter.h @@ -0,0 +1,75 @@ +#ifndef _GPXE_FILTER_H +#define _GPXE_FILTER_H + +/** @file + * + * Data transfer filters + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stddef.h> +#include <gpxe/xfer.h> + +/** + * Half of a data transfer filter + * + * Embed two of these structures within a structure implementing a + * data transfer filter, and intialise with filter_init(). You can + * then use the filter_xxx() methods as the data transfer interface + * methods as required. + */ +struct xfer_filter_half { + /** Data transfer interface */ + struct xfer_interface xfer; + /** Other half of the data transfer filter */ + struct xfer_filter_half *other; +}; + +/** + * Get data transfer interface for the other half of a data transfer filter + * + * @v xfer Data transfer interface + * @ret other Other half's data transfer interface + */ +static inline __attribute__ (( always_inline )) struct xfer_interface * +filter_other_half ( struct xfer_interface *xfer ) { + struct xfer_filter_half *half = + container_of ( xfer, struct xfer_filter_half, xfer ); + return &half->other->xfer; +} + +extern void filter_close ( struct xfer_interface *xfer, int rc ); +extern int filter_vredirect ( struct xfer_interface *xfer, int type, + va_list args ); +extern size_t filter_window ( struct xfer_interface *xfer ); +extern struct io_buffer * filter_alloc_iob ( struct xfer_interface *xfer, + size_t len ); +extern int filter_deliver_iob ( struct xfer_interface *xfer, + struct io_buffer *iobuf, + struct xfer_metadata *meta ); +extern int filter_deliver_raw ( struct xfer_interface *xfer, const void *data, + size_t len ); + +/** + * Initialise a data transfer filter + * + * @v left "Left" half of the filter + * @v left_op Data transfer interface operations for "left" half + * @v right "Right" half of the filter + * @v right_op Data transfer interface operations for "right" half + * @v refcnt Containing object reference counter, or NULL + */ +static inline void filter_init ( struct xfer_filter_half *left, + struct xfer_interface_operations *left_op, + struct xfer_filter_half *right, + struct xfer_interface_operations *right_op, + struct refcnt *refcnt ) { + xfer_init ( &left->xfer, left_op, refcnt ); + xfer_init ( &right->xfer, right_op, refcnt ); + left->other = right; + right->other = left; +} + +#endif /* _GPXE_FILTER_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ftp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ftp.h new file mode 100644 index 0000000..93194f6 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ftp.h @@ -0,0 +1,15 @@ +#ifndef _GPXE_FTP_H +#define _GPXE_FTP_H + +/** @file + * + * File transfer protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** FTP default port */ +#define FTP_PORT 21 + +#endif /* _GPXE_FTP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbserial.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbserial.h new file mode 100644 index 0000000..2613ab4 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbserial.h @@ -0,0 +1,21 @@ +#ifndef _GPXE_GDBSERIAL_H +#define _GPXE_GDBSERIAL_H + +/** @file + * + * GDB remote debugging over serial + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct gdb_transport; + +/** + * Set up the serial transport + * + * @ret transport suitable for starting the GDB stub or NULL on error + */ +struct gdb_transport *gdbserial_configure ( void ); + +#endif /* _GPXE_GDBSERIAL_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbstub.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbstub.h new file mode 100644 index 0000000..8f9b7c1 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbstub.h @@ -0,0 +1,77 @@ +#ifndef _GPXE_GDBSTUB_H +#define _GPXE_GDBSTUB_H + +/** @file + * + * GDB remote debugging + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/tables.h> +#include <gdbmach.h> + +/** + * A transport mechanism for the GDB protocol + * + */ +struct gdb_transport { + /** Transport name */ + const char *name; + /** + * Set up the transport given a list of arguments + * + * @v argc Number of arguments + * @v argv Argument list + * @ret Return status code + * + * Note that arguments start at argv[0]. + */ + int ( * init ) ( int argc, char **argv ); + /** + * Perform a blocking read + * + * @v buf Buffer + * @v len Size of buffer + * @ret Number of bytes read into buffer + */ + size_t ( * recv ) ( char *buf, size_t len ); + /** + * Write, may block + * + * @v buf Buffer + * @v len Size of buffer + */ + void ( * send ) ( const char *buf, size_t len ); +}; + +#define GDB_TRANSPORTS __table ( struct gdb_transport, "gdb_transports" ) + +#define __gdb_transport __table_entry ( GDB_TRANSPORTS, 01 ) + +/** + * Look up GDB transport by name + * + * @v name Name of transport + * @ret GDB transport or NULL + */ +extern struct gdb_transport *find_gdb_transport ( const char *name ); + +/** + * Break into the debugger using the given transport + * + * @v trans GDB transport + */ +extern void gdbstub_start ( struct gdb_transport *trans ); + +/** + * Interrupt handler + * + * @signo POSIX signal number + * @regs CPU register snapshot + **/ +extern void gdbstub_handler ( int signo, gdbreg_t *regs ); + +#endif /* _GPXE_GDBSTUB_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbudp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbudp.h new file mode 100644 index 0000000..5f02faa --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/gdbudp.h @@ -0,0 +1,24 @@ +#ifndef _GPXE_GDBUDP_H +#define _GPXE_GDBUDP_H + +/** @file + * + * GDB remote debugging over UDP + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct sockaddr_in; +struct gdb_transport; + +/** + * Set up the UDP transport with network address + * + * @name network device name + * @addr IP address and UDP listen port, may be NULL and fields may be zero + * @ret transport suitable for starting the GDB stub or NULL on error + */ +struct gdb_transport *gdbudp_configure ( const char *name, struct sockaddr_in *addr ); + +#endif /* _GPXE_GDBUDP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/hidemem.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/hidemem.h new file mode 100644 index 0000000..01b3fc2 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/hidemem.h @@ -0,0 +1,17 @@ +#ifndef _GPXE_HIDEMEM_H +#define _GPXE_HIDEMEM_H + +/** + * @file + * + * Hidden memory regions + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +extern void hide_umalloc ( physaddr_t start, physaddr_t end ); + +#endif /* _GPXE_HIDEMEM_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/hmac.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/hmac.h new file mode 100644 index 0000000..cb001b9 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/hmac.h @@ -0,0 +1,32 @@ +#ifndef _GPXE_HMAC_H +#define _GPXE_HMAC_H + +/** @file + * + * Keyed-Hashing for Message Authentication + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/crypto.h> + +/** + * Update HMAC + * + * @v digest Digest algorithm to use + * @v digest_ctx Digest context + * @v data Data + * @v len Length of data + */ +static inline void hmac_update ( struct digest_algorithm *digest, + void *digest_ctx, const void *data, + size_t len ) { + digest_update ( digest, digest_ctx, data, len ); +} + +extern void hmac_init ( struct digest_algorithm *digest, void *digest_ctx, + void *key, size_t *key_len ); +extern void hmac_final ( struct digest_algorithm *digest, void *digest_ctx, + void *key, size_t *key_len, void *hmac ); + +#endif /* _GPXE_HMAC_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/http.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/http.h new file mode 100644 index 0000000..baa6d83 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/http.h @@ -0,0 +1,23 @@ +#ifndef _GPXE_HTTP_H +#define _GPXE_HTTP_H + +/** @file + * + * Hyper Text Transport Protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** HTTP default port */ +#define HTTP_PORT 80 + +/** HTTPS default port */ +#define HTTPS_PORT 443 + +extern int http_open_filter ( struct xfer_interface *xfer, struct uri *uri, + unsigned int default_port, + int ( * filter ) ( struct xfer_interface *, + struct xfer_interface ** ) ); + +#endif /* _GPXE_HTTP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/i2c.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/i2c.h new file mode 100644 index 0000000..87b89d4 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/i2c.h @@ -0,0 +1,171 @@ +#ifndef _GPXE_I2C_H +#define _GPXE_I2C_H + +/** @file + * + * I2C interface + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/bitbash.h> + +/** An I2C device + * + * An I2C device represents a specific slave device on an I2C bus. It + * is accessed via an I2C interface. + */ +struct i2c_device { + /** Address of this device + * + * The actual address sent on the bus will look like + * + * <start> <device address> <word address overflow> <r/w> + * + * The "word address overflow" is any excess bits from the + * word address, i.e. any portion that does not fit within the + * defined word address length. + */ + unsigned int dev_addr; + /** Device address length, in bytes + * + * This is the number of bytes that comprise the device + * address, defined to be the portion that terminates with the + * read/write bit. + */ + unsigned int dev_addr_len; + /** Word adddress length, in bytes + * + * This is the number of bytes that comprise the word address, + * defined to be the portion that starts after the read/write + * bit and ends before the first data byte. + * + * For some devices, this length will be zero (i.e. the word + * address is contained entirely within the "word address + * overflow"). + */ + unsigned int word_addr_len; +}; + +/** An I2C interface + * + * An I2C interface provides access to an I2C bus, via which I2C + * devices may be reached. + */ +struct i2c_interface { + /** + * Read data from I2C device + * + * @v i2c I2C interface + * @v i2cdev I2C device + * @v offset Starting offset within the device + * @v data Data buffer + * @v len Length of data buffer + * @ret rc Return status code + */ + int ( * read ) ( struct i2c_interface *i2c, struct i2c_device *i2cdev, + unsigned int offset, uint8_t *data, + unsigned int len ); + /** + * Write data to I2C device + * + * @v i2c I2C interface + * @v i2cdev I2C device + * @v offset Starting offset within the device + * @v data Data buffer + * @v len Length of data buffer + * @ret rc Return status code + */ + int ( * write ) ( struct i2c_interface *i2c, struct i2c_device *i2cdev, + unsigned int offset, const uint8_t *data, + unsigned int len ); +}; + +/** A bit-bashing I2C interface + * + * This provides a standardised way to construct I2C buses via a + * bit-bashing interface. + */ +struct i2c_bit_basher { + /** I2C interface */ + struct i2c_interface i2c; + /** Bit-bashing interface */ + struct bit_basher basher; +}; + +/** Ten-bit address marker + * + * This value is ORed with the I2C device address to indicate a + * ten-bit address format on the bus. + */ +#define I2C_TENBIT_ADDRESS 0x7800 + +/** An I2C write command */ +#define I2C_WRITE 0 + +/** An I2C read command */ +#define I2C_READ 1 + +/** Bit indices used for I2C bit-bashing interface */ +enum { + /** Serial clock */ + I2C_BIT_SCL = 0, + /** Serial data */ + I2C_BIT_SDA, +}; + +/** Delay required for bit-bashing operation */ +#define I2C_UDELAY 5 + +/** Maximum number of cycles to use when attempting a bus reset */ +#define I2C_RESET_MAX_CYCLES 32 + +/** + * Check presence of I2C device + * + * @v i2c I2C interface + * @v i2cdev I2C device + * @ret rc Return status code + * + * Checks for the presence of the device on the I2C bus by attempting + * a zero-length write. + */ +static inline int i2c_check_presence ( struct i2c_interface *i2c, + struct i2c_device *i2cdev ) { + return i2c->write ( i2c, i2cdev, 0, NULL, 0 ); +} + +extern int init_i2c_bit_basher ( struct i2c_bit_basher *i2cbit, + struct bit_basher_operations *bash_op ); + +/** + * Initialise generic I2C EEPROM device + * + * @v i2cdev I2C device + */ +static inline __always_inline void +init_i2c_eeprom ( struct i2c_device *i2cdev, unsigned int dev_addr ) { + i2cdev->dev_addr = dev_addr; + i2cdev->dev_addr_len = 1; + i2cdev->word_addr_len = 1; +} + +/** + * Initialise Atmel AT24C11 + * + * @v i2cdev I2C device + */ +static inline __always_inline void +init_at24c11 ( struct i2c_device *i2cdev ) { + /* This chip has no device address; it must be the only chip + * on the bus. The word address is contained entirely within + * the device address field. + */ + i2cdev->dev_addr = 0; + i2cdev->dev_addr_len = 1; + i2cdev->word_addr_len = 0; +} + +#endif /* _GPXE_I2C_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_cm.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_cm.h new file mode 100644 index 0000000..670fffd --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_cm.h @@ -0,0 +1,72 @@ +#ifndef _GPXE_IB_CM_H +#define _GPXE_IB_CM_H + +/** @file + * + * Infiniband communication management + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/infiniband.h> +#include <gpxe/retry.h> + +struct ib_mad_transaction; +struct ib_connection; + +/** Infiniband connection operations */ +struct ib_connection_operations { + /** Handle change of connection status + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @v conn Connection + * @v rc Connection status code + * @v private_data Private data, if available + * @v private_data_len Length of private data + */ + void ( * changed ) ( struct ib_device *ibdev, struct ib_queue_pair *qp, + struct ib_connection *conn, int rc, + void *private_data, size_t private_data_len ); +}; + +/** An Infiniband connection */ +struct ib_connection { + /** Infiniband device */ + struct ib_device *ibdev; + /** Queue pair */ + struct ib_queue_pair *qp; + /** Local communication ID */ + uint32_t local_id; + /** Remote communication ID */ + uint32_t remote_id; + /** Target service ID */ + struct ib_gid_half service_id; + /** Connection operations */ + struct ib_connection_operations *op; + + /** List of connections */ + struct list_head list; + + /** Path to target */ + struct ib_path *path; + /** Connection request management transaction */ + struct ib_mad_transaction *madx; + + /** Length of connection request private data */ + size_t private_data_len; + /** Connection request private data */ + uint8_t private_data[0]; +}; + +extern struct ib_connection * +ib_create_conn ( struct ib_device *ibdev, struct ib_queue_pair *qp, + struct ib_gid *dgid, struct ib_gid_half *service_id, + void *req_private_data, size_t req_private_data_len, + struct ib_connection_operations *op ); +extern void ib_destroy_conn ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct ib_connection *conn ); + +#endif /* _GPXE_IB_CM_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_cmrc.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_cmrc.h new file mode 100644 index 0000000..efa741a --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_cmrc.h @@ -0,0 +1,20 @@ +#ifndef _GPXE_IB_CMRC_H +#define _GPXE_IB_CMRC_H + +/** @file + * + * Infiniband Communication-managed Reliable Connections + * + */ + +FILE_LICENCE ( BSD2 ); + +#include <gpxe/infiniband.h> +#include <gpxe/xfer.h> + +extern int ib_cmrc_open ( struct xfer_interface *xfer, + struct ib_device *ibdev, + struct ib_gid *dgid, + struct ib_gid_half *service_id ); + +#endif /* _GPXE_IB_CMRC_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mad.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mad.h new file mode 100644 index 0000000..8b49718 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mad.h @@ -0,0 +1,561 @@ +#ifndef _GPXE_IB_MAD_H +#define _GPXE_IB_MAD_H + +/** @file + * + * Infiniband management datagrams + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/ib_packet.h> + +/***************************************************************************** + * + * Subnet management MADs + * + ***************************************************************************** + */ + +/** A subnet management header + * + * Defined in sections 14.2.1.1 and 14.2.1.2 of the IBA. + */ +struct ib_smp_hdr { + uint64_t mkey; + uint16_t slid; + uint16_t dlid; + uint8_t reserved[28]; +} __attribute__ (( packed )); + +/** Subnet management class version */ +#define IB_SMP_CLASS_VERSION 1 + +/** Subnet management direction bit + * + * This bit resides in the "status" field in the MAD header. + */ +#define IB_SMP_STATUS_D_INBOUND 0x8000 + +/* Subnet management attributes */ +#define IB_SMP_ATTR_NOTICE 0x0002 +#define IB_SMP_ATTR_NODE_DESC 0x0010 +#define IB_SMP_ATTR_NODE_INFO 0x0011 +#define IB_SMP_ATTR_SWITCH_INFO 0x0012 +#define IB_SMP_ATTR_GUID_INFO 0x0014 +#define IB_SMP_ATTR_PORT_INFO 0x0015 +#define IB_SMP_ATTR_PKEY_TABLE 0x0016 +#define IB_SMP_ATTR_SL_TO_VL_TABLE 0x0017 +#define IB_SMP_ATTR_VL_ARB_TABLE 0x0018 +#define IB_SMP_ATTR_LINEAR_FORWARD_TABLE 0x0019 +#define IB_SMP_ATTR_RANDOM_FORWARD_TABLE 0x001A +#define IB_SMP_ATTR_MCAST_FORWARD_TABLE 0x001B +#define IB_SMP_ATTR_SM_INFO 0x0020 +#define IB_SMP_ATTR_VENDOR_DIAG 0x0030 +#define IB_SMP_ATTR_LED_INFO 0x0031 +#define IB_SMP_ATTR_VENDOR_MASK 0xFF00 + +/** + * A Node Description attribute + * + * Defined in section 14.2.5.2 of the IBA + */ +struct ib_node_desc { + char node_string[64]; +} __attribute__ (( packed )); + +/** A Node Information attribute + * + * Defined in section 14.2.5.3 of the IBA. + */ +struct ib_node_info { + uint8_t base_version; + uint8_t class_version; + uint8_t node_type; + uint8_t num_ports; + struct ib_gid_half sys_guid; + struct ib_gid_half node_guid; + struct ib_gid_half port_guid; + uint16_t partition_cap; + uint16_t device_id; + uint32_t revision; + uint8_t local_port_num; + uint8_t vendor_id[3]; +} __attribute__ ((packed)); + +#define IB_NODE_TYPE_HCA 0x01 +#define IB_NODE_TYPE_SWITCH 0x02 +#define IB_NODE_TYPE_ROUTER 0x03 + +/** A GUID Information attribute + * + * Defined in section 14.2.5.5 of the IBA. + */ +struct ib_guid_info { + uint8_t guid[8][8]; +} __attribute__ (( packed )); + +/** A Port Information attribute + * + * Defined in section 14.2.5.6 of the IBA. + */ +struct ib_port_info { + uint64_t mkey; + uint8_t gid_prefix[8]; + uint16_t lid; + uint16_t mastersm_lid; + uint32_t cap_mask; + uint16_t diag_code; + uint16_t mkey_lease_period; + uint8_t local_port_num; + uint8_t link_width_enabled; + uint8_t link_width_supported; + uint8_t link_width_active; + uint8_t link_speed_supported__port_state; + uint8_t port_phys_state__link_down_def_state; + uint8_t mkey_prot_bits__lmc; + uint8_t link_speed_active__link_speed_enabled; + uint8_t neighbour_mtu__mastersm_sl; + uint8_t vl_cap__init_type; + uint8_t vl_high_limit; + uint8_t vl_arbitration_high_cap; + uint8_t vl_arbitration_low_cap; + uint8_t init_type_reply__mtu_cap; + uint8_t vl_stall_count__hoq_life; + uint8_t operational_vls__enforcement; + uint16_t mkey_violations; + uint16_t pkey_violations; + uint16_t qkey_violations; + uint8_t guid_cap; + uint8_t client_reregister__subnet_timeout; + uint8_t resp_time_value; + uint8_t local_phy_errors__overrun_errors; + uint16_t max_credit_hint; + uint32_t link_round_trip_latency; +} __attribute__ (( packed )); + +#define IB_LINK_WIDTH_1X 0x01 +#define IB_LINK_WIDTH_4X 0x02 +#define IB_LINK_WIDTH_8X 0x04 +#define IB_LINK_WIDTH_12X 0x08 + +#define IB_LINK_SPEED_SDR 0x01 +#define IB_LINK_SPEED_DDR 0x02 +#define IB_LINK_SPEED_QDR 0x04 + +#define IB_PORT_STATE_DOWN 0x01 +#define IB_PORT_STATE_INIT 0x02 +#define IB_PORT_STATE_ARMED 0x03 +#define IB_PORT_STATE_ACTIVE 0x04 + +#define IB_PORT_PHYS_STATE_SLEEP 0x01 +#define IB_PORT_PHYS_STATE_POLLING 0x02 + +#define IB_MTU_256 0x01 +#define IB_MTU_512 0x02 +#define IB_MTU_1024 0x03 +#define IB_MTU_2048 0x04 +#define IB_MTU_4096 0x05 + +#define IB_VL_0 0x01 +#define IB_VL_0_1 0x02 +#define IB_VL_0_3 0x03 +#define IB_VL_0_7 0x04 +#define IB_VL_0_14 0x05 + +/** A Partition Key Table attribute + * + * Defined in section 14.2.5.7 of the IBA. + */ +struct ib_pkey_table { + uint16_t pkey[32]; +} __attribute__ (( packed )); + +/** A subnet management attribute */ +union ib_smp_data { + struct ib_node_desc node_desc; + struct ib_node_info node_info; + struct ib_guid_info guid_info; + struct ib_port_info port_info; + struct ib_pkey_table pkey_table; + uint8_t bytes[64]; +} __attribute__ (( packed )); + +/** A subnet management directed route path */ +struct ib_smp_dr_path { + uint8_t hops[64]; +} __attribute__ (( packed )); + +/** Subnet management MAD class-specific data */ +struct ib_smp_class_specific { + uint8_t hop_pointer; + uint8_t hop_count; +} __attribute__ (( packed )); + +/***************************************************************************** + * + * Subnet administration MADs + * + ***************************************************************************** + */ + +#define IB_SA_CLASS_VERSION 2 + +#define IB_SA_METHOD_DELETE_RESP 0x95 + +struct ib_rmpp_hdr { + uint32_t raw[3]; +} __attribute__ (( packed )); + +struct ib_sa_hdr { + uint32_t sm_key[2]; + uint16_t reserved; + uint16_t attrib_offset; + uint32_t comp_mask[2]; +} __attribute__ (( packed )); + +#define IB_SA_ATTR_MC_MEMBER_REC 0x38 +#define IB_SA_ATTR_PATH_REC 0x35 + +struct ib_path_record { + uint32_t reserved0[2]; + struct ib_gid dgid; + struct ib_gid sgid; + uint16_t dlid; + uint16_t slid; + uint32_t hop_limit__flow_label__raw_traffic; + uint32_t pkey__numb_path__reversible__tclass; + uint8_t reserved1; + uint8_t reserved__sl; + uint8_t mtu_selector__mtu; + uint8_t rate_selector__rate; + uint32_t preference__packet_lifetime__packet_lifetime_selector; + uint32_t reserved2[35]; +} __attribute__ (( packed )); + +#define IB_SA_PATH_REC_DGID (1<<2) +#define IB_SA_PATH_REC_SGID (1<<3) + +struct ib_mc_member_record { + struct ib_gid mgid; + struct ib_gid port_gid; + uint32_t qkey; + uint16_t mlid; + uint8_t mtu_selector__mtu; + uint8_t tclass; + uint16_t pkey; + uint8_t rate_selector__rate; + uint8_t packet_lifetime_selector__packet_lifetime; + uint32_t sl__flow_label__hop_limit; + uint8_t scope__join_state; + uint8_t proxy_join__reserved; + uint16_t reserved0; + uint32_t reserved1[37]; +} __attribute__ (( packed )); + +#define IB_SA_MCMEMBER_REC_MGID (1<<0) +#define IB_SA_MCMEMBER_REC_PORT_GID (1<<1) +#define IB_SA_MCMEMBER_REC_QKEY (1<<2) +#define IB_SA_MCMEMBER_REC_MLID (1<<3) +#define IB_SA_MCMEMBER_REC_MTU_SELECTOR (1<<4) +#define IB_SA_MCMEMBER_REC_MTU (1<<5) +#define IB_SA_MCMEMBER_REC_TRAFFIC_CLASS (1<<6) +#define IB_SA_MCMEMBER_REC_PKEY (1<<7) +#define IB_SA_MCMEMBER_REC_RATE_SELECTOR (1<<8) +#define IB_SA_MCMEMBER_REC_RATE (1<<9) +#define IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME_SELECTOR (1<<10) +#define IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME (1<<11) +#define IB_SA_MCMEMBER_REC_SL (1<<12) +#define IB_SA_MCMEMBER_REC_FLOW_LABEL (1<<13) +#define IB_SA_MCMEMBER_REC_HOP_LIMIT (1<<14) +#define IB_SA_MCMEMBER_REC_SCOPE (1<<15) +#define IB_SA_MCMEMBER_REC_JOIN_STATE (1<<16) +#define IB_SA_MCMEMBER_REC_PROXY_JOIN (1<<17) + +union ib_sa_data { + struct ib_path_record path_record; + struct ib_mc_member_record mc_member_record; +} __attribute__ (( packed )); + +/***************************************************************************** + * + * Communication management MADs + * + ***************************************************************************** + */ + +/** Communication management class version */ +#define IB_CM_CLASS_VERSION 2 + +/* Communication management attributes */ +#define IB_CM_ATTR_CLASS_PORT_INFO 0x0001 +#define IB_CM_ATTR_CONNECT_REQUEST 0x0010 +#define IB_CM_ATTR_MSG_RCPT_ACK 0x0011 +#define IB_CM_ATTR_CONNECT_REJECT 0x0012 +#define IB_CM_ATTR_CONNECT_REPLY 0x0013 +#define IB_CM_ATTR_READY_TO_USE 0x0014 +#define IB_CM_ATTR_DISCONNECT_REQUEST 0x0015 +#define IB_CM_ATTR_DISCONNECT_REPLY 0x0016 +#define IB_CM_ATTR_SERVICE_ID_RES_REQ 0x0016 +#define IB_CM_ATTR_SERVICE_ID_RES_REQ_RESP 0x0018 +#define IB_CM_ATTR_LOAD_ALTERNATE_PATH 0x0019 +#define IB_CM_ATTR_ALTERNATE_PATH_RESPONSE 0x001a + +/** Communication management common fields */ +struct ib_cm_common { + /** Local communication ID */ + uint32_t local_id; + /** Remote communication ID */ + uint32_t remote_id; + /** Reserved */ + uint8_t reserved[224]; +} __attribute__ (( packed )); + +/** A communication management path */ +struct ib_cm_path { + /** Local port LID */ + uint16_t local_lid; + /** Remote port LID */ + uint16_t remote_lid; + /** Local port GID */ + struct ib_gid local_gid; + /** Remote port GID */ + struct ib_gid remote_gid; + /** Flow label and rate */ + uint32_t flow_label__rate; + /** Traffic class */ + uint8_t tc; + /** Hop limit */ + uint8_t hop_limit; + /** SL and subnet local*/ + uint8_t sl__subnet_local; + /** Local ACK timeout */ + uint8_t local_ack_timeout; +} __attribute__ (( packed )); + +/** A communication management connection request + * + * Defined in section 12.6.5 of the IBA. + */ +struct ib_cm_connect_request { + /** Local communication ID */ + uint32_t local_id; + /** Reserved */ + uint32_t reserved0[1]; + /** Service ID */ + struct ib_gid_half service_id; + /** Local CA GUID */ + struct ib_gid_half local_ca; + /** Reserved */ + uint32_t reserved1[1]; + /** Local queue key */ + uint32_t local_qkey; + /** Local QPN and responder resources*/ + uint32_t local_qpn__responder_resources; + /** Local EECN and initiator depth */ + uint32_t local_eecn__initiator_depth; + /** Remote EECN, remote CM response timeout, transport service + * type, EE flow control + */ + uint32_t remote_eecn__remote_timeout__service_type__ee_flow_ctrl; + /** Starting PSN, local CM response timeout and retry count */ + uint32_t starting_psn__local_timeout__retry_count; + /** Partition key */ + uint16_t pkey; + /** Path packet payload MTU, RDC exists, RNR retry count */ + uint8_t payload_mtu__rdc_exists__rnr_retry; + /** Max CM retries and SRQ */ + uint8_t max_cm_retries__srq; + /** Primary path */ + struct ib_cm_path primary; + /** Alternate path */ + struct ib_cm_path alternate; + /** Private data */ + uint8_t private_data[92]; +} __attribute__ (( packed )); + +/** CM transport types */ +#define IB_CM_TRANSPORT_RC 0 +#define IB_CM_TRANSPORT_UC 1 +#define IB_CM_TRANSPORT_RD 2 + +/** A communication management connection rejection + * + * Defined in section 12.6.7 of the IBA. + */ +struct ib_cm_connect_reject { + /** Local communication ID */ + uint32_t local_id; + /** Remote communication ID */ + uint32_t remote_id; + /** Message rejected */ + uint8_t message; + /** Reject information length */ + uint8_t info_len; + /** Rejection reason */ + uint16_t reason; + /** Additional rejection information */ + uint8_t info[72]; + /** Private data */ + uint8_t private_data[148]; +} __attribute__ (( packed )); + +/** CM rejection reasons */ +#define IB_CM_REJECT_BAD_SERVICE_ID 8 +#define IB_CM_REJECT_STALE_CONN 10 +#define IB_CM_REJECT_CONSUMER 28 + +/** A communication management connection reply + * + * Defined in section 12.6.8 of the IBA. + */ +struct ib_cm_connect_reply { + /** Local communication ID */ + uint32_t local_id; + /** Remote communication ID */ + uint32_t remote_id; + /** Local queue key */ + uint32_t local_qkey; + /** Local QPN */ + uint32_t local_qpn; + /** Local EECN */ + uint32_t local_eecn; + /** Starting PSN */ + uint32_t starting_psn; + /** Responder resources */ + uint8_t responder_resources; + /** Initiator depth */ + uint8_t initiator_depth; + /** Target ACK delay, failover accepted, and end-to-end flow control */ + uint8_t target_ack_delay__failover_accepted__ee_flow_ctrl; + /** RNR retry count, SRQ */ + uint8_t rnr_retry__srq; + /** Local CA GUID */ + struct ib_gid_half local_ca; + /** Private data */ + uint8_t private_data[196]; +} __attribute__ (( packed )); + +/** A communication management ready to use reply + * + * Defined in section 12.6.9 of the IBA. + */ +struct ib_cm_ready_to_use { + /** Local communication ID */ + uint32_t local_id; + /** Remote communication ID */ + uint32_t remote_id; + /** Private data */ + uint8_t private_data[224]; +} __attribute__ (( packed )); + +/** A communication management attribute */ +union ib_cm_data { + struct ib_cm_common common; + struct ib_cm_connect_request connect_request; + struct ib_cm_connect_reject connect_reject; + struct ib_cm_connect_reply connect_reply; + struct ib_cm_ready_to_use ready_to_use; + uint8_t bytes[232]; +} __attribute__ (( packed )); + +/***************************************************************************** + * + * MADs + * + ***************************************************************************** + */ + +/** Management datagram class_specific data */ +union ib_mad_class_specific { + uint16_t raw; + struct ib_smp_class_specific smp; +} __attribute__ (( packed )); + +/** A management datagram common header + * + * Defined in section 13.4.2 of the IBA. + */ +struct ib_mad_hdr { + uint8_t base_version; + uint8_t mgmt_class; + uint8_t class_version; + uint8_t method; + uint16_t status; + union ib_mad_class_specific class_specific; + uint32_t tid[2]; + uint16_t attr_id; + uint8_t reserved[2]; + uint32_t attr_mod; +} __attribute__ (( packed )); + +/* Management base version */ +#define IB_MGMT_BASE_VERSION 1 + +/* Management classes */ +#define IB_MGMT_CLASS_SUBN_LID_ROUTED 0x01 +#define IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE 0x81 +#define IB_MGMT_CLASS_SUBN_ADM 0x03 +#define IB_MGMT_CLASS_PERF_MGMT 0x04 +#define IB_MGMT_CLASS_BM 0x05 +#define IB_MGMT_CLASS_DEVICE_MGMT 0x06 +#define IB_MGMT_CLASS_CM 0x07 +#define IB_MGMT_CLASS_SNMP 0x08 +#define IB_MGMT_CLASS_VENDOR_RANGE2_START 0x30 +#define IB_MGMT_CLASS_VENDOR_RANGE2_END 0x4f + +#define IB_MGMT_CLASS_MASK 0x7f + +/* Management methods */ +#define IB_MGMT_METHOD_GET 0x01 +#define IB_MGMT_METHOD_SET 0x02 +#define IB_MGMT_METHOD_GET_RESP 0x81 +#define IB_MGMT_METHOD_SEND 0x03 +#define IB_MGMT_METHOD_TRAP 0x05 +#define IB_MGMT_METHOD_REPORT 0x06 +#define IB_MGMT_METHOD_REPORT_RESP 0x86 +#define IB_MGMT_METHOD_TRAP_REPRESS 0x07 +#define IB_MGMT_METHOD_DELETE 0x15 + +/* Status codes */ +#define IB_MGMT_STATUS_OK 0x0000 +#define IB_MGMT_STATUS_BAD_VERSION 0x0001 +#define IB_MGMT_STATUS_UNSUPPORTED_METHOD 0x0002 +#define IB_MGMT_STATUS_UNSUPPORTED_METHOD_ATTR 0x0003 +#define IB_MGMT_STATUS_INVALID_VALUE 0x0004 + +/** A subnet management MAD */ +struct ib_mad_smp { + struct ib_mad_hdr mad_hdr; + struct ib_smp_hdr smp_hdr; + union ib_smp_data smp_data; + struct ib_smp_dr_path initial_path; + struct ib_smp_dr_path return_path; +} __attribute__ (( packed )); + +/** A subnet administration MAD */ +struct ib_mad_sa { + struct ib_mad_hdr mad_hdr; + struct ib_rmpp_hdr rmpp_hdr; + struct ib_sa_hdr sa_hdr; + union ib_sa_data sa_data; +} __attribute__ (( packed )); + +/** A communication management MAD */ +struct ib_mad_cm { + struct ib_mad_hdr mad_hdr; + union ib_cm_data cm_data; +} __attribute__ (( packed )); + +/** A management datagram */ +union ib_mad { + struct ib_mad_hdr hdr; + struct ib_mad_smp smp; + struct ib_mad_sa sa; + struct ib_mad_cm cm; + uint8_t bytes[256]; +} __attribute__ (( packed )); + +#endif /* _GPXE_IB_MAD_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mcast.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mcast.h new file mode 100644 index 0000000..74eccd0 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mcast.h @@ -0,0 +1,48 @@ +#ifndef _GPXE_IB_MCAST_H +#define _GPXE_IB_MCAST_H + +/** @file + * + * Infiniband multicast groups + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/infiniband.h> + +struct ib_mad_transaction; + +/** An Infiniband multicast group membership */ +struct ib_mc_membership { + /** Queue pair */ + struct ib_queue_pair *qp; + /** Multicast GID */ + struct ib_gid gid; + /** Multicast group join transaction */ + struct ib_mad_transaction *madx; + /** Handle join success/failure + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @v membership Multicast group membership + * @v rc Status code + * @v mad Response MAD (or NULL on error) + */ + void ( * complete ) ( struct ib_device *ibdev, struct ib_queue_pair *qp, + struct ib_mc_membership *membership, int rc, + union ib_mad *mad ); +}; + +extern int ib_mcast_join ( struct ib_device *ibdev, struct ib_queue_pair *qp, + struct ib_mc_membership *membership, + struct ib_gid *gid, + void ( * joined ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct ib_mc_membership *memb, + int rc, union ib_mad *mad ) ); + +extern void ib_mcast_leave ( struct ib_device *ibdev, struct ib_queue_pair *qp, + struct ib_mc_membership *membership ); + +#endif /* _GPXE_IB_MCAST_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mi.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mi.h new file mode 100644 index 0000000..b1cf686 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_mi.h @@ -0,0 +1,135 @@ +#ifndef _GPXE_IB_MI_H +#define _GPXE_IB_MI_H + +/** @file + * + * Infiniband management interfaces + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/list.h> +#include <gpxe/retry.h> +#include <gpxe/tables.h> +#include <gpxe/infiniband.h> + +struct ib_mad_interface; +struct ib_mad_transaction; + +/** An Infiniband management agent */ +struct ib_mad_agent { + /** Management class */ + uint8_t mgmt_class; + /** Class version */ + uint8_t class_version; + /** Attribute (in network byte order) */ + uint16_t attr_id; + /** Handle MAD + * + * @v ibdev Infiniband device + * @v mi Management interface + * @v mad Received MAD + * @v av Source address vector + * @ret rc Return status code + */ + void ( * handle ) ( struct ib_device *ibdev, + struct ib_mad_interface *mi, + union ib_mad *mad, + struct ib_address_vector *av ); +}; + +/** Infiniband management agents */ +#define IB_MAD_AGENTS __table ( struct ib_mad_agent, "ib_mad_agents" ) + +/** Declare an Infiniband management agent */ +#define __ib_mad_agent __table_entry ( IB_MAD_AGENTS, 01 ) + +/** Infiniband management transaction operations */ +struct ib_mad_transaction_operations { + /** Handle transaction completion + * + * @v ibdev Infiniband device + * @v mi Management interface + * @v madx Management transaction + * @v rc Status code + * @v mad Received MAD (or NULL on error) + * @v av Source address vector (or NULL on error) + * + * The completion handler should in most cases call + * ib_destroy_madx() to free up the completed transaction. + */ + void ( * complete ) ( struct ib_device *ibdev, + struct ib_mad_interface *mi, + struct ib_mad_transaction *madx, + int rc, union ib_mad *mad, + struct ib_address_vector *av ); +}; + +/** An Infiniband management transaction */ +struct ib_mad_transaction { + /** Associated management interface */ + struct ib_mad_interface *mi; + /** List of transactions */ + struct list_head list; + /** Retry timer */ + struct retry_timer timer; + /** Destination address vector */ + struct ib_address_vector av; + /** MAD being sent */ + union ib_mad mad; + /** Transaction operations */ + struct ib_mad_transaction_operations *op; + /** Owner private data */ + void *owner_priv; +}; + +/** An Infiniband management interface */ +struct ib_mad_interface { + /** Infiniband device */ + struct ib_device *ibdev; + /** Completion queue */ + struct ib_completion_queue *cq; + /** Queue pair */ + struct ib_queue_pair *qp; + /** List of management transactions */ + struct list_head madx; +}; + +/** + * Set Infiniband management transaction owner-private data + * + * @v madx Management transaction + * @v priv Private data + */ +static inline __always_inline void +ib_madx_set_ownerdata ( struct ib_mad_transaction *madx, void *priv ) { + madx->owner_priv = priv; +} + +/** + * Get Infiniband management transaction owner-private data + * + * @v madx Management transaction + * @ret priv Private data + */ +static inline __always_inline void * +ib_madx_get_ownerdata ( struct ib_mad_transaction *madx ) { + return madx->owner_priv; +} + +extern int ib_mi_send ( struct ib_device *ibdev, struct ib_mad_interface *mi, + union ib_mad *mad, struct ib_address_vector *av ); +extern struct ib_mad_transaction * +ib_create_madx ( struct ib_device *ibdev, struct ib_mad_interface *mi, + union ib_mad *mad, struct ib_address_vector *av, + struct ib_mad_transaction_operations *op ); +extern void ib_destroy_madx ( struct ib_device *ibdev, + struct ib_mad_interface *mi, + struct ib_mad_transaction *madx ); +extern struct ib_mad_interface * ib_create_mi ( struct ib_device *ibdev, + enum ib_queue_pair_type type ); +extern void ib_destroy_mi ( struct ib_device *ibdev, + struct ib_mad_interface *mi ); + +#endif /* _GPXE_IB_MI_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_packet.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_packet.h new file mode 100644 index 0000000..d468859 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_packet.h @@ -0,0 +1,147 @@ +#ifndef _GPXE_IB_PACKET_H +#define _GPXE_IB_PACKET_H + +/** @file + * + * Infiniband packet format + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct ib_device; +struct ib_queue_pair; +struct ib_address_vector; +struct io_buffer; + +/** Half of an Infiniband Global Identifier */ +struct ib_gid_half { + union { + uint8_t bytes[8]; + uint16_t words[4]; + uint32_t dwords[2]; + } u; +}; + +/** An Infiniband Global Identifier */ +struct ib_gid { + union { + uint8_t bytes[16]; + uint16_t words[8]; + uint32_t dwords[4]; + struct ib_gid_half half[2]; + } u; +}; + +/** An Infiniband Local Route Header */ +struct ib_local_route_header { + /** Virtual lane and link version */ + uint8_t vl__lver; + /** Service level and next link header */ + uint8_t sl__lnh; + /** Destination LID */ + uint16_t dlid; + /** Packet length */ + uint16_t length; + /** Source LID */ + uint16_t slid; +} __attribute__ (( packed )); + +/** Infiniband virtual lanes */ +enum ib_vl { + IB_VL_DEFAULT = 0, + IB_VL_SMP = 15, +}; + +/** An Infiniband Link Next Header value */ +enum ib_lnh { + IB_LNH_RAW = 0, + IB_LNH_IPv6 = 1, + IB_LNH_BTH = 2, + IB_LNH_GRH = 3 +}; + +/** Default Infiniband LID */ +#define IB_LID_NONE 0xffff + +/** Test for multicast LID */ +#define IB_LID_MULTICAST( lid ) ( ( (lid) >= 0xc000 ) && ( (lid) <= 0xfffe ) ) + +/** An Infiniband Global Route Header */ +struct ib_global_route_header { + /** IP version, traffic class, and flow label + * + * 4 bits : Version of the GRH + * 8 bits : Traffic class + * 20 bits : Flow label + */ + uint32_t ipver__tclass__flowlabel; + /** Payload length */ + uint16_t paylen; + /** Next header */ + uint8_t nxthdr; + /** Hop limit */ + uint8_t hoplmt; + /** Source GID */ + struct ib_gid sgid; + /** Destiniation GID */ + struct ib_gid dgid; +} __attribute__ (( packed )); + +#define IB_GRH_IPVER_IPv6 0x06 +#define IB_GRH_NXTHDR_IBA 0x1b + +/** An Infiniband Base Transport Header */ +struct ib_base_transport_header { + /** Opcode */ + uint8_t opcode; + /** Transport header version, pad count, migration and solicitation */ + uint8_t se__m__padcnt__tver; + /** Partition key */ + uint16_t pkey; + /** Destination queue pair */ + uint32_t dest_qp; + /** Packet sequence number and acknowledge request */ + uint32_t ack__psn; +} __attribute__ (( packed )); + +/** An Infiniband BTH opcode */ +enum ib_bth_opcode { + BTH_OPCODE_UD_SEND = 0x64, +}; + +/** An Infiniband Datagram Extended Transport Header */ +struct ib_datagram_extended_transport_header { + /** Queue key */ + uint32_t qkey; + /** Source queue pair */ + uint32_t src_qp; +} __attribute__ (( packed )); + +/** All known IB header formats */ +union ib_headers { + struct ib_local_route_header lrh; + struct { + struct ib_local_route_header lrh; + struct ib_global_route_header grh; + struct ib_base_transport_header bth; + struct ib_datagram_extended_transport_header deth; + } __attribute__ (( packed )) lrh__grh__bth__deth; + struct { + struct ib_local_route_header lrh; + struct ib_base_transport_header bth; + struct ib_datagram_extended_transport_header deth; + } __attribute__ (( packed )) lrh__bth__deth; +} __attribute__ (( packed )); + +/** Maximum size required for IB headers */ +#define IB_MAX_HEADER_SIZE sizeof ( union ib_headers ) + +extern int ib_push ( struct ib_device *ibdev, struct io_buffer *iobuf, + struct ib_queue_pair *qp, size_t payload_len, + const struct ib_address_vector *av ); +extern int ib_pull ( struct ib_device *ibdev, struct io_buffer *iobuf, + struct ib_queue_pair **qp, size_t *payload_len, + struct ib_address_vector *av ); + +#endif /* _GPXE_IB_PACKET_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_pathrec.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_pathrec.h new file mode 100644 index 0000000..5884d53 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_pathrec.h @@ -0,0 +1,76 @@ +#ifndef _GPXE_IB_PATHREC_H +#define _GPXE_IB_PATHREC_H + +/** @file + * + * Infiniband path records + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/infiniband.h> + +struct ib_mad_transaction; +struct ib_path; + +/** Infiniband path operations */ +struct ib_path_operations { + /** Handle path transaction completion + * + * @v ibdev Infiniband device + * @v path Path + * @v rc Status code + * @v av Address vector, or NULL on error + */ + void ( * complete ) ( struct ib_device *ibdev, + struct ib_path *path, int rc, + struct ib_address_vector *av ); +}; + +/** An Infiniband path */ +struct ib_path { + /** Infiniband device */ + struct ib_device *ibdev; + /** Address vector */ + struct ib_address_vector av; + /** Management transaction */ + struct ib_mad_transaction *madx; + /** Path operations */ + struct ib_path_operations *op; + /** Owner private data */ + void *owner_priv; +}; + +/** + * Set Infiniband path owner-private data + * + * @v path Path + * @v priv Private data + */ +static inline __always_inline void +ib_path_set_ownerdata ( struct ib_path *path, void *priv ) { + path->owner_priv = priv; +} + +/** + * Get Infiniband path owner-private data + * + * @v path Path + * @ret priv Private data + */ +static inline __always_inline void * +ib_path_get_ownerdata ( struct ib_path *path ) { + return path->owner_priv; +} + +extern struct ib_path * +ib_create_path ( struct ib_device *ibdev, struct ib_address_vector *av, + struct ib_path_operations *op ); +extern void ib_destroy_path ( struct ib_device *ibdev, + struct ib_path *path ); + +extern int ib_resolve_path ( struct ib_device *ibdev, + struct ib_address_vector *av ); + +#endif /* _GPXE_IB_PATHREC_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_sma.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_sma.h new file mode 100644 index 0000000..78fc672 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_sma.h @@ -0,0 +1,20 @@ +#ifndef _GPXE_IB_SMA_H +#define _GPXE_IB_SMA_H + +/** @file + * + * Infiniband subnet management agent + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct ib_device; +struct ib_mad_interface; + +extern int ib_create_sma ( struct ib_device *ibdev, + struct ib_mad_interface *mi ); +extern void ib_destroy_sma ( struct ib_device *ibdev, + struct ib_mad_interface *mi ); + +#endif /* _GPXE_IB_SMA_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_smc.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_smc.h new file mode 100644 index 0000000..fdd1c9c --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_smc.h @@ -0,0 +1,20 @@ +#ifndef _GPXE_IB_SMC_H +#define _GPXE_IB_SMC_H + +/** @file + * + * Infiniband Subnet Management Client + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/infiniband.h> + +typedef int ( * ib_local_mad_t ) ( struct ib_device *ibdev, + union ib_mad *mad ); + +extern int ib_smc_update ( struct ib_device *ibdev, + ib_local_mad_t local_mad ); + +#endif /* _GPXE_IB_SMC_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_srp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_srp.h new file mode 100644 index 0000000..cf705b3 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ib_srp.h @@ -0,0 +1,79 @@ +#ifndef _GPXE_IB_SRP_H +#define _GPXE_IB_SRP_H + +/** @file + * + * SCSI RDMA Protocol over Infiniband + * + */ + +FILE_LICENCE ( BSD2 ); + +#include <stdint.h> +#include <gpxe/infiniband.h> +#include <gpxe/srp.h> + +/** SRP initiator port identifier for Infiniband */ +struct ib_srp_initiator_port_id { + /** Identifier extension */ + struct ib_gid_half id_ext; + /** IB channel adapter GUID */ + struct ib_gid_half hca_guid; +} __attribute__ (( packed )); + +/** SRP target port identifier for Infiniband */ +struct ib_srp_target_port_id { + /** Identifier extension */ + struct ib_gid_half id_ext; + /** I/O controller GUID */ + struct ib_gid_half ioc_guid; +} __attribute__ (( packed )); + +/** + * Get Infiniband-specific initiator port ID + * + * @v port_ids SRP port IDs + * @ret initiator_port_id Infiniband-specific initiator port ID + */ +static inline __always_inline struct ib_srp_initiator_port_id * +ib_srp_initiator_port_id ( struct srp_port_ids *port_ids ) { + return ( ( struct ib_srp_initiator_port_id * ) &port_ids->initiator ); +} + +/** + * Get Infiniband-specific target port ID + * + * @v port_ids SRP port IDs + * @ret target_port_id Infiniband-specific target port ID + */ +static inline __always_inline struct ib_srp_target_port_id * +ib_srp_target_port_id ( struct srp_port_ids *port_ids ) { + return ( ( struct ib_srp_target_port_id * ) &port_ids->target ); +} + +/** Infiniband-specific SRP parameters */ +struct ib_srp_parameters { + /** Source GID */ + struct ib_gid sgid; + /** Destination GID */ + struct ib_gid dgid; + /** Service ID */ + struct ib_gid_half service_id; + /** Partition key */ + uint16_t pkey; +}; + +/** + * Get Infiniband-specific transport parameters + * + * @v srp SRP device + * @ret ib_params Infiniband-specific transport parameters + */ +static inline __always_inline struct ib_srp_parameters * +ib_srp_params ( struct srp_device *srp ) { + return srp_transport_priv ( srp ); +} + +extern struct srp_transport_type ib_srp_transport; + +#endif /* _GPXE_IB_SRP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/icmp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/icmp.h new file mode 100644 index 0000000..bb8fce8 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/icmp.h @@ -0,0 +1,25 @@ +#ifndef _GPXE_ICMP_H +#define _GPXE_ICMP_H + +/** @file + * + * ICMP protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** An ICMP header */ +struct icmp_header { + /** Type */ + uint8_t type; + /** Code */ + uint8_t code; + /** Checksum */ + uint16_t chksum; +} __attribute__ (( packed )); + +#define ICMP_ECHO_RESPONSE 0 +#define ICMP_ECHO_REQUEST 8 + +#endif /* _GPXE_ICMP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/icmp6.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/icmp6.h new file mode 100644 index 0000000..e8fd1eb --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/icmp6.h @@ -0,0 +1,59 @@ +#ifndef _GPXE_ICMP6_H +#define _GPXE_ICMP6_H + +/** @file + * + * ICMP6 protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/ip6.h> +#include <gpxe/ndp.h> + +#define ICMP6_NSOLICIT 135 +#define ICMP6_NADVERT 136 + +extern struct tcpip_protocol icmp6_protocol; + +struct icmp6_header { + uint8_t type; + uint8_t code; + uint16_t csum; + /* Message body */ +}; + +struct neighbour_solicit { + uint8_t type; + uint8_t code; + uint16_t csum; + uint32_t reserved; + struct in6_addr target; + /* "Compulsory" options */ + uint8_t opt_type; + uint8_t opt_len; + /* FIXME: hack alert */ + uint8_t opt_ll_addr[6]; +}; + +struct neighbour_advert { + uint8_t type; + uint8_t code; + uint16_t csum; + uint8_t flags; + uint8_t reserved; + struct in6_addr target; + uint8_t opt_type; + uint8_t opt_len; + /* FIXME: hack alert */ + uint8_t opt_ll_addr[6]; +}; + +#define ICMP6_FLAGS_ROUTER 0x80 +#define ICMP6_FLAGS_SOLICITED 0x40 +#define ICMP6_FLAGS_OVERRIDE 0x20 + +int icmp6_send_solicit ( struct net_device *netdev, struct in6_addr *src, struct in6_addr *dest ); + +#endif /* _GPXE_ICMP6_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ieee80211.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ieee80211.h new file mode 100644 index 0000000..0403f92 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ieee80211.h @@ -0,0 +1,1182 @@ +#ifndef _GPXE_IEEE80211_H +#define _GPXE_IEEE80211_H + +#include <gpxe/if_ether.h> /* for ETH_ALEN */ + +/** @file + * Constants and data structures defined in IEEE 802.11, subsetted + * according to what gPXE knows how to use. + */ + +FILE_LICENCE(GPL2_OR_LATER); + +/* ---------- Maximum lengths of things ---------- */ + +/** + * @defgroup ieee80211_maxlen Maximum lengths in the 802.11 protocol + * @{ + */ + +/** Maximum length of frame payload + * + * This does not include cryptographic overhead, which can be up to 20 + * bytes, but it DOES include the 802.2 LLC/SNAP headers that are used + * on data frames (but not management frames). + */ +#define IEEE80211_MAX_DATA_LEN 2304 + +/** Length of LLC/SNAP headers on data frames */ +#define IEEE80211_LLC_HEADER_LEN 8 + +/** Maximum cryptographic overhead before encrypted data */ +#define IEEE80211_MAX_CRYPTO_HEADER 8 + +/** Maximum cryptographic overhead after encrypted data + * + * This does not count the MIC in TKIP frames, since that is + * considered to be part of the MSDU and thus contributes to the size + * of the data field. + * + * It @e does count the MIC in CCMP frames, which is considered part + * of the MPDU (outside the data field). + */ +#define IEEE80211_MAX_CRYPTO_TRAILER 8 + +/** Total maximum cryptographic overhead */ +#define IEEE80211_MAX_CRYPTO_OVERHEAD 16 + +/** Bytes of network-layer data that can go into a regular data frame */ +#define IEEE80211_MAX_FRAME_DATA 2296 + +/** Frame header length for frames we might work with + * + * QoS adds a two-byte field on top of this, and APs communicating + * with each other in Wireless Distribution System (WDS) mode add an + * extra 6-byte MAC address field, but we do not work with such + * frames. + */ +#define IEEE80211_TYP_FRAME_HEADER_LEN 24 + +/** Theoretical maximum frame header length + * + * This includes the QoS and WDS Addr4 fields that we should never + * see. + */ +#define IEEE80211_MAX_FRAME_HEADER_LEN 32 + +/** Maximum combined frame length + * + * The biggest frame will include 32 frame header bytes, 16 bytes of + * crypto overhead, and 2304 data bytes. + */ +#define IEEE80211_MAX_FRAME_LEN 2352 + +/** Maximum length of an ESSID */ +#define IEEE80211_MAX_SSID_LEN 32 + +/** @} */ + + +/* ---------- Frame Control defines ---------- */ + +/** + * @defgroup ieee80211_fc 802.11 Frame Control field bits + * @{ + */ + +/** 802.11 Frame Control field, Version bitmask */ +#define IEEE80211_FC_VERSION 0x0003 + +/** Expected value of Version bits in Frame Control */ +#define IEEE80211_THIS_VERSION 0x0000 + + +/** 802.11 Frame Control field, Frame Type bitmask */ +#define IEEE80211_FC_TYPE 0x000C + +/** Type value for management (layer-2) frames */ +#define IEEE80211_TYPE_MGMT 0x0000 + +/** Type value for control (layer-1, hardware-managed) frames */ +#define IEEE80211_TYPE_CTRL 0x0004 + +/** Type value for data frames */ +#define IEEE80211_TYPE_DATA 0x0008 + + +/** 802.11 Frame Control field, Frame Subtype bitmask */ +#define IEEE80211_FC_SUBTYPE 0x00F0 + +/** Subtype value for association-request management frames + * + * Association request frames are sent after authentication from the + * client to the Access Point to establish the client as part of the + * Access Point's network. + */ +#define IEEE80211_STYPE_ASSOC_REQ 0x0000 + +/** Subtype value for association-response management frames + * + * Association response frames are sent by the Access Point to confirm + * or deny the association requested in an association request frame. + */ +#define IEEE80211_STYPE_ASSOC_RESP 0x0010 + +/** Subtype value for reassociation-request management frames + * + * Reassociation request frames are sent by clients wishing to change + * from one Access Point to another while roaming within the same + * extended network (same ESSID). + */ +#define IEEE80211_STYPE_REASSOC_REQ 0x0020 + +/** Subtype value for reassociation-response management frames + * + * Reassociation response frames are sent by the Access Point to + * confirm or deny the swap requested in a reassociation request + * frame. + */ +#define IEEE80211_STYPE_REASSOC_RESP 0x0030 + +/** Subtype value for probe-request management frames + * + * Probe request frames are sent by clients to request that all Access + * Points on the sending channel, or all belonging to a particular + * ESSID, identify themselves by BSSID, supported transfer rates, RF + * configuration, and other capabilities. + */ +#define IEEE80211_STYPE_PROBE_REQ 0x0040 + +/** Subtype value for probe-response management frames + * + * Probe response frames are sent by Access Points in response to + * probe request frames, providing the requested information. + */ +#define IEEE80211_STYPE_PROBE_RESP 0x0050 + +/** Subtype value for beacon management frames + * + * Beacon frames are sent by Access Points at regular intervals, + * usually ten per second, on the channel on which they communicate. + * They can be used to probe passively for access points on a channel + * where local regulatory restrictions prohibit active scanning, or + * due to their regularity as a mechanism to determine the fraction of + * packets that are being dropped. + */ +#define IEEE80211_STYPE_BEACON 0x0080 + +/** Subtype value for disassociation management frames + * + * Disassociation frames are sent by either a client or an Access + * Point to unequivocally terminate the association between the two. + * They may be sent by clients upon leaving the network, or by an + * Access Point upon reconfiguration, among other reasons; they are + * usually more "polite" than deauthentication frames. + */ +#define IEEE80211_STYPE_DISASSOC 0x00A0 + +/** Subtype value for authentication management frames + * + * Authentication frames are exchanged between a client and an Access + * Point before association may be performed. Confusingly, in the most + * common authentication method (Open System) no security tokens are + * exchanged at all. Modern 802.11 security handshaking takes place + * after association. + */ +#define IEEE80211_STYPE_AUTH 0x00B0 + +/** Subtype value for deauthentication management frames + * + * Deauthentication frames are sent by either a client or an Access + * Point to terminate the authentication (and therefore also the + * association) between the two. They are generally more forceful than + * disassociation frames, sent for such reasons as a failure to + * set up security properly after associating. + */ +#define IEEE80211_STYPE_DEAUTH 0x00C0 + +/** Subtype value for action management frames + * + * Action frames are used to implement spectrum management and QoS + * features that gPXE currently does not support. + */ +#define IEEE80211_STYPE_ACTION 0x00D0 + + +/** Subtype value for RTS (request to send) control frames */ +#define IEEE80211_STYPE_RTS 0x00B0 + +/** Subtype value for CTS (clear to send) control frames */ +#define IEEE80211_STYPE_CTS 0x00C0 + +/** Subtype value for ACK (acknowledgement) control frames */ +#define IEEE80211_STYPE_ACK 0x00D0 + + +/** Subtype value for ordinary data frames, with no QoS or CF add-ons */ +#define IEEE80211_STYPE_DATA 0x0000 + +/** Subtype value for data frames containing no data */ +#define IEEE80211_STYPE_NODATA 0x0040 + + +/** 802.11 Frame Control field: To Data System flag + * + * This is set on data frames sent to an Access Point. + */ +#define IEEE80211_FC_TODS 0x0100 + +/** 802.11 Frame Control field: From Data System flag + * + * This is set on data frames sent from an Access Point. If both TODS + * and FROMDS are set, the frame header is a 4-address format used for + * inter-Access Point communication. + */ +#define IEEE80211_FC_FROMDS 0x0200 + +/** 802.11 Frame Control field: More Fragments flag */ +#define IEEE80211_FC_MORE_FRAG 0x0400 + +/** 802.11 Frame Control field: Retransmission flag */ +#define IEEE80211_FC_RETRY 0x0800 + +/** 802.11 Frame Control field: Power Managed flag + * + * This is set on any frame sent by a low-power station that will go + * into a power-saving mode immediately after this frame. Access + * Points are not allowed to act as low-power stations. + */ +#define IEEE80211_FC_PWR_MGMT 0x1000 + +/** 802.11 Frame Control field: More Data flag + * + * This is set on any frame sent by a station that has more data + * queued to be sent than is in the frame. + */ +#define IEEE80211_FC_MORE_DATA 0x2000 + +/** 802.11 Frame Control field: Protected flag + * + * This is set on frames in which data is encrypted (by any method). + */ +#define IEEE80211_FC_PROTECTED 0x4000 + +/** 802.11 Frame Control field: Ordered flag [?] */ +#define IEEE80211_FC_ORDER 0x8000 + +/** @} */ + + +/* ---------- Sequence Control defines ---------- */ + +/** + * @defgroup ieee80211_seq 802.11 Sequence Control field handling + * @{ + */ + +/** Extract sequence number from 802.11 Sequence Control field */ +#define IEEE80211_SEQNR( seq ) ( ( seq ) >> 4 ) + +/** Extract fragment number from 802.11 Sequence Control field */ +#define IEEE80211_FRAG( seq ) ( ( seq ) & 0x000F ) + +/** Make 802.11 Sequence Control field from sequence and fragment numbers */ +#define IEEE80211_MAKESEQ( seqnr, frag ) \ + ( ( ( ( seqnr ) & 0xFFF ) << 4 ) | ( ( frag ) & 0xF ) ) + +/** @} */ + + +/* ---------- Frame header formats ---------- */ + +/** + * @defgroup ieee80211_hdr 802.11 frame header formats + * @{ + */ + +/** An 802.11 data or management frame without QoS or WDS header fields */ +struct ieee80211_frame +{ + u16 fc; /**< 802.11 Frame Control field */ + u16 duration; /**< Microseconds to reserve link */ + u8 addr1[ETH_ALEN]; /**< Address 1 (immediate receiver) */ + u8 addr2[ETH_ALEN]; /**< Address 2 (immediate sender) */ + u8 addr3[ETH_ALEN]; /**< Address 3 (often "forward to") */ + u16 seq; /**< 802.11 Sequence Control field */ + u8 data[0]; /**< Beginning of frame data */ +} __attribute__((packed)); + +/** The 802.2 LLC/SNAP header sent before actual data in a data frame + * + * This header is not acknowledged in the 802.11 standard at all; it + * is treated just like data for MAC-layer purposes, including + * fragmentation and encryption. It is actually two headers + * concatenated: a three-byte 802.2 LLC header indicating Subnetwork + * Accesss Protocol (SNAP) in both source and destination Service + * Access Point (SAP) fields, and a five-byte SNAP header indicating a + * zero OUI and two-byte Ethernet protocol type field. + * + * Thus, an eight-byte header in which six of the bytes are redundant. + * Lovely, isn't it? + */ +struct ieee80211_llc_snap_header +{ + /* LLC part: */ + u8 dsap; /**< Destination SAP ID */ + u8 ssap; /**< Source SAP ID */ + u8 ctrl; /**< Control information */ + + /* SNAP part: */ + u8 oui[3]; /**< Organization code, usually 0 */ + u16 ethertype; /**< Ethernet Type field */ +} __attribute__((packed)); + +/** Value for DSAP field in 802.2 LLC header for 802.11 frames: SNAP */ +#define IEEE80211_LLC_DSAP 0xAA + +/** Value for SSAP field in 802.2 LLC header for 802.11 frames: SNAP */ +#define IEEE80211_LLC_SSAP 0xAA + +/** Value for control field in 802.2 LLC header for 802.11 frames + * + * "Unnumbered Information". + */ +#define IEEE80211_LLC_CTRL 0x03 + + +/** 16-byte RTS frame format, with abbreviated header */ +struct ieee80211_rts +{ + u16 fc; /**< 802.11 Frame Control field */ + u16 duration; /**< Microseconds to reserve link */ + u8 addr1[ETH_ALEN]; /**< Address 1 (immediate receiver) */ + u8 addr2[ETH_ALEN]; /**< Address 2 (immediate sender) */ +} __attribute__((packed)); + +/** Length of 802.11 RTS control frame */ +#define IEEE80211_RTS_LEN 16 + +/** 10-byte CTS or ACK frame format, with abbreviated header */ +struct ieee80211_cts_or_ack +{ + u16 fc; /**< 802.11 Frame Control field */ + u16 duration; /**< Microseconds to reserve link */ + u8 addr1[ETH_ALEN]; /**< Address 1 (immediate receiver) */ +} __attribute__((packed)); + +#define ieee80211_cts ieee80211_cts_or_ack +#define ieee80211_ack ieee80211_cts_or_ack + +/** Length of 802.11 CTS control frame */ +#define IEEE80211_CTS_LEN 10 + +/** Length of 802.11 ACK control frame */ +#define IEEE80211_ACK_LEN 10 + +/** @} */ + + +/* ---------- Capability bits, status and reason codes ---------- */ + +/** + * @defgroup ieee80211_capab 802.11 management frame capability field bits + * @{ + */ + +/** Set if using an Access Point (managed mode) */ +#define IEEE80211_CAPAB_MANAGED 0x0001 + +/** Set if operating in IBSS (no-AP, "Ad-Hoc") mode */ +#define IEEE80211_CAPAB_ADHOC 0x0002 + +/** Set if we support Contention-Free Period operation */ +#define IEEE80211_CAPAB_CFPOLL 0x0004 + +/** Set if we wish to be polled for Contention-Free operation */ +#define IEEE80211_CAPAB_CFPR 0x0008 + +/** Set if the network is encrypted (by any method) */ +#define IEEE80211_CAPAB_PRIVACY 0x0010 + +/** Set if PHY supports short preambles on 802.11b */ +#define IEEE80211_CAPAB_SHORT_PMBL 0x0020 + +/** Set if PHY supports PBCC modulation */ +#define IEEE80211_CAPAB_PBCC 0x0040 + +/** Set if we support Channel Agility */ +#define IEEE80211_CAPAB_CHAN_AGILITY 0x0080 + +/** Set if we support spectrum management (DFS and TPC) on the 5GHz band */ +#define IEEE80211_CAPAB_SPECTRUM_MGMT 0x0100 + +/** Set if we support Quality of Service enhancements */ +#define IEEE80211_CAPAB_QOS 0x0200 + +/** Set if PHY supports short slot time on 802.11g */ +#define IEEE80211_CAPAB_SHORT_SLOT 0x0400 + +/** Set if PHY supports APSD option */ +#define IEEE80211_CAPAB_APSD 0x0800 + +/** Set if PHY supports DSSS/OFDM modulation (one way of 802.11 b/g mixing) */ +#define IEEE80211_CAPAB_DSSS_OFDM 0x2000 + +/** Set if we support delayed block ACK */ +#define IEEE80211_CAPAB_DELAYED_BACK 0x4000 + +/** Set if we support immediate block ACK */ +#define IEEE80211_CAPAB_IMMED_BACK 0x8000 + +/** @} */ + + +/** + * @defgroup ieee80211_status 802.11 status codes + * + * These are returned to indicate an immediate denial of + * authentication or association. In gPXE, the lower 5 bits of the + * status code are encoded into the file-unique portion of an error + * code, the ERRFILE portion is always @c ERRFILE_net80211, and the + * POSIX error code is @c ECONNREFUSED for status 0-31 or @c + * EHOSTUNREACH for status 32-63. + * + * For a complete table with non-abbreviated error messages, see IEEE + * Std 802.11-2007, Table 7-23, p.94. + * + * @{ + */ + +#define IEEE80211_STATUS_SUCCESS 0 +#define IEEE80211_STATUS_FAILURE 1 +#define IEEE80211_STATUS_CAPAB_UNSUPP 10 +#define IEEE80211_STATUS_REASSOC_INVALID 11 +#define IEEE80211_STATUS_ASSOC_DENIED 12 +#define IEEE80211_STATUS_AUTH_ALGO_UNSUPP 13 +#define IEEE80211_STATUS_AUTH_SEQ_INVALID 14 +#define IEEE80211_STATUS_AUTH_CHALL_INVALID 15 +#define IEEE80211_STATUS_AUTH_TIMEOUT 16 +#define IEEE80211_STATUS_ASSOC_NO_ROOM 17 +#define IEEE80211_STATUS_ASSOC_NEED_RATE 18 +#define IEEE80211_STATUS_ASSOC_NEED_SHORT_PMBL 19 +#define IEEE80211_STATUS_ASSOC_NEED_PBCC 20 +#define IEEE80211_STATUS_ASSOC_NEED_CHAN_AGILITY 21 +#define IEEE80211_STATUS_ASSOC_NEED_SPECTRUM_MGMT 22 +#define IEEE80211_STATUS_ASSOC_BAD_POWER 23 +#define IEEE80211_STATUS_ASSOC_BAD_CHANNELS 24 +#define IEEE80211_STATUS_ASSOC_NEED_SHORT_SLOT 25 +#define IEEE80211_STATUS_ASSOC_NEED_DSSS_OFDM 26 +#define IEEE80211_STATUS_QOS_FAILURE 32 +#define IEEE80211_STATUS_QOS_NO_ROOM 33 +#define IEEE80211_STATUS_LINK_IS_HORRIBLE 34 +#define IEEE80211_STATUS_ASSOC_NEED_QOS 35 +#define IEEE80211_STATUS_REQUEST_DECLINED 37 +#define IEEE80211_STATUS_REQUEST_INVALID 38 +#define IEEE80211_STATUS_TS_NOT_CREATED_AGAIN 39 +#define IEEE80211_STATUS_INVALID_IE 40 +#define IEEE80211_STATUS_GROUP_CIPHER_INVALID 41 +#define IEEE80211_STATUS_PAIR_CIPHER_INVALID 42 +#define IEEE80211_STATUS_AKMP_INVALID 43 +#define IEEE80211_STATUS_RSN_VERSION_UNSUPP 44 +#define IEEE80211_STATUS_RSN_CAPAB_INVALID 45 +#define IEEE80211_STATUS_CIPHER_REJECTED 46 +#define IEEE80211_STATUS_TS_NOT_CREATED_WAIT 47 +#define IEEE80211_STATUS_DIRECT_LINK_FORBIDDEN 48 +#define IEEE80211_STATUS_DEST_NOT_PRESENT 49 +#define IEEE80211_STATUS_DEST_NOT_QOS 50 +#define IEEE80211_STATUS_ASSOC_LISTEN_TOO_HIGH 51 + +/** @} */ + + + +/** + * @defgroup ieee80211_reason 802.11 reason codes + * + * These are returned to indicate the reason for a deauthentication or + * disassociation sent (usually) after authentication or association + * had succeeded. In gPXE, the lower 5 bits of the reason code are + * encoded into the file-unique portion of an error code, the ERRFILE + * portion is always @c ERRFILE_net80211, and the POSIX error code is + * @c ECONNRESET for reason 0-31 or @c ENETRESET for reason 32-63. + * + * For a complete table with non-abbreviated error messages, see IEEE + * Std 802.11-2007, Table 7-22, p.92. + * + * @{ + */ + +#define IEEE80211_REASON_NONE 0 +#define IEEE80211_REASON_UNSPECIFIED 1 +#define IEEE80211_REASON_AUTH_NO_LONGER_VALID 2 +#define IEEE80211_REASON_LEAVING 3 +#define IEEE80211_REASON_INACTIVITY 4 +#define IEEE80211_REASON_OUT_OF_RESOURCES 5 +#define IEEE80211_REASON_NEED_AUTH 6 +#define IEEE80211_REASON_NEED_ASSOC 7 +#define IEEE80211_REASON_LEAVING_TO_ROAM 8 +#define IEEE80211_REASON_REASSOC_INVALID 9 +#define IEEE80211_REASON_BAD_POWER 10 +#define IEEE80211_REASON_BAD_CHANNELS 11 +#define IEEE80211_REASON_INVALID_IE 13 +#define IEEE80211_REASON_MIC_FAILURE 14 +#define IEEE80211_REASON_4WAY_TIMEOUT 15 +#define IEEE80211_REASON_GROUPKEY_TIMEOUT 16 +#define IEEE80211_REASON_4WAY_INVALID 17 +#define IEEE80211_REASON_GROUP_CIPHER_INVALID 18 +#define IEEE80211_REASON_PAIR_CIPHER_INVALID 19 +#define IEEE80211_REASON_AKMP_INVALID 20 +#define IEEE80211_REASON_RSN_VERSION_INVALID 21 +#define IEEE80211_REASON_RSN_CAPAB_INVALID 22 +#define IEEE80211_REASON_8021X_FAILURE 23 +#define IEEE80211_REASON_CIPHER_REJECTED 24 +#define IEEE80211_REASON_QOS_UNSPECIFIED 32 +#define IEEE80211_REASON_QOS_OUT_OF_RESOURCES 33 +#define IEEE80211_REASON_LINK_IS_HORRIBLE 34 +#define IEEE80211_REASON_INVALID_TXOP 35 +#define IEEE80211_REASON_REQUESTED_LEAVING 36 +#define IEEE80211_REASON_REQUESTED_NO_USE 37 +#define IEEE80211_REASON_REQUESTED_NEED_SETUP 38 +#define IEEE80211_REASON_REQUESTED_TIMEOUT 39 +#define IEEE80211_REASON_CIPHER_UNSUPPORTED 45 + +/** @} */ + +/* ---------- Information element declarations ---------- */ + +/** + * @defgroup ieee80211_ie 802.11 information elements + * + * Many management frames include a section that amounts to a + * concatenation of these information elements, so that the sender can + * choose which information to send and the receiver can ignore the + * parts it doesn't understand. Each IE contains a two-byte header, + * one byte ID and one byte length, followed by IE-specific data. The + * length does not include the two-byte header. Information elements + * are required to be sorted by ID, but gPXE does not require that in + * those it receives. + * + * This group also includes a few inline functions to simplify common + * tasks in IE processing. + * + * @{ + */ + +/** Generic 802.11 information element header */ +struct ieee80211_ie_header { + u8 id; /**< Information element ID */ + u8 len; /**< Information element length */ +} __attribute__ ((packed)); + + +/** 802.11 SSID information element */ +struct ieee80211_ie_ssid { + u8 id; /**< SSID ID: 0 */ + u8 len; /**< SSID length */ + char ssid[0]; /**< SSID data, not NUL-terminated */ +} __attribute__ ((packed)); + +/** Information element ID for SSID information element */ +#define IEEE80211_IE_SSID 0 + + +/** 802.11 rates information element + * + * The first 8 rates go in an IE of type RATES (1), and any more rates + * go in one of type EXT_RATES (50). Each rate is a byte with the low + * 7 bits equal to the rate in units of 500 kbps, and the high bit set + * if and only if the rate is "basic" (must be supported by all + * connected stations). + */ +struct ieee80211_ie_rates { + u8 id; /**< Rates ID: 1 or 50 */ + u8 len; /**< Number of rates */ + u8 rates[0]; /**< Rates data, one rate per byte */ +} __attribute__ ((packed)); + +/** Information element ID for rates information element */ +#define IEEE80211_IE_RATES 1 + +/** Information element ID for extended rates information element */ +#define IEEE80211_IE_EXT_RATES 50 + + +/** 802.11 Direct Spectrum parameter information element + * + * This just contains the channel number. It has the fancy name + * because IEEE 802.11 also defines a frequency-hopping PHY that + * changes channels at regular intervals following a predetermined + * pattern; in practice nobody uses the FH PHY. + */ +struct ieee80211_ie_ds_param { + u8 id; /**< DS parameter ID: 3 */ + u8 len; /**< DS parameter length: 1 */ + u8 current_channel; /**< Current channel number, 1-14 */ +} __attribute__ ((packed)); + +/** Information element ID for Direct Spectrum parameter information element */ +#define IEEE80211_IE_DS_PARAM 3 + + +/** 802.11 Country information element regulatory extension triplet */ +struct ieee80211_ie_country_ext_triplet { + u8 reg_ext_id; /**< Regulatory extension ID */ + u8 reg_class_id; /**< Regulatory class ID */ + u8 coverage_class; /**< Coverage class */ +} __attribute__ ((packed)); + +/** 802.11 Country information element regulatory band triplet */ +struct ieee80211_ie_country_band_triplet { + u8 first_channel; /**< Channel number for first channel in band */ + u8 nr_channels; /**< Number of contiguous channels in band */ + u8 max_txpower; /**< Maximum TX power in dBm */ +} __attribute__ ((packed)); + +/** 802.11 Country information element regulatory triplet + * + * It is a band triplet if the first byte is 200 or less, and a + * regulatory extension triplet otherwise. + */ +union ieee80211_ie_country_triplet { + /** Differentiator between band and ext triplets */ + u8 first; + + /** Information about a band of channels */ + struct ieee80211_ie_country_band_triplet band; + + /** Regulatory extension information */ + struct ieee80211_ie_country_ext_triplet ext; +}; + +/** 802.11 Country information element + * + * This contains some data about RF regulations. + */ +struct ieee80211_ie_country { + u8 id; /**< Country information ID: 7 */ + u8 len; /**< Country information length: varies */ + char name[2]; /**< ISO Alpha2 country code */ + char in_out; /**< 'I' for indoor, 'O' for outdoor */ + + /** List of regulatory triplets */ + union ieee80211_ie_country_triplet triplet[0]; +} __attribute__ ((packed)); + +/** Information element ID for Country information element */ +#define IEEE80211_IE_COUNTRY 7 + + +/** 802.11 Request information element + * + * This contains a list of information element types we would like to + * be included in probe response frames. + */ +struct ieee80211_ie_request { + u8 id; /**< Request ID: 10 */ + u8 len; /**< Number of IEs requested */ + u8 request[0]; /**< List of IEs requested */ +} __attribute__ ((packed)); + +/** Information element ID for Request information element */ +#define IEEE80211_IE_REQUEST 10 + + +/** 802.11 Challenge Text information element + * + * This is used in authentication frames under Shared Key + * authentication. + */ +struct ieee80211_ie_challenge_text { + u8 id; /**< Challenge Text ID: 16 */ + u8 len; /**< Challenge Text length: usually 128 */ + u8 challenge_text[0]; /**< Challenge Text data */ +} __attribute__ ((packed)); + +/** Information element ID for Challenge Text information element */ +#define IEEE80211_IE_CHALLENGE_TEXT 16 + + +/** 802.11 Power Constraint information element + * + * This is used to specify an additional power limitation on top of + * the Country requirements. + */ +struct ieee80211_ie_power_constraint { + u8 id; /**< Power Constraint ID: 52 */ + u8 len; /**< Power Constraint length: 1 */ + u8 power_constraint; /**< Decrease in allowed TX power, dBm */ +} __attribute__ ((packed)); + +/** Information element ID for Power Constraint information element */ +#define IEEE80211_IE_POWER_CONSTRAINT 52 + + +/** 802.11 Power Capability information element + * + * This is used in association request frames to indicate the extremes + * of our TX power abilities. It is required only if we indicate + * support for spectrum management. + */ +struct ieee80211_ie_power_capab { + u8 id; /**< Power Capability ID: 33 */ + u8 len; /**< Power Capability length: 2 */ + u8 min_txpower; /**< Minimum possible TX power, dBm */ + u8 max_txpower; /**< Maximum possible TX power, dBm */ +} __attribute__ ((packed)); + +/** Information element ID for Power Capability information element */ +#define IEEE80211_IE_POWER_CAPAB 33 + + +/** 802.11 Channels information element channel band tuple */ +struct ieee80211_ie_channels_channel_band { + u8 first_channel; /**< Channel number of first channel in band */ + u8 nr_channels; /**< Number of channels in band */ +} __attribute__ ((packed)); + +/** 802.11 Channels information element + * + * This is used in association frames to indicate the channels we can + * use. It is required only if we indicate support for spectrum + * management. + */ +struct ieee80211_ie_channels { + u8 id; /**< Channels ID: 36 */ + u8 len; /**< Channels length: 2 */ + + /** List of (start, length) channel bands we can use */ + struct ieee80211_ie_channels_channel_band channels[0]; +} __attribute__ ((packed)); + +/** Information element ID for Channels information element */ +#define IEEE80211_IE_CHANNELS 36 + + +/** 802.11 ERP Information information element + * + * This is used to communicate some PHY-level flags. + */ +struct ieee80211_ie_erp_info { + u8 id; /**< ERP Information ID: 42 */ + u8 len; /**< ERP Information length: 1 */ + u8 erp_info; /**< ERP flags */ +} __attribute__ ((packed)); + +/** Information element ID for ERP Information information element */ +#define IEEE80211_IE_ERP_INFO 42 + +/** ERP information element: Flag set if 802.11b stations are present */ +#define IEEE80211_ERP_NONERP_PRESENT 0x01 + +/** ERP information element: Flag set if CTS protection must be used */ +#define IEEE80211_ERP_USE_PROTECTION 0x02 + +/** ERP information element: Flag set if long preambles must be used */ +#define IEEE80211_ERP_BARKER_LONG 0x04 + + +/** 802.11 Robust Security Network ("WPA") information element + * + * Showing once again a striking clarity of design, the IEEE folks put + * dynamically-sized data in the middle of this structure. As such, + * the below structure definition is only a guideline; the + * @c IEEE80211_RSN_FIELD, @c IEEE80211_RSN_CIPHER, and + * @c IEEE80211_RSN_AUTHTYPE macros should be used to access any + * data. + * + * Also inspired was IEEE's choice of 16-bit fields to count the + * number of 4-byte elements in a structure with a maximum length of + * 255 bytes. + * + * Many fields reference a cipher or authentication-type ID; this is a + * three-byte OUI followed by one byte identifying the cipher with + * respect to that OUI. For all standard ciphers the OUI is 00:0F:AC. + * + * The authentication types referenced in this structure have nothing + * to do with 802.11 authentication frames or the @c algorithm field + * within them. + */ +struct ieee80211_ie_rsn { + /** Information element ID */ + u8 id; + + /** Information element length */ + u8 len; + + /** RSN information element version */ + u16 version; + + /** Cipher ID for the cipher used in multicast/broadcast frames */ + u8 group_cipher[4]; + + /** Number of unicast ciphers supported */ + u16 pairwise_count; + + /** List of cipher IDs for supported unicast frame ciphers */ + u8 pairwise_cipher[4]; + + /** Number of authentication types supported */ + u16 akm_count; + + /** List of authentication type IDs for supported types */ + u8 akm_list[4]; + + /** Security capabilities field. */ + u16 rsn_capab; + + /** Number of PMKIDs included (present only in association frames) */ + u16 pmkid_count; + + /** List of PMKIDs included, each a 16-byte SHA1 hash */ + u8 pmkid_list[0]; +} __attribute__((packed)); + +/** Information element ID for Robust Security Network information element */ +#define IEEE80211_IE_RSN 48 + +/** OUI for standard ciphers in RSN information element */ +#define IEEE80211_RSN_OUI "\x00\x0F\xAC" + +/** Extract RSN IE version field */ +#define IEEE80211_RSN_FIELD_version( rsnp ) ( (rsnp)->version ) + +/** Extract RSN IE group_cipher field */ +#define IEEE80211_RSN_FIELD_group_cipher( rsnp ) ( (rsnp)->group_cipher ) + +/** Extract RSN IE pairwise_count field */ +#define IEEE80211_RSN_FIELD_pairwise_count( rsnp ) ( (rsnp)->pairwise_count ) + +/** Extract RSN IE akm_count field */ +#define IEEE80211_RSN_FIELD_akm_count( rsnp ) \ + ( ( ( struct ieee80211_ie_rsn * ) ( ( void * ) ( rsnp ) + \ + 4*( ( rsnp )->pairwise_count - 1 ) ) )->akm_count ) + +/** Extract RSN IE rsn_capab field */ +#define IEEE80211_RSN_FIELD_rsn_capab( rsnp ) \ + ( ( ( struct ieee80211_ie_rsn * ) ( ( void * ) ( rsnp ) + \ + 4*( ( rsnp )->pairwise_count - 1 ) + \ + 4*( ( rsnp )->akm_count - 1 ) ) )->rsn_capab ) + +/** Extract RSN IE pmkid_count field */ +#define IEEE80211_RSN_FIELD_pmkid_count( rsnp ) \ + ( ( ( struct ieee80211_ie_rsn * ) ( ( void * ) ( rsnp ) + \ + 4*( ( rsnp )->pairwise_count - 1 ) + \ + 4*( ( rsnp )->akm_count - 1 ) ) )->pmkid_count ) + +/** Extract field from RSN information element + * + * @v rsnp Pointer to RSN information element + * @v field Name of field to extract + * @ret val Lvalue of the requested field + * + * You must fill the fields of the structure in order for this to work + * properly. + */ +#define IEEE80211_RSN_FIELD( rsnp, field ) \ + IEEE80211_RSN_FIELD_ ## field ( rsnp ) + +/** Get pointer to pairwise cipher from RSN information element + * + * @v rsnp Pointer to RSN information element + * @v cipher Index of pairwise cipher to extract + * @ret ptr Pointer to requested cipher + */ +#define IEEE80211_RSN_CIPHER( rsnp, cipher ) \ + ( ( rsnp )->pairwise_cipher + 4 * ( cipher ) ) + +/** Get pointer to authentication type from RSN information element + * + * @v rsnp Pointer to RSN information element + * @v akm Index of authentication type to extract + * @ret ptr Pointer to requested authentication type + * + * The @c pairwise_count field must be correct. + */ +#define IEEE80211_RSN_AUTHTYPE( rsnp, akm ) \ + ( ( rsnp )->akm_list + 4 * ( ( rsnp )->pairwise_count - 1 ) + 4 * ( akm ) ) + +/** Get pointer to PMKID from RSN information element + * + * @v rsnp Pointer to RSN information element + * @v idx Index of PMKID to extract + * @ret ptr Pointer to requested PMKID + * + * The @c pairwise_count and @c akm_count fields must be correct. + */ +#define IEEE80211_RSN_PMKID( rsnp, idx ) \ + ( ( rsnp )->pmkid_list + 4 * ( ( rsnp )->pairwise_count - 1 ) + \ + 4 * ( ( rsnp )->akm_count - 1 ) + 16 * ( idx ) ) + +/** Verify size of RSN information element + * + * @v rsnp Pointer to RSN information element + * @ret ok TRUE if count fields are consistent with length field + * + * It is important to drop any RSN IE that does not pass this function + * before using the @c IEEE80211_RSN_FIELD, @c IEEE80211_RSN_CIPHER, + * and @c IEEE80211_RSN_AUTHTYPE macros, to avoid potential security + * compromise due to a malformed RSN IE. + * + * This function does not consider the possibility of some PMKIDs + * included in the RSN IE, because PMKIDs are only included in RSN IEs + * sent in association request frames, and we should never receive an + * association request frame. An RSN IE that includes PMKIDs will + * always fail this check. + */ +static inline int ieee80211_rsn_check ( struct ieee80211_ie_rsn *rsnp ) { + if ( rsnp->len < 12 + 4 * rsnp->pairwise_count ) + return 0; + return ( rsnp->len == 12 + 4 * ( rsnp->pairwise_count + + IEEE80211_RSN_FIELD ( rsnp, akm_count ) ) ); +} + +/** Calculate necessary size of RSN information element + * + * @v npair Number of pairwise ciphers supported + * @v nauth Number of authentication types supported + * @v npmkid Number of PMKIDs to include + * @ret size Necessary size of RSN IE, including header bytes + */ +static inline size_t ieee80211_rsn_size ( int npair, int nauth, int npmkid ) { + return 16 + 4 * ( npair + nauth ) + 16 * npmkid; +} + +/** 802.11 RSN IE: expected version number */ +#define IEEE80211_RSN_VERSION 1 + +/** 802.11 RSN IE: fourth byte of cipher type for 40-bit WEP */ +#define IEEE80211_RSN_CTYPE_WEP40 1 + +/** 802.11 RSN IE: fourth byte of cipher type for 104-bit WEP */ +#define IEEE80211_RSN_CTYPE_WEP104 5 + +/** 802.11 RSN IE: fourth byte of cipher type for TKIP ("WPA") */ +#define IEEE80211_RSN_CTYPE_TKIP 2 + +/** 802.11 RSN IE: fourth byte of cipher type for CCMP ("WPA2") */ +#define IEEE80211_RSN_CTYPE_CCMP 4 + +/** 802.11 RSN IE: fourth byte of cipher type for "use group" + * + * This can only appear as a pairwise cipher, and means unicast frames + * should be encrypted in the same way as broadcast/multicast frames. + */ +#define IEEE80211_RSN_CTYPE_USEGROUP 0 + +/** 802.11 RSN IE: fourth byte of auth method type for using an 802.1X server */ +#define IEEE80211_RSN_ATYPE_8021X 1 + +/** 802.11 RSN IE: fourth byte of auth method type for using a pre-shared key */ +#define IEEE80211_RSN_ATYPE_PSK 2 + +/** 802.11 RSN IE capabilities: AP supports pre-authentication */ +#define IEEE80211_RSN_CAPAB_PREAUTH 0x001 + +/** 802.11 RSN IE capabilities: Node has conflict between TKIP and WEP + * + * This is a legacy issue; APs always set it to 0, and gPXE sets it to + * 0. + */ +#define IEEE80211_RSN_CAPAB_NO_PAIRWISE 0x002 + +/** 802.11 RSN IE capabilities: Number of PTKSA replay counters + * + * A value of 0 means one replay counter, 1 means two, 2 means four, + * and 3 means sixteen. + */ +#define IEEE80211_RSN_CAPAB_PTKSA_REPLAY 0x00C + +/** 802.11 RSN IE capabilities: Number of GTKSA replay counters + * + * A value of 0 means one replay counter, 1 means two, 2 means four, + * and 3 means sixteen. + */ +#define IEEE80211_RSN_CAPAB_GTKSA_REPLAY 0x030 + +/** 802.11 RSN IE capabilities: PeerKey Handshaking is suported */ +#define IEEE80211_RSN_CAPAB_PEERKEY 0x200 + + + +/** Any 802.11 information element + * + * This is formatted for ease of use, so IEs with complex structures + * get referenced in full, while those with only one byte of data or a + * simple array are pulled in to avoid a layer of indirection like + * ie->channels.channels[0]. + */ +union ieee80211_ie +{ + /** Generic and simple information element info */ + struct { + u8 id; /**< Information element ID */ + u8 len; /**< Information element data length */ + union { + char ssid[0]; /**< SSID text */ + u8 rates[0]; /**< Rates data */ + u8 request[0]; /**< Request list */ + u8 challenge_text[0]; /**< Challenge text data */ + u8 power_constraint; /**< Power constraint, dBm */ + u8 erp_info; /**< ERP information flags */ + /** List of channels */ + struct ieee80211_ie_channels_channel_band channels[0]; + }; + }; + + /** DS parameter set */ + struct ieee80211_ie_ds_param ds_param; + + /** Country information */ + struct ieee80211_ie_country country; + + /** Power capability */ + struct ieee80211_ie_power_capab power_capab; + + /** Security information */ + struct ieee80211_ie_rsn rsn; +}; + +/** Advance to next 802.11 information element + * + * @v ie Current information element pointer + * @v end Pointer to first byte not in information element space + * @ret next Pointer to next information element, or NULL if no more + * + * When processing received IEs, @a end should be set to the I/O + * buffer tail pointer; when marshalling IEs for sending, @a end + * should be NULL. + */ +static inline union ieee80211_ie * ieee80211_next_ie ( union ieee80211_ie *ie, + void *end ) +{ + void *next_ie_byte = ( void * ) ie + ie->len + 2; + union ieee80211_ie *next_ie = next_ie_byte; + + if ( ! end ) + return next_ie; + + if ( next_ie_byte < end && next_ie_byte + next_ie->len <= end ) + return next_ie; + + return NULL; +} + +/** @} */ + + +/* ---------- Management frame data formats ---------- */ + +/** + * @defgroup ieee80211_mgmt_data Management frame data payloads + * @{ + */ + +/** Beacon or probe response frame data */ +struct ieee80211_beacon_or_probe_resp +{ + /** 802.11 TSFT value at frame send */ + u64 timestamp; + + /** Interval at which beacons are sent, in units of 1024 us */ + u16 beacon_interval; + + /** Capability flags */ + u16 capability; + + /** List of information elements */ + union ieee80211_ie info_element[0]; +} __attribute__((packed)); + +#define ieee80211_beacon ieee80211_beacon_or_probe_resp +#define ieee80211_probe_resp ieee80211_beacon_or_probe_resp + +/** Disassociation or deauthentication frame data */ +struct ieee80211_disassoc_or_deauth +{ + /** Reason code */ + u16 reason; +} __attribute__((packed)); + +#define ieee80211_disassoc ieee80211_disassoc_or_deauth +#define ieee80211_deauth ieee80211_disassoc_or_deauth + +/** Association request frame data */ +struct ieee80211_assoc_req +{ + /** Capability flags */ + u16 capability; + + /** Interval at which we wake up, in units of the beacon interval */ + u16 listen_interval; + + /** List of information elements */ + union ieee80211_ie info_element[0]; +} __attribute__((packed)); + +/** Association or reassociation response frame data */ +struct ieee80211_assoc_or_reassoc_resp +{ + /** Capability flags */ + u16 capability; + + /** Status code */ + u16 status; + + /** Association ID */ + u16 aid; + + /** List of information elements */ + union ieee80211_ie info_element[0]; +} __attribute__((packed)); + +#define ieee80211_assoc_resp ieee80211_assoc_or_reassoc_resp +#define ieee80211_reassoc_resp ieee80211_assoc_or_reassoc_resp + +/** Reassociation request frame data */ +struct ieee80211_reassoc_req +{ + /** Capability flags */ + u16 capability; + + /** Interval at which we wake up, in units of the beacon interval */ + u16 listen_interval; + + /** MAC address of current Access Point */ + u8 current_addr[ETH_ALEN]; + + /** List of information elements */ + union ieee80211_ie info_element[0]; +} __attribute__((packed)); + +/** Probe request frame data */ +struct ieee80211_probe_req +{ + /** List of information elements */ + union ieee80211_ie info_element[0]; +} __attribute__((packed)); + +/** Authentication frame data */ +struct ieee80211_auth +{ + /** Authentication algorithm (Open System or Shared Key) */ + u16 algorithm; + + /** Sequence number of this frame; first from client to AP is 1 */ + u16 tx_seq; + + /** Status code */ + u16 status; + + /** List of information elements */ + union ieee80211_ie info_element[0]; +} __attribute__((packed)); + +/** Open System authentication algorithm */ +#define IEEE80211_AUTH_OPEN_SYSTEM 0 + +/** Shared Key authentication algorithm */ +#define IEEE80211_AUTH_SHARED_KEY 1 + +/** @} */ + +#endif diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/if_arp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/if_arp.h new file mode 100644 index 0000000..932bb3b --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/if_arp.h @@ -0,0 +1,102 @@ +#ifndef _GPXE_IF_ARP_H +#define _GPXE_IF_ARP_H + +/** @file + * + * Address Resolution Protocol constants and types + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/* ARP protocol HARDWARE identifiers. */ +#define ARPHRD_NETROM 0 /**< from KA9Q: NET/ROM pseudo */ +#define ARPHRD_ETHER 1 /**< Ethernet 10Mbps */ +#define ARPHRD_EETHER 2 /**< Experimental Ethernet */ +#define ARPHRD_AX25 3 /**< AX.25 Level 2 */ +#define ARPHRD_PRONET 4 /**< PROnet token ring */ +#define ARPHRD_CHAOS 5 /**< Chaosnet */ +#define ARPHRD_IEEE802 6 /**< IEEE 802.2 Ethernet/TR/TB */ +#define ARPHRD_ARCNET 7 /**< ARCnet */ +#define ARPHRD_APPLETLK 8 /**< APPLEtalk */ +#define ARPHRD_DLCI 15 /**< Frame Relay DLCI */ +#define ARPHRD_ATM 19 /**< ATM */ +#define ARPHRD_METRICOM 23 /**< Metricom STRIP (new IANA id) */ +#define ARPHRD_IEEE1394 24 /**< IEEE 1394 IPv4 - RFC 2734 */ +#define ARPHRD_EUI64 27 /**< EUI-64 */ +#define ARPHRD_INFINIBAND 32 /**< InfiniBand */ + +/* ARP protocol opcodes. */ +#define ARPOP_REQUEST 1 /**< ARP request */ +#define ARPOP_REPLY 2 /**< ARP reply */ +#define ARPOP_RREQUEST 3 /**< RARP request */ +#define ARPOP_RREPLY 4 /**< RARP reply */ +#define ARPOP_InREQUEST 8 /**< InARP request */ +#define ARPOP_InREPLY 9 /**< InARP reply */ +#define ARPOP_NAK 10 /**< (ATM)ARP NAK */ + +/** + * An ARP header + * + * This contains only the fixed-size portions of an ARP header; for + * other fields use the arp_{sender,target}_{ha,pa} family of + * functions. + */ +struct arphdr { + /** Link-layer protocol + * + * This is an ARPHRD_XXX constant + */ + uint16_t ar_hrd; + /** Network-layer protocol + * + * This is, for Ethernet, an ETH_P_XXX constant. + */ + uint16_t ar_pro; + /** Link-layer address length */ + uint8_t ar_hln; + /** Network-layer address length */ + uint8_t ar_pln; + /** ARP opcode */ + uint16_t ar_op; +} __attribute__ (( packed )); + +/** ARP packet sender hardware address + * + * @v arphdr ARP header + * @ret ar_sha Sender hardware address + */ +static inline void * arp_sender_ha ( struct arphdr *arphdr ) { + return ( ( ( void * ) arphdr ) + sizeof ( *arphdr ) ); +} + +/** ARP packet sender protocol address + * + * @v arphdr ARP header + * @ret ar_spa Sender protocol address + */ +static inline void * arp_sender_pa ( struct arphdr *arphdr ) { + return ( arp_sender_ha ( arphdr ) + arphdr->ar_hln ); +} + +/** ARP packet target hardware address + * + * @v arphdr ARP header + * @ret ar_tha Target hardware address + */ +static inline void * arp_target_ha ( struct arphdr *arphdr ) { + return ( arp_sender_pa ( arphdr ) + arphdr->ar_pln ); +} + +/** ARP packet target protocol address + * + * @v arphdr ARP header + * @ret ar_tpa Target protocol address + */ +static inline void * arp_target_pa ( struct arphdr *arphdr ) { + return ( arp_target_ha ( arphdr ) + arphdr->ar_hln ); +} + +#endif /* _GPXE_IF_ARP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/if_ether.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/if_ether.h new file mode 100644 index 0000000..57f8e12 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/if_ether.h @@ -0,0 +1,35 @@ +#ifndef _GPXE_IF_ETHER_H +#define _GPXE_IF_ETHER_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +#define ETH_ALEN 6 /* Size of Ethernet address */ +#define ETH_HLEN 14 /* Size of ethernet header */ +#define ETH_ZLEN 60 /* Minimum packet */ +#define ETH_FRAME_LEN 1514 /* Maximum packet */ +#define ETH_DATA_ALIGN 2 /* Amount needed to align the data after an ethernet header */ +#ifndef ETH_MAX_MTU +#define ETH_MAX_MTU (ETH_FRAME_LEN-ETH_HLEN) +#endif + +#define ETH_P_RAW 0x0000 /* Raw packet */ +#define ETH_P_IP 0x0800 /* Internet Protocl Packet */ +#define ETH_P_ARP 0x0806 /* Address Resolution Protocol */ +#define ETH_P_RARP 0x8035 /* Reverse Address resolution Protocol */ +#define ETH_P_IPV6 0x86DD /* IPv6 over blueblook */ +#define ETH_P_SLOW 0x8809 /* Ethernet slow protocols */ +#define ETH_P_AOE 0x88A2 /* ATA over Ethernet */ + +/** An Ethernet link-layer header */ +struct ethhdr { + /** Destination MAC address */ + uint8_t h_dest[ETH_ALEN]; + /** Source MAC address */ + uint8_t h_source[ETH_ALEN]; + /** Protocol ID */ + uint16_t h_protocol; +} __attribute__ ((packed)); + +#endif /* _GPXE_IF_ETHER_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/image.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/image.h new file mode 100644 index 0000000..10db8af --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/image.h @@ -0,0 +1,194 @@ +#ifndef _GPXE_IMAGE_H +#define _GPXE_IMAGE_H + +/** + * @file + * + * Executable/loadable images + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/tables.h> +#include <gpxe/list.h> +#include <gpxe/uaccess.h> +#include <gpxe/refcnt.h> + +struct uri; +struct image_type; + +/** An executable or loadable image */ +struct image { + /** Reference count */ + struct refcnt refcnt; + + /** List of registered images */ + struct list_head list; + + /** URI of image */ + struct uri *uri; + /** Name */ + char name[16]; + /** Flags */ + unsigned int flags; + + /** Command line to pass to image */ + char *cmdline; + /** Raw file image */ + userptr_t data; + /** Length of raw file image */ + size_t len; + + /** Image type, if known */ + struct image_type *type; + /** Image type private data */ + union { + physaddr_t phys; + userptr_t user; + unsigned long ul; + } priv; + + /** Replacement image + * + * An image wishing to replace itself with another image (in a + * style similar to a Unix exec() call) should return from its + * exec() method with the replacement image set to point to + * the new image. The new image must already be in a suitable + * state for execution (i.e. loaded). + * + * If an image unregisters itself as a result of being + * executed, it must make sure that its replacement image (if + * any) is registered, otherwise the replacement is likely to + * be freed before it can be executed. + */ + struct image *replacement; +}; + +/** Image is loaded */ +#define IMAGE_LOADED 0x0001 + +/** An executable or loadable image type */ +struct image_type { + /** Name of this image type */ + char *name; + /** + * Load image into memory + * + * @v image Executable/loadable image + * @ret rc Return status code + * + * Load the image into memory at the correct location as + * determined by the file format. + * + * If the file image is in the correct format, the method must + * update @c image->type to point to its own type (unless @c + * image->type is already set). This allows the autoloading + * code to disambiguate between "this is not my image format" + * and "there is something wrong with this image". In + * particular, setting @c image->type and then returning an + * error will cause image_autoload() to abort and return an + * error, rather than continuing to the next image type. + */ + int ( * load ) ( struct image *image ); + /** + * Execute loaded image + * + * @v image Loaded image + * @ret rc Return status code + * + * Note that the image may be invalidated by the act of + * execution, i.e. an image is allowed to choose to unregister + * (and so potentially free) itself. + */ + int ( * exec ) ( struct image *image ); +}; + +/** + * Multiboot image probe priority + * + * Multiboot images are also valid executables in another format + * (e.g. ELF), so we must perform the multiboot probe first. + */ +#define PROBE_MULTIBOOT 01 + +/** + * Normal image probe priority + */ +#define PROBE_NORMAL 02 + +/** + * PXE image probe priority + * + * PXE images have no signature checks, so will claim all image files. + * They must therefore be tried last in the probe order list. + */ +#define PROBE_PXE 03 + +/** Executable or loadable image type table */ +#define IMAGE_TYPES __table ( struct image_type, "image_types" ) + +/** An executable or loadable image type */ +#define __image_type( probe_order ) __table_entry ( IMAGE_TYPES, probe_order ) + +extern struct list_head images; + +/** Iterate over all registered images */ +#define for_each_image( image ) \ + list_for_each_entry ( (image), &images, list ) + +/** + * Test for existence of images + * + * @ret existence Some images exist + */ +static inline int have_images ( void ) { + return ( ! list_empty ( &images ) ); +} + +extern struct image * alloc_image ( void ); +extern int image_set_uri ( struct image *image, struct uri *uri ); +extern int image_set_cmdline ( struct image *image, const char *cmdline ); +extern int register_image ( struct image *image ); +extern void unregister_image ( struct image *image ); +extern void promote_image ( struct image *image ); +struct image * find_image ( const char *name ); +extern int image_load ( struct image *image ); +extern int image_autoload ( struct image *image ); +extern int image_exec ( struct image *image ); +extern int register_and_autoload_image ( struct image *image ); +extern int register_and_autoexec_image ( struct image *image ); + +/** + * Increment reference count on an image + * + * @v image Image + * @ret image Image + */ +static inline struct image * image_get ( struct image *image ) { + ref_get ( &image->refcnt ); + return image; +} + +/** + * Decrement reference count on an image + * + * @v image Image + */ +static inline void image_put ( struct image *image ) { + ref_put ( &image->refcnt ); +} + +/** + * Set image name + * + * @v image Image + * @v name New image name + * @ret rc Return status code + */ +static inline int image_set_name ( struct image *image, const char *name ) { + strncpy ( image->name, name, ( sizeof ( image->name ) - 1 ) ); + return 0; +} + +#endif /* _GPXE_IMAGE_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/in.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/in.h new file mode 100644 index 0000000..7027114 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/in.h @@ -0,0 +1,105 @@ +#ifndef _GPXE_IN_H +#define _GPXE_IN_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/socket.h> + +/* Protocol numbers */ + +#define IP_ICMP 1 +#define IP_IGMP 2 +#define IP_TCP 6 +#define IP_UDP 17 +#define IP_ICMP6 58 + +/* IP address constants */ + +#define INADDR_NONE 0xffffffff + +#define INADDR_BROADCAST 0xffffffff + +#define IN_CLASSA(addr) ( ( (addr) & 0x80000000 ) == 0x00000000 ) +#define IN_CLASSA_NET 0xff000000 +#define IN_CLASSB(addr) ( ( (addr) & 0xc0000000 ) == 0x80000000 ) +#define IN_CLASSB_NET 0xffff0000 +#define IN_CLASSC(addr) ( ( (addr) & 0xe0000000 ) == 0xc0000000 ) +#define IN_CLASSC_NET 0xffffff00 +#define IN_MULTICAST(addr) ( ( (addr) & 0xf0000000 ) == 0xe0000000 ) + +/** + * IP address structure + */ +struct in_addr { + uint32_t s_addr; +}; + +typedef struct in_addr in_addr; + +/** + * IP6 address structure + */ +struct in6_addr { + union { + uint8_t u6_addr8[16]; + uint16_t u6_addr16[8]; + uint32_t u6_addr32[4]; + } in6_u; +#define s6_addr in6_u.u6_addr8 +#define s6_addr16 in6_u.u6_addr16 +#define s6_addr32 in6_u.u6_addr32 +}; + +/** + * IPv4 socket address + */ +struct sockaddr_in { + /** Socket address family (part of struct @c sockaddr) + * + * Always set to @c AF_INET for IPv4 addresses + */ + sa_family_t sin_family; + /** TCP/IP port (part of struct @c sockaddr_tcpip) */ + uint16_t sin_port; + /** IPv4 address */ + struct in_addr sin_addr; + /** Padding + * + * This ensures that a struct @c sockaddr_tcpip is large + * enough to hold a socket address for any TCP/IP address + * family. + */ + char pad[ sizeof ( struct sockaddr ) - sizeof ( sa_family_t ) + - sizeof ( uint16_t ) + - sizeof ( struct in_addr ) ]; +} __attribute__ (( may_alias )); + +/** + * IPv6 socket address + */ +struct sockaddr_in6 { + /** Socket address family (part of struct @c sockaddr) + * + * Always set to @c AF_INET6 for IPv6 addresses + */ + sa_family_t sin_family; + /** TCP/IP port (part of struct @c sockaddr_tcpip) */ + uint16_t sin_port; + uint32_t sin6_flowinfo; /* Flow number */ + struct in6_addr sin6_addr; /* 128-bit destination address */ + uint32_t sin6_scope_id; /* Scope ID */ +} __attribute__ (( may_alias )); + +extern int inet_aton ( const char *cp, struct in_addr *inp ); +extern char * inet_ntoa ( struct in_addr in ); + +/* Adding the following for IP6 support + * + +extern int inet6_aton ( const char *cp, struct in6_addr *inp ); +extern char * inet6_ntoa ( struct in_addr in ); + + */ + +#endif /* _GPXE_IN_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/infiniband.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/infiniband.h new file mode 100644 index 0000000..69bc69b --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/infiniband.h @@ -0,0 +1,652 @@ +#ifndef _GPXE_INFINIBAND_H +#define _GPXE_INFINIBAND_H + +/** @file + * + * Infiniband protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/refcnt.h> +#include <gpxe/device.h> +#include <gpxe/ib_packet.h> +#include <gpxe/ib_mad.h> + +/** Subnet management interface QPN */ +#define IB_QPN_SMI 0 + +/** Subnet management interface queue key */ +#define IB_QKEY_SMI 0 + +/** General service interface QPN */ +#define IB_QPN_GSI 1 + +/** General service interface queue key */ +#define IB_QKEY_GSI 0x80010000UL + +/** Broadcast QPN */ +#define IB_QPN_BROADCAST 0xffffffUL + +/** Default Infiniband partition key */ +#define IB_PKEY_NONE 0xffff + +/** + * Maximum payload size + * + * This is currently hard-coded in various places (drivers, subnet + * management agent, etc.) to 2048. + */ +#define IB_MAX_PAYLOAD_SIZE 2048 + +struct ib_device; +struct ib_queue_pair; +struct ib_address_vector; +struct ib_completion_queue; +struct ib_mad_interface; + +/** Infiniband transmission rates */ +enum ib_rate { + IB_RATE_2_5 = 2, + IB_RATE_10 = 3, + IB_RATE_30 = 4, + IB_RATE_5 = 5, + IB_RATE_20 = 6, + IB_RATE_40 = 7, + IB_RATE_60 = 8, + IB_RATE_80 = 9, + IB_RATE_120 = 10, +}; + +/** An Infiniband Address Vector */ +struct ib_address_vector { + /** Queue Pair Number */ + unsigned long qpn; + /** Queue key + * + * Not specified for received packets. + */ + unsigned long qkey; + /** Local ID */ + unsigned int lid; + /** Rate + * + * Not specified for received packets. + */ + enum ib_rate rate; + /** Service level */ + unsigned int sl; + /** GID is present */ + unsigned int gid_present; + /** GID, if present */ + struct ib_gid gid; +}; + +/** An Infiniband Work Queue */ +struct ib_work_queue { + /** Containing queue pair */ + struct ib_queue_pair *qp; + /** "Is a send queue" flag */ + int is_send; + /** Associated completion queue */ + struct ib_completion_queue *cq; + /** List of work queues on this completion queue */ + struct list_head list; + /** Packet sequence number */ + uint32_t psn; + /** Number of work queue entries */ + unsigned int num_wqes; + /** Number of occupied work queue entries */ + unsigned int fill; + /** Next work queue entry index + * + * This is the index of the next entry to be filled (i.e. the + * first empty entry). This value is not bounded by num_wqes; + * users must logical-AND with (num_wqes-1) to generate an + * array index. + */ + unsigned long next_idx; + /** I/O buffers assigned to work queue */ + struct io_buffer **iobufs; + /** Driver private data */ + void *drv_priv; +}; + +/** An Infiniband multicast GID */ +struct ib_multicast_gid { + /** List of multicast GIDs on this QP */ + struct list_head list; + /** Multicast GID */ + struct ib_gid gid; +}; + +/** An Infiniband queue pair type */ +enum ib_queue_pair_type { + IB_QPT_SMI, + IB_QPT_GSI, + IB_QPT_UD, + IB_QPT_RC, +}; + +/** An Infiniband Queue Pair */ +struct ib_queue_pair { + /** Containing Infiniband device */ + struct ib_device *ibdev; + /** List of queue pairs on this Infiniband device */ + struct list_head list; + /** Queue pair number */ + unsigned long qpn; + /** Externally-visible queue pair number + * + * This may differ from the real queue pair number (e.g. when + * the HCA cannot use the management QPNs 0 and 1 as hardware + * QPNs and needs to remap them). + */ + unsigned long ext_qpn; + /** Queue pair type */ + enum ib_queue_pair_type type; + /** Queue key */ + unsigned long qkey; + /** Send queue */ + struct ib_work_queue send; + /** Receive queue */ + struct ib_work_queue recv; + /** List of multicast GIDs */ + struct list_head mgids; + /** Address vector */ + struct ib_address_vector av; + /** Driver private data */ + void *drv_priv; + /** Queue owner private data */ + void *owner_priv; +}; + +/** Infiniband completion queue operations */ +struct ib_completion_queue_operations { + /** + * Complete Send WQE + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @v iobuf I/O buffer + * @v rc Completion status code + */ + void ( * complete_send ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct io_buffer *iobuf, int rc ); + /** + * Complete Receive WQE + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @v av Address vector, or NULL + * @v iobuf I/O buffer + * @v rc Completion status code + */ + void ( * complete_recv ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct ib_address_vector *av, + struct io_buffer *iobuf, int rc ); +}; + +/** An Infiniband Completion Queue */ +struct ib_completion_queue { + /** Containing Infiniband device */ + struct ib_device *ibdev; + /** List of completion queues on this Infiniband device */ + struct list_head list; + /** Completion queue number */ + unsigned long cqn; + /** Number of completion queue entries */ + unsigned int num_cqes; + /** Next completion queue entry index + * + * This is the index of the next entry to be filled (i.e. the + * first empty entry). This value is not bounded by num_wqes; + * users must logical-AND with (num_wqes-1) to generate an + * array index. + */ + unsigned long next_idx; + /** List of work queues completing to this queue */ + struct list_head work_queues; + /** Completion queue operations */ + struct ib_completion_queue_operations *op; + /** Driver private data */ + void *drv_priv; +}; + +/** + * Infiniband device operations + * + * These represent a subset of the Infiniband Verbs. + */ +struct ib_device_operations { + /** Create completion queue + * + * @v ibdev Infiniband device + * @v cq Completion queue + * @ret rc Return status code + */ + int ( * create_cq ) ( struct ib_device *ibdev, + struct ib_completion_queue *cq ); + /** Destroy completion queue + * + * @v ibdev Infiniband device + * @v cq Completion queue + */ + void ( * destroy_cq ) ( struct ib_device *ibdev, + struct ib_completion_queue *cq ); + /** Create queue pair + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @ret rc Return status code + */ + int ( * create_qp ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp ); + /** Modify queue pair + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @ret rc Return status code + */ + int ( * modify_qp ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp ); + /** Destroy queue pair + * + * @v ibdev Infiniband device + * @v qp Queue pair + */ + void ( * destroy_qp ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp ); + /** Post send work queue entry + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @v av Address vector + * @v iobuf I/O buffer + * @ret rc Return status code + * + * If this method returns success, the I/O buffer remains + * owned by the queue pair. If this method returns failure, + * the I/O buffer is immediately released; the failure is + * interpreted as "failure to enqueue buffer". + */ + int ( * post_send ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct ib_address_vector *av, + struct io_buffer *iobuf ); + /** Post receive work queue entry + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @v iobuf I/O buffer + * @ret rc Return status code + * + * If this method returns success, the I/O buffer remains + * owned by the queue pair. If this method returns failure, + * the I/O buffer is immediately released; the failure is + * interpreted as "failure to enqueue buffer". + */ + int ( * post_recv ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct io_buffer *iobuf ); + /** Poll completion queue + * + * @v ibdev Infiniband device + * @v cq Completion queue + * + * The relevant completion handler (specified at completion + * queue creation time) takes ownership of the I/O buffer. + */ + void ( * poll_cq ) ( struct ib_device *ibdev, + struct ib_completion_queue *cq ); + /** + * Poll event queue + * + * @v ibdev Infiniband device + */ + void ( * poll_eq ) ( struct ib_device *ibdev ); + /** + * Open port + * + * @v ibdev Infiniband device + * @ret rc Return status code + */ + int ( * open ) ( struct ib_device *ibdev ); + /** + * Close port + * + * @v ibdev Infiniband device + */ + void ( * close ) ( struct ib_device *ibdev ); + /** Attach to multicast group + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @v gid Multicast GID + * @ret rc Return status code + */ + int ( * mcast_attach ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct ib_gid *gid ); + /** Detach from multicast group + * + * @v ibdev Infiniband device + * @v qp Queue pair + * @v gid Multicast GID + */ + void ( * mcast_detach ) ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct ib_gid *gid ); + /** Set port information + * + * @v ibdev Infiniband device + * @v mad Set port information MAD + * + * This method is required only by adapters that do not have + * an embedded SMA. + */ + int ( * set_port_info ) ( struct ib_device *ibdev, union ib_mad *mad ); + /** Set partition key table + * + * @v ibdev Infiniband device + * @v mad Set partition key table MAD + * + * This method is required only by adapters that do not have + * an embedded SMA. + */ + int ( * set_pkey_table ) ( struct ib_device *ibdev, + union ib_mad *mad ); +}; + +/** An Infiniband device */ +struct ib_device { + /** Reference counter */ + struct refcnt refcnt; + /** List of Infiniband devices */ + struct list_head list; + /** List of open Infiniband devices */ + struct list_head open_list; + /** Underlying device */ + struct device *dev; + /** List of completion queues */ + struct list_head cqs; + /** List of queue pairs */ + struct list_head qps; + /** Infiniband operations */ + struct ib_device_operations *op; + /** Port number */ + unsigned int port; + /** Port open request counter */ + unsigned int open_count; + + /** Port state */ + uint8_t port_state; + /** Link width supported */ + uint8_t link_width_supported; + /** Link width enabled */ + uint8_t link_width_enabled; + /** Link width active */ + uint8_t link_width_active; + /** Link speed supported */ + uint8_t link_speed_supported; + /** Link speed enabled */ + uint8_t link_speed_enabled; + /** Link speed active */ + uint8_t link_speed_active; + /** Port GID */ + struct ib_gid gid; + /** Port LID */ + uint16_t lid; + /** Subnet manager LID */ + uint16_t sm_lid; + /** Subnet manager SL */ + uint8_t sm_sl; + /** Partition key */ + uint16_t pkey; + + /** RDMA key + * + * This is a single key allowing unrestricted access to + * memory. + */ + uint32_t rdma_key; + + /** Subnet management interface */ + struct ib_mad_interface *smi; + /** General services interface */ + struct ib_mad_interface *gsi; + + /** Driver private data */ + void *drv_priv; + /** Owner private data */ + void *owner_priv; +}; + +extern struct ib_completion_queue * +ib_create_cq ( struct ib_device *ibdev, unsigned int num_cqes, + struct ib_completion_queue_operations *op ); +extern void ib_destroy_cq ( struct ib_device *ibdev, + struct ib_completion_queue *cq ); +extern void ib_poll_cq ( struct ib_device *ibdev, + struct ib_completion_queue *cq ); +extern struct ib_queue_pair * +ib_create_qp ( struct ib_device *ibdev, enum ib_queue_pair_type type, + unsigned int num_send_wqes, struct ib_completion_queue *send_cq, + unsigned int num_recv_wqes, + struct ib_completion_queue *recv_cq ); +extern int ib_modify_qp ( struct ib_device *ibdev, struct ib_queue_pair *qp ); +extern void ib_destroy_qp ( struct ib_device *ibdev, + struct ib_queue_pair *qp ); +extern struct ib_queue_pair * ib_find_qp_qpn ( struct ib_device *ibdev, + unsigned long qpn ); +extern struct ib_queue_pair * ib_find_qp_mgid ( struct ib_device *ibdev, + struct ib_gid *gid ); +extern struct ib_work_queue * ib_find_wq ( struct ib_completion_queue *cq, + unsigned long qpn, int is_send ); +extern int ib_post_send ( struct ib_device *ibdev, struct ib_queue_pair *qp, + struct ib_address_vector *av, + struct io_buffer *iobuf ); +extern int ib_post_recv ( struct ib_device *ibdev, struct ib_queue_pair *qp, + struct io_buffer *iobuf ); +extern void ib_complete_send ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct io_buffer *iobuf, int rc ); +extern void ib_complete_recv ( struct ib_device *ibdev, + struct ib_queue_pair *qp, + struct ib_address_vector *av, + struct io_buffer *iobuf, int rc ); +extern void ib_refill_recv ( struct ib_device *ibdev, + struct ib_queue_pair *qp ); +extern int ib_open ( struct ib_device *ibdev ); +extern void ib_close ( struct ib_device *ibdev ); +extern int ib_mcast_attach ( struct ib_device *ibdev, struct ib_queue_pair *qp, + struct ib_gid *gid ); +extern void ib_mcast_detach ( struct ib_device *ibdev, + struct ib_queue_pair *qp, struct ib_gid *gid ); +extern int ib_get_hca_info ( struct ib_device *ibdev, + struct ib_gid_half *hca_guid ); +extern int ib_set_port_info ( struct ib_device *ibdev, union ib_mad *mad ); +extern int ib_set_pkey_table ( struct ib_device *ibdev, union ib_mad *mad ); +extern struct ib_device * alloc_ibdev ( size_t priv_size ); +extern int register_ibdev ( struct ib_device *ibdev ); +extern void unregister_ibdev ( struct ib_device *ibdev ); +extern struct ib_device * find_ibdev ( struct ib_gid *gid ); +extern struct ib_device * last_opened_ibdev ( void ); +extern void ib_link_state_changed ( struct ib_device *ibdev ); +extern void ib_poll_eq ( struct ib_device *ibdev ); +extern struct list_head ib_devices; + +/** Iterate over all network devices */ +#define for_each_ibdev( ibdev ) \ + list_for_each_entry ( (ibdev), &ib_devices, list ) + +/** + * Check link state + * + * @v ibdev Infiniband device + * @ret link_up Link is up + */ +static inline __always_inline int +ib_link_ok ( struct ib_device *ibdev ) { + return ( ibdev->port_state == IB_PORT_STATE_ACTIVE ); +} + +/** + * Get reference to Infiniband device + * + * @v ibdev Infiniband device + * @ret ibdev Infiniband device + */ +static inline __always_inline struct ib_device * +ibdev_get ( struct ib_device *ibdev ) { + ref_get ( &ibdev->refcnt ); + return ibdev; +} + +/** + * Drop reference to Infiniband device + * + * @v ibdev Infiniband device + */ +static inline __always_inline void +ibdev_put ( struct ib_device *ibdev ) { + ref_put ( &ibdev->refcnt ); +} + +/** + * Set Infiniband work queue driver-private data + * + * @v wq Work queue + * @v priv Private data + */ +static inline __always_inline void +ib_wq_set_drvdata ( struct ib_work_queue *wq, void *priv ) { + wq->drv_priv = priv; +} + +/** + * Get Infiniband work queue driver-private data + * + * @v wq Work queue + * @ret priv Private data + */ +static inline __always_inline void * +ib_wq_get_drvdata ( struct ib_work_queue *wq ) { + return wq->drv_priv; +} + +/** + * Set Infiniband queue pair driver-private data + * + * @v qp Queue pair + * @v priv Private data + */ +static inline __always_inline void +ib_qp_set_drvdata ( struct ib_queue_pair *qp, void *priv ) { + qp->drv_priv = priv; +} + +/** + * Get Infiniband queue pair driver-private data + * + * @v qp Queue pair + * @ret priv Private data + */ +static inline __always_inline void * +ib_qp_get_drvdata ( struct ib_queue_pair *qp ) { + return qp->drv_priv; +} + +/** + * Set Infiniband queue pair owner-private data + * + * @v qp Queue pair + * @v priv Private data + */ +static inline __always_inline void +ib_qp_set_ownerdata ( struct ib_queue_pair *qp, void *priv ) { + qp->owner_priv = priv; +} + +/** + * Get Infiniband queue pair owner-private data + * + * @v qp Queue pair + * @ret priv Private data + */ +static inline __always_inline void * +ib_qp_get_ownerdata ( struct ib_queue_pair *qp ) { + return qp->owner_priv; +} + +/** + * Set Infiniband completion queue driver-private data + * + * @v cq Completion queue + * @v priv Private data + */ +static inline __always_inline void +ib_cq_set_drvdata ( struct ib_completion_queue *cq, void *priv ) { + cq->drv_priv = priv; +} + +/** + * Get Infiniband completion queue driver-private data + * + * @v cq Completion queue + * @ret priv Private data + */ +static inline __always_inline void * +ib_cq_get_drvdata ( struct ib_completion_queue *cq ) { + return cq->drv_priv; +} + +/** + * Set Infiniband device driver-private data + * + * @v ibdev Infiniband device + * @v priv Private data + */ +static inline __always_inline void +ib_set_drvdata ( struct ib_device *ibdev, void *priv ) { + ibdev->drv_priv = priv; +} + +/** + * Get Infiniband device driver-private data + * + * @v ibdev Infiniband device + * @ret priv Private data + */ +static inline __always_inline void * +ib_get_drvdata ( struct ib_device *ibdev ) { + return ibdev->drv_priv; +} + +/** + * Set Infiniband device owner-private data + * + * @v ibdev Infiniband device + * @v priv Private data + */ +static inline __always_inline void +ib_set_ownerdata ( struct ib_device *ibdev, void *priv ) { + ibdev->owner_priv = priv; +} + +/** + * Get Infiniband device owner-private data + * + * @v ibdev Infiniband device + * @ret priv Private data + */ +static inline __always_inline void * +ib_get_ownerdata ( struct ib_device *ibdev ) { + return ibdev->owner_priv; +} + +#endif /* _GPXE_INFINIBAND_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/init.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/init.h new file mode 100644 index 0000000..a72cba7 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/init.h @@ -0,0 +1,81 @@ +#ifndef _GPXE_INIT_H +#define _GPXE_INIT_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/tables.h> + +/** + * An initialisation function + * + * Initialisation functions are called exactly once, as part of the + * call to initialise(). + */ +struct init_fn { + void ( * initialise ) ( void ); +}; + +/** Initialisation function table */ +#define INIT_FNS __table ( struct init_fn, "init_fns" ) + +/** Declare an initialisation functon */ +#define __init_fn( init_order ) __table_entry ( INIT_FNS, init_order ) + +/** @defgroup initfn_order Initialisation function ordering + * @{ + */ + +#define INIT_EARLY 01 /**< Early initialisation */ +#define INIT_SERIAL 02 /**< Serial driver initialisation */ +#define INIT_CONSOLE 03 /**< Console initialisation */ +#define INIT_NORMAL 04 /**< Normal initialisation */ + +/** @} */ + +/** Shutdown flags */ +enum shutdown_flags { + /** Shutdown is in order to exit (return to gPXE's caller) */ + SHUTDOWN_EXIT = 0x0001, + /** Shutdown is in order to boot an OS */ + SHUTDOWN_BOOT = 0x0002, + /** Do not remove devices */ + SHUTDOWN_KEEP_DEVICES = 0x0004, +}; + +/** + * A startup/shutdown function + * + * Startup and shutdown functions may be called multiple times, as + * part of the calls to startup() and shutdown(). + */ +struct startup_fn { + void ( * startup ) ( void ); + void ( * shutdown ) ( int flags ); +}; + +/** Startup/shutdown function table */ +#define STARTUP_FNS __table ( struct startup_fn, "startup_fns" ) + +/** Declare a startup/shutdown function */ +#define __startup_fn( startup_order ) \ + __table_entry ( STARTUP_FNS, startup_order ) + +/** @defgroup startfn_order Startup/shutdown function ordering + * + * Shutdown functions are called in the reverse order to startup + * functions. + * + * @{ + */ + +#define STARTUP_EARLY 01 /**< Early startup */ +#define STARTUP_NORMAL 02 /**< Normal startup */ +#define STARTUP_LATE 03 /**< Late startup */ + +/** @} */ + +extern void initialise ( void ); +extern void startup ( void ); +extern void shutdown ( int flags ); + +#endif /* _GPXE_INIT_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/interface.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/interface.h new file mode 100644 index 0000000..114ebf3 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/interface.h @@ -0,0 +1,58 @@ +#ifndef _GPXE_INTERFACE_H +#define _GPXE_INTERFACE_H + +/** @file + * + * Object communication interfaces + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/refcnt.h> + +/** An object communication interface */ +struct interface { + /** Destination interface + * + * When messages are sent via this interface, they will be + * delivered to the destination interface. + * + * This pointer may never be NULL. When the interface is + * unplugged, it should point to a null interface. + */ + struct interface *dest; + /** Reference counter + * + * If this interface is not part of a reference-counted + * object, this field may be NULL. + */ + struct refcnt *refcnt; +}; + +/** + * Increment reference count on an interface + * + * @v intf Interface + * @ret intf Interface + */ +static inline __attribute__ (( always_inline )) struct interface * +intf_get ( struct interface *intf ) { + ref_get ( intf->refcnt ); + return intf; +} + +/** + * Decrement reference count on an interface + * + * @v intf Interface + */ +static inline __attribute__ (( always_inline )) void +intf_put ( struct interface *intf ) { + ref_put ( intf->refcnt ); +} + +extern void plug ( struct interface *intf, struct interface *dest ); +extern void plug_plug ( struct interface *a, struct interface *b ); + +#endif /* _GPXE_INTERFACE_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/iobuf.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/iobuf.h new file mode 100644 index 0000000..8f05f9e --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/iobuf.h @@ -0,0 +1,229 @@ +#ifndef _GPXE_IOBUF_H +#define _GPXE_IOBUF_H + +/** @file + * + * I/O buffers + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <assert.h> +#include <gpxe/list.h> + +/** + * I/O buffer alignment + * + * I/O buffers allocated via alloc_iob() are guaranteed to be + * physically aligned to this boundary. Some cards cannot DMA across + * a 4kB boundary. With a standard Ethernet MTU, aligning to a 2kB + * boundary is sufficient to guarantee no 4kB boundary crossings. For + * a jumbo Ethernet MTU, a packet may be larger than 4kB anyway. + */ +#define IOB_ALIGN 2048 + +/** + * Minimum I/O buffer length + * + * alloc_iob() will round up the allocated length to this size if + * necessary. This is used on behalf of hardware that is not capable + * of auto-padding. + */ +#define IOB_ZLEN 64 + +/** + * A persistent I/O buffer + * + * This data structure encapsulates a long-lived I/O buffer. The + * buffer may be passed between multiple owners, queued for possible + * retransmission, etc. + */ +struct io_buffer { + /** List of which this buffer is a member + * + * The list must belong to the current owner of the buffer. + * Different owners may maintain different lists (e.g. a + * retransmission list for TCP). + */ + struct list_head list; + + /** Start of the buffer */ + void *head; + /** Start of data */ + void *data; + /** End of data */ + void *tail; + /** End of the buffer */ + void *end; +}; + +/** + * Reserve space at start of I/O buffer + * + * @v iobuf I/O buffer + * @v len Length to reserve + * @ret data Pointer to new start of buffer + */ +static inline void * iob_reserve ( struct io_buffer *iobuf, size_t len ) { + iobuf->data += len; + iobuf->tail += len; + return iobuf->data; +} +#define iob_reserve( iobuf, len ) ( { \ + void *__result; \ + __result = iob_reserve ( (iobuf), (len) ); \ + assert ( (iobuf)->tail <= (iobuf)->end ); \ + __result; } ) + +/** + * Add data to start of I/O buffer + * + * @v iobuf I/O buffer + * @v len Length to add + * @ret data Pointer to new start of buffer + */ +static inline void * iob_push ( struct io_buffer *iobuf, size_t len ) { + iobuf->data -= len; + return iobuf->data; +} +#define iob_push( iobuf, len ) ( { \ + void *__result; \ + __result = iob_push ( (iobuf), (len) ); \ + assert ( (iobuf)->data >= (iobuf)->head ); \ + __result; } ) + +/** + * Remove data from start of I/O buffer + * + * @v iobuf I/O buffer + * @v len Length to remove + * @ret data Pointer to new start of buffer + */ +static inline void * iob_pull ( struct io_buffer *iobuf, size_t len ) { + iobuf->data += len; + assert ( iobuf->data <= iobuf->tail ); + return iobuf->data; +} +#define iob_pull( iobuf, len ) ( { \ + void *__result; \ + __result = iob_pull ( (iobuf), (len) ); \ + assert ( (iobuf)->data <= (iobuf)->tail ); \ + __result; } ) + +/** + * Add data to end of I/O buffer + * + * @v iobuf I/O buffer + * @v len Length to add + * @ret data Pointer to newly added space + */ +static inline void * iob_put ( struct io_buffer *iobuf, size_t len ) { + void *old_tail = iobuf->tail; + iobuf->tail += len; + return old_tail; +} +#define iob_put( iobuf, len ) ( { \ + void *__result; \ + __result = iob_put ( (iobuf), (len) ); \ + assert ( (iobuf)->tail <= (iobuf)->end ); \ + __result; } ) + +/** + * Remove data from end of I/O buffer + * + * @v iobuf I/O buffer + * @v len Length to remove + */ +static inline void iob_unput ( struct io_buffer *iobuf, size_t len ) { + iobuf->tail -= len; +} +#define iob_unput( iobuf, len ) do { \ + iob_unput ( (iobuf), (len) ); \ + assert ( (iobuf)->tail >= (iobuf)->data ); \ + } while ( 0 ) + +/** + * Empty an I/O buffer + * + * @v iobuf I/O buffer + */ +static inline void iob_empty ( struct io_buffer *iobuf ) { + iobuf->tail = iobuf->data; +} + +/** + * Calculate length of data in an I/O buffer + * + * @v iobuf I/O buffer + * @ret len Length of data in buffer + */ +static inline size_t iob_len ( struct io_buffer *iobuf ) { + return ( iobuf->tail - iobuf->data ); +} + +/** + * Calculate available space at start of an I/O buffer + * + * @v iobuf I/O buffer + * @ret len Length of data available at start of buffer + */ +static inline size_t iob_headroom ( struct io_buffer *iobuf ) { + return ( iobuf->data - iobuf->head ); +} + +/** + * Calculate available space at end of an I/O buffer + * + * @v iobuf I/O buffer + * @ret len Length of data available at end of buffer + */ +static inline size_t iob_tailroom ( struct io_buffer *iobuf ) { + return ( iobuf->end - iobuf->tail ); +} + +/** + * Create a temporary I/O buffer + * + * @v iobuf I/O buffer + * @v data Data buffer + * @v len Length of data + * @v max_len Length of buffer + * + * It is sometimes useful to use the iob_xxx() methods on temporary + * data buffers. + */ +static inline void iob_populate ( struct io_buffer *iobuf, + void *data, size_t len, size_t max_len ) { + iobuf->head = iobuf->data = data; + iobuf->tail = ( data + len ); + iobuf->end = ( data + max_len ); +} + +/** + * Disown an I/O buffer + * + * @v iobuf I/O buffer + * + * There are many functions that take ownership of the I/O buffer they + * are passed as a parameter. The caller should not retain a pointer + * to the I/O buffer. Use iob_disown() to automatically nullify the + * caller's pointer, e.g.: + * + * xfer_deliver_iob ( xfer, iob_disown ( iobuf ) ); + * + * This will ensure that iobuf is set to NULL for any code after the + * call to xfer_deliver_iob(). + */ +#define iob_disown( iobuf ) ( { \ + struct io_buffer *__iobuf = (iobuf); \ + (iobuf) = NULL; \ + __iobuf; } ) + +extern struct io_buffer * __malloc alloc_iob ( size_t len ); +extern void free_iob ( struct io_buffer *iobuf ); +extern void iob_pad ( struct io_buffer *iobuf, size_t min_len ); +extern int iob_ensure_headroom ( struct io_buffer *iobuf, size_t len ); + +#endif /* _GPXE_IOBUF_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ip.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ip.h new file mode 100644 index 0000000..4342a0c --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ip.h @@ -0,0 +1,97 @@ +#ifndef _GPXE_IP_H +#define _GPXE_IP_H + +/** @file + * + * IP protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/in.h> +#include <gpxe/list.h> +#include <gpxe/retry.h> + +struct io_buffer; +struct net_device; +struct net_protocol; + +/* IP constants */ + +#define IP_VER 0x40U +#define IP_MASK_VER 0xf0U +#define IP_MASK_HLEN 0x0fU +#define IP_MASK_OFFSET 0x1fffU +#define IP_MASK_DONOTFRAG 0x4000U +#define IP_MASK_MOREFRAGS 0x2000U +#define IP_PSHLEN 12 + +/* IP header defaults */ +#define IP_TOS 0 +#define IP_TTL 64 + +#define IP_FRAG_IOB_SIZE 1500 +#define IP_FRAG_TIMEOUT 50 + +/** An IPv4 packet header */ +struct iphdr { + uint8_t verhdrlen; + uint8_t service; + uint16_t len; + uint16_t ident; + uint16_t frags; + uint8_t ttl; + uint8_t protocol; + uint16_t chksum; + struct in_addr src; + struct in_addr dest; +} __attribute__ (( packed )); + +/** An IPv4 pseudo header */ +struct ipv4_pseudo_header { + struct in_addr src; + struct in_addr dest; + uint8_t zero_padding; + uint8_t protocol; + uint16_t len; +}; + +/** An IPv4 address/routing table entry */ +struct ipv4_miniroute { + /** List of miniroutes */ + struct list_head list; + + /** Network device */ + struct net_device *netdev; + + /** IPv4 address */ + struct in_addr address; + /** Subnet mask */ + struct in_addr netmask; + /** Gateway address */ + struct in_addr gateway; +}; + +/* Fragment reassembly buffer */ +struct frag_buffer { + /* Identification number */ + uint16_t ident; + /* Source network address */ + struct in_addr src; + /* Destination network address */ + struct in_addr dest; + /* Reassembled I/O buffer */ + struct io_buffer *frag_iob; + /* Reassembly timer */ + struct retry_timer frag_timer; + /* List of fragment reassembly buffers */ + struct list_head list; +}; + +extern struct list_head ipv4_miniroutes; + +extern struct net_protocol ipv4_protocol; + +#endif /* _GPXE_IP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ip6.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ip6.h new file mode 100644 index 0000000..edb2863 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ip6.h @@ -0,0 +1,80 @@ +#ifndef _GPXE_IP6_H +#define _GPXE_IP6_H + +/** @file + * + * IP6 protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/in.h> + +/* IP6 constants */ + +#define IP6_VERSION 0x6 +#define IP6_HOP_LIMIT 255 + +/** + * I/O buffer contents + * This is duplicated in tcp.h and here. Ideally it should go into iobuf.h + */ +#define MAX_HDR_LEN 100 +#define MAX_IOB_LEN 1500 +#define MIN_IOB_LEN MAX_HDR_LEN + 100 /* To account for padding by LL */ + +#define IP6_EQUAL( in6_addr1, in6_addr2 ) \ + ( memcmp ( ( char* ) &( in6_addr1 ), ( char* ) &( in6_addr2 ),\ + sizeof ( struct in6_addr ) ) == 0 ) + +#define IS_UNSPECIFIED( addr ) \ + ( ( (addr).in6_u.u6_addr32[0] == 0x00000000 ) && \ + ( (addr).in6_u.u6_addr32[1] == 0x00000000 ) && \ + ( (addr).in6_u.u6_addr32[2] == 0x00000000 ) && \ + ( (addr).in6_u.u6_addr32[3] == 0x00000000 ) ) +/* IP6 header */ +struct ip6_header { + uint32_t ver_traffic_class_flow_label; + uint16_t payload_len; + uint8_t nxt_hdr; + uint8_t hop_limit; + struct in6_addr src; + struct in6_addr dest; +}; + +/* IP6 pseudo header */ +struct ipv6_pseudo_header { + struct in6_addr src; + struct in6_addr dest; + uint8_t zero_padding; + uint8_t nxt_hdr; + uint16_t len; +}; + +/* Next header numbers */ +#define IP6_HOPBYHOP 0x00 +#define IP6_ROUTING 0x43 +#define IP6_FRAGMENT 0x44 +#define IP6_AUTHENTICATION 0x51 +#define IP6_DEST_OPTS 0x60 +#define IP6_ESP 0x50 +#define IP6_ICMP6 0x58 +#define IP6_NO_HEADER 0x59 + +struct io_buffer; +struct net_device; +struct net_protocol; + +extern struct net_protocol ipv6_protocol; +extern struct tcpip_net_protocol ipv6_tcpip_protocol; +extern char * inet6_ntoa ( struct in6_addr in6 ); + +extern int add_ipv6_address ( struct net_device *netdev, + struct in6_addr prefix, int prefix_len, + struct in6_addr address, + struct in6_addr gateway ); +extern void del_ipv6_address ( struct net_device *netdev ); + +#endif /* _GPXE_IP6_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ipoib.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ipoib.h new file mode 100644 index 0000000..f8231db --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ipoib.h @@ -0,0 +1,60 @@ +#ifndef _GPXE_IPOIB_H +#define _GPXE_IPOIB_H + +/** @file + * + * IP over Infiniband + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/infiniband.h> + +/** IPoIB MAC address length */ +#define IPOIB_ALEN 20 + +/** An IPoIB MAC address */ +struct ipoib_mac { + /** Queue pair number + * + * MSB must be zero; QPNs are only 24-bit. + */ + uint32_t qpn; + /** Port GID */ + struct ib_gid gid; +} __attribute__ (( packed )); + +/** IPoIB link-layer header length */ +#define IPOIB_HLEN 4 + +/** IPoIB link-layer header */ +struct ipoib_hdr { + /** Network-layer protocol */ + uint16_t proto; + /** Reserved, must be zero */ + union { + /** Reserved, must be zero */ + uint16_t reserved; + /** Peer addresses + * + * We use these fields internally to represent the + * peer addresses using a lookup key. There simply + * isn't enough room in the IPoIB header to store + * literal source or destination MAC addresses. + */ + struct { + /** Destination address key */ + uint8_t dest; + /** Source address key */ + uint8_t src; + } __attribute__ (( packed )) peer; + } __attribute__ (( packed )) u; +} __attribute__ (( packed )); + +extern const char * ipoib_ntoa ( const void *ll_addr ); +extern void ipoib_link_state_changed ( struct ib_device *ibdev ); +extern int ipoib_probe ( struct ib_device *ibdev ); +extern void ipoib_remove ( struct ib_device *ibdev ); +extern struct net_device * alloc_ipoibdev ( size_t priv_size ); + +#endif /* _GPXE_IPOIB_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/isa.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/isa.h new file mode 100644 index 0000000..63027a5 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/isa.h @@ -0,0 +1,97 @@ +#ifndef ISA_H +#define ISA_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/isa_ids.h> +#include <gpxe/device.h> +#include <gpxe/tables.h> + +/** An ISA device */ +struct isa_device { + /** Generic device */ + struct device dev; + /** I/O address */ + uint16_t ioaddr; + /** Driver for this device */ + struct isa_driver *driver; + /** Driver-private data + * + * Use isa_set_drvdata() and isa_get_drvdata() to access + * this field. + */ + void *priv; + /** Driver name */ + const char *driver_name; +}; + +/* + * An individual ISA device, identified by probe address + * + */ +typedef uint16_t isa_probe_addr_t; + +/** An ISA driver */ +struct isa_driver { + /** Name */ + const char *name; + /** Probe address list */ + isa_probe_addr_t *probe_addrs; + /** Number of entries in probe address list */ + unsigned int addr_count; + /** Manufacturer ID to be assumed for this device */ + uint16_t vendor_id; + /** Product ID to be assumed for this device */ + uint16_t prod_id; + /** + * Probe device + * + * @v isa ISA device + * @v id Matching entry in ID table + * @ret rc Return status code + */ + int ( * probe ) ( struct isa_device *isa ); + /** + * Remove device + * + * @v isa ISA device + */ + void ( * remove ) ( struct isa_device *isa ); +}; + +/** ISA driver table */ +#define ISA_DRIVERS __table ( struct isa_driver, "isa_drivers" ) + +/** Declare an ISA driver */ +#define __isa_driver __table_entry ( ISA_DRIVERS, 01 ) + +/** + * Set ISA driver-private data + * + * @v isa ISA device + * @v priv Private data + */ +static inline void isa_set_drvdata ( struct isa_device *isa, void *priv ) { + isa->priv = priv; +} + +/** + * Get ISA driver-private data + * + * @v isa ISA device + * @ret priv Private data + */ +static inline void * isa_get_drvdata ( struct isa_device *isa ) { + return isa->priv; +} + +/* + * ISA_ROM is parsed by parserom.pl to generate Makefile rules and + * files for rom-o-matic. + * + */ +#define ISA_ROM( IMAGE, DESCRIPTION ) + +#endif /* ISA_H */ + diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/isa_ids.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/isa_ids.h new file mode 100644 index 0000000..1faf114 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/isa_ids.h @@ -0,0 +1,51 @@ +#ifndef ISA_IDS_H +#define ISA_IDS_H + +/* + * This file defines IDs as used by ISAPnP and EISA devices. These + * IDs have the format: + * + * vendor byte 0 bit 7 must be zero + * bits 6-2 first vendor char in compressed ASCII + * bits 1-0 second vendor char in compressed ASCII (bits 4-3) + * byte 1 bits 7-5 second vendor char in compressed ASCII (bits 2-0) + * bits 4-0 third vendor char in compressed ASCII + * product byte 0 bits 7-4 first hex digit of product number + * bits 3-0 second hex digit of product number + * byte 1 bits 7-4 third hex digit of product number + * bits 3-0 hex digit of revision level + * + * ISA IDs are always expressed in little-endian order, even though + * the underlying "meaning" is big-endian. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <byteswap.h> + +/* + * Construct a vendor ID from three ASCII characters + * + */ +#define ISA_VENDOR( a, b, c ) \ + bswap_16 ( ( ( ( (a) - 'A' + 1 ) & 0x1f ) << 10 ) | \ + ( ( ( (b) - 'A' + 1 ) & 0x1f ) << 5 ) | \ + ( ( ( (c) - 'A' + 1 ) & 0x1f ) << 0 ) ) + +#define ISAPNP_VENDOR( a, b, c ) ISA_VENDOR ( a, b, c ) +#define EISA_VENDOR( a, b, c ) ISA_VENDOR ( a, b, c ) + +#define GENERIC_ISAPNP_VENDOR ISAPNP_VENDOR ( 'P','N','P' ) + +/* + * Extract product ID and revision from combined product field + * + */ +#define ISA_PROD_ID_MASK ( 0xf0ff ) +#define ISA_PROD_ID(product) ( (product) & ISA_PROD_ID_MASK ) +#define ISA_PROD_REV(product) ( ( (product) & ~ISA_PROD_ID_MASK ) >> 8 ) + +/* Functions in isa_ids.c */ +extern char * isa_id_string ( unsigned int vendor, unsigned int product ); + +#endif /* ISA_IDS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/isapnp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/isapnp.h new file mode 100644 index 0000000..b58a87e --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/isapnp.h @@ -0,0 +1,278 @@ +/************************************************************************** +* +* isapnp.h -- Etherboot isapnp support for the 3Com 3c515 +* Written 2002-2003 by Timothy Legge <tlegge@rogers.com> +* +* 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 +* (at your option) 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. +* +* Portions of this code: +* Copyright (C) 2001 P.J.H.Fox (fox@roestock.demon.co.uk) +* +* +* +* REVISION HISTORY: +* ================ +* Version 0.1 April 26, 2002 TJL +* Version 0.2 01/08/2003 TJL Renamed from 3c515_isapnp.h +* +* +* Generalised into an ISAPnP bus that can be used by more than just +* the 3c515 by Michael Brown <mbrown@fensystems.co.uk> +* +***************************************************************************/ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#ifndef ISAPNP_H +#define ISAPNP_H + +#include <stdint.h> +#include <gpxe/isa_ids.h> +#include <gpxe/device.h> +#include <gpxe/tables.h> + +/* + * ISAPnP constants + * + */ + +/* Port addresses */ +#define ISAPNP_ADDRESS 0x279 +#define ISAPNP_WRITE_DATA 0xa79 +#define ISAPNP_READ_PORT_MIN 0x203 +#define ISAPNP_READ_PORT_START 0x213 /* ISAPnP spec says 0x203, but + * Linux ISAPnP starts at + * 0x213 with no explanatory + * comment. 0x203 probably + * clashes with something. */ +#define ISAPNP_READ_PORT_MAX 0x3ff +#define ISAPNP_READ_PORT_STEP 0x10 /* Can be any multiple of 4 + * according to the spec, but + * since ISA I/O addresses are + * allocated in blocks of 16, + * it makes no sense to use + * any value less than 16. + */ + +/* Card select numbers */ +#define ISAPNP_CSN_MIN 0x01 +#define ISAPNP_CSN_MAX 0x0f + +/* Registers */ +#define ISAPNP_READPORT 0x00 +#define ISAPNP_SERIALISOLATION 0x01 +#define ISAPNP_CONFIGCONTROL 0x02 +#define ISAPNP_WAKE 0x03 +#define ISAPNP_RESOURCEDATA 0x04 +#define ISAPNP_STATUS 0x05 +#define ISAPNP_CARDSELECTNUMBER 0x06 +#define ISAPNP_LOGICALDEVICENUMBER 0x07 +#define ISAPNP_ACTIVATE 0x30 +#define ISAPNP_IORANGECHECK 0x31 +#define ISAPNP_IOBASE(n) ( 0x60 + ( (n) * 2 ) ) +#define ISAPNP_IRQNO(n) ( 0x70 + ( (n) * 2 ) ) +#define ISAPNP_IRQTYPE(n) ( 0x71 + ( (n) * 2 ) ) + +/* Bits in the CONFIGCONTROL register */ +#define ISAPNP_CONFIG_RESET ( 1 << 0 ) +#define ISAPNP_CONFIG_WAIT_FOR_KEY ( 1 << 1 ) +#define ISAPNP_CONFIG_RESET_CSN ( 1 << 2 ) +#define ISAPNP_CONFIG_RESET_DRV ( ISAPNP_CONFIG_RESET | \ + ISAPNP_CONFIG_WAIT_FOR_KEY | \ + ISAPNP_CONFIG_RESET_CSN ) + +/* The LFSR used for the initiation key and for checksumming */ +#define ISAPNP_LFSR_SEED 0x6a + +/* Small tags */ +#define ISAPNP_IS_SMALL_TAG(tag) ( ! ( (tag) & 0x80 ) ) +#define ISAPNP_SMALL_TAG_NAME(tag) ( ( (tag) >> 3 ) & 0xf ) +#define ISAPNP_SMALL_TAG_LEN(tag) ( ( (tag) & 0x7 ) ) +#define ISAPNP_TAG_PNPVERNO 0x01 +#define ISAPNP_TAG_LOGDEVID 0x02 +#define ISAPNP_TAG_COMPATDEVID 0x03 +#define ISAPNP_TAG_IRQ 0x04 +#define ISAPNP_TAG_DMA 0x05 +#define ISAPNP_TAG_STARTDEP 0x06 +#define ISAPNP_TAG_ENDDEP 0x07 +#define ISAPNP_TAG_IOPORT 0x08 +#define ISAPNP_TAG_FIXEDIO 0x09 +#define ISAPNP_TAG_RSVDSHORTA 0x0A +#define ISAPNP_TAG_RSVDSHORTB 0x0B +#define ISAPNP_TAG_RSVDSHORTC 0x0C +#define ISAPNP_TAG_RSVDSHORTD 0x0D +#define ISAPNP_TAG_VENDORSHORT 0x0E +#define ISAPNP_TAG_END 0x0F +/* Large tags */ +#define ISAPNP_IS_LARGE_TAG(tag) ( ( (tag) & 0x80 ) ) +#define ISAPNP_LARGE_TAG_NAME(tag) (tag) +#define ISAPNP_TAG_MEMRANGE 0x81 +#define ISAPNP_TAG_ANSISTR 0x82 +#define ISAPNP_TAG_UNICODESTR 0x83 +#define ISAPNP_TAG_VENDORLONG 0x84 +#define ISAPNP_TAG_MEM32RANGE 0x85 +#define ISAPNP_TAG_FIXEDMEM32RANGE 0x86 +#define ISAPNP_TAG_RSVDLONG0 0xF0 +#define ISAPNP_TAG_RSVDLONG1 0xF1 +#define ISAPNP_TAG_RSVDLONG2 0xF2 +#define ISAPNP_TAG_RSVDLONG3 0xF3 +#define ISAPNP_TAG_RSVDLONG4 0xF4 +#define ISAPNP_TAG_RSVDLONG5 0xF5 +#define ISAPNP_TAG_RSVDLONG6 0xF6 +#define ISAPNP_TAG_RSVDLONG7 0xF7 +#define ISAPNP_TAG_RSVDLONG8 0xF8 +#define ISAPNP_TAG_RSVDLONG9 0xF9 +#define ISAPNP_TAG_RSVDLONGA 0xFA +#define ISAPNP_TAG_RSVDLONGB 0xFB +#define ISAPNP_TAG_RSVDLONGC 0xFC +#define ISAPNP_TAG_RSVDLONGD 0xFD +#define ISAPNP_TAG_RSVDLONGE 0xFE +#define ISAPNP_TAG_RSVDLONGF 0xFF +#define ISAPNP_TAG_PSEUDO_NEWBOARD 0x100 + +/** An ISAPnP serial identifier */ +struct isapnp_identifier { + /** Vendor ID */ + uint16_t vendor_id; + /** Product ID */ + uint16_t prod_id; + /** Serial number */ + uint32_t serial; + /** Checksum */ + uint8_t checksum; +} __attribute__ (( packed )); + +/** An ISAPnP logical device ID structure */ +struct isapnp_logdevid { + /** Vendor ID */ + uint16_t vendor_id; + /** Product ID */ + uint16_t prod_id; + /** Flags */ + uint16_t flags; +} __attribute__ (( packed )); + +/** An ISAPnP device ID list entry */ +struct isapnp_device_id { + /** Name */ + const char *name; + /** Vendor ID */ + uint16_t vendor_id; + /** Product ID */ + uint16_t prod_id; +}; + +/** An ISAPnP device */ +struct isapnp_device { + /** Generic device */ + struct device dev; + /** Vendor ID */ + uint16_t vendor_id; + /** Product ID */ + uint16_t prod_id; + /** I/O address */ + uint16_t ioaddr; + /** Interrupt number */ + uint8_t irqno; + /** Card Select Number */ + uint8_t csn; + /** Logical Device ID */ + uint8_t logdev; + /** Driver for this device */ + struct isapnp_driver *driver; + /** Driver-private data + * + * Use isapnp_set_drvdata() and isapnp_get_drvdata() to access + * this field. + */ + void *priv; + /** Driver name */ + const char *driver_name; +}; + +/** An ISAPnP driver */ +struct isapnp_driver { + /** ISAPnP ID table */ + struct isapnp_device_id *ids; + /** Number of entries in ISAPnP ID table */ + unsigned int id_count; + /** + * Probe device + * + * @v isapnp ISAPnP device + * @v id Matching entry in ID table + * @ret rc Return status code + */ + int ( * probe ) ( struct isapnp_device *isapnp, + const struct isapnp_device_id *id ); + /** + * Remove device + * + * @v isapnp ISAPnP device + */ + void ( * remove ) ( struct isapnp_device *isapnp ); +}; + +/** ISAPnP driver table */ +#define ISAPNP_DRIVERS __table ( struct isapnp_driver, "isapnp_drivers" ) + +/** Declare an ISAPnP driver */ +#define __isapnp_driver __table_entry ( ISAPNP_DRIVERS, 01 ) + +extern uint16_t isapnp_read_port; + +extern void isapnp_device_activation ( struct isapnp_device *isapnp, + int activation ); + +/** + * Activate ISAPnP device + * + * @v isapnp ISAPnP device + */ +static inline void activate_isapnp_device ( struct isapnp_device *isapnp ) { + isapnp_device_activation ( isapnp, 1 ); +} + +/** + * Deactivate ISAPnP device + * + * @v isapnp ISAPnP device + */ +static inline void deactivate_isapnp_device ( struct isapnp_device *isapnp ) { + isapnp_device_activation ( isapnp, 0 ); +} + +/** + * Set ISAPnP driver-private data + * + * @v isapnp ISAPnP device + * @v priv Private data + */ +static inline void isapnp_set_drvdata ( struct isapnp_device *isapnp, + void *priv ) { + isapnp->priv = priv; +} + +/** + * Get ISAPnP driver-private data + * + * @v isapnp ISAPnP device + * @ret priv Private data + */ +static inline void * isapnp_get_drvdata ( struct isapnp_device *isapnp ) { + return isapnp->priv; +} + +#endif /* ISAPNP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/iscsi.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/iscsi.h new file mode 100644 index 0000000..00717d2 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/iscsi.h @@ -0,0 +1,678 @@ +#ifndef _GPXE_ISCSI_H +#define _GPXE_ISCSI_H + +/** @file + * + * iSCSI protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/socket.h> +#include <gpxe/scsi.h> +#include <gpxe/chap.h> +#include <gpxe/refcnt.h> +#include <gpxe/xfer.h> +#include <gpxe/process.h> + +/** Default iSCSI port */ +#define ISCSI_PORT 3260 + +/** + * iSCSI segment lengths + * + * iSCSI uses an icky structure with one one-byte field (a dword + * count) and one three-byte field (a byte count). This structure, + * and the accompanying macros, relieve some of the pain. + */ +union iscsi_segment_lengths { + struct { + /** The AHS length (measured in dwords) */ + uint8_t ahs_len; + /** The data length (measured in bytes), in network + * byte order + */ + uint8_t data_len[3]; + } bytes; + /** Ths data length (measured in bytes), in network byte + * order, with ahs_len as the first byte. + */ + uint32_t ahs_and_data_len; +}; + +/** The length of the additional header segment, in dwords */ +#define ISCSI_AHS_LEN( segment_lengths ) \ + ( (segment_lengths).bytes.ahs_len ) + +/** The length of the data segment, in bytes, excluding any padding */ +#define ISCSI_DATA_LEN( segment_lengths ) \ + ( ntohl ( (segment_lengths).ahs_and_data_len ) & 0xffffff ) + +/** The padding of the data segment, in bytes */ +#define ISCSI_DATA_PAD_LEN( segment_lengths ) \ + ( ( 0 - (segment_lengths).bytes.data_len[2] ) & 0x03 ) + +/** Set additional header and data segment lengths */ +#define ISCSI_SET_LENGTHS( segment_lengths, ahs_len, data_len ) do { \ + (segment_lengths).ahs_and_data_len = \ + htonl ( data_len | ( ahs_len << 24 ) ); \ + } while ( 0 ) + +/** + * iSCSI basic header segment common fields + * + */ +struct iscsi_bhs_common { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Fields specific to the PDU type */ + uint8_t other_a[2]; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** Fields specific to the PDU type */ + uint8_t other_b[8]; + /** Initiator Task Tag */ + uint32_t itt; + /** Fields specific to the PDU type */ + uint8_t other_c[28]; +}; + +/** Opcode mask */ +#define ISCSI_OPCODE_MASK 0x3f + +/** Immediate delivery */ +#define ISCSI_FLAG_IMMEDIATE 0x40 + +/** Final PDU of a sequence */ +#define ISCSI_FLAG_FINAL 0x80 + +/** + * iSCSI basic header segment common request fields + * + */ +struct iscsi_bhs_common_response { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Fields specific to the PDU type */ + uint8_t other_a[2]; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** Fields specific to the PDU type */ + uint8_t other_b[8]; + /** Initiator Task Tag */ + uint32_t itt; + /** Fields specific to the PDU type */ + uint8_t other_c[4]; + /** Status sequence number */ + uint32_t statsn; + /** Expected command sequence number */ + uint32_t expcmdsn; + /** Fields specific to the PDU type */ + uint8_t other_d[16]; +}; + +/** + * iSCSI login request basic header segment + * + */ +struct iscsi_bhs_login_request { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Maximum supported version number */ + uint8_t version_max; + /** Minimum supported version number */ + uint8_t version_min; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** Initiator session ID (IANA format) enterprise number and flags */ + uint32_t isid_iana_en; + /** Initiator session ID (IANA format) qualifier */ + uint16_t isid_iana_qual; + /** Target session identifying handle */ + uint16_t tsih; + /** Initiator Task Tag */ + uint32_t itt; + /** Connection ID */ + uint16_t cid; + /** Reserved */ + uint16_t reserved_a; + /** Command sequence number */ + uint32_t cmdsn; + /** Expected status sequence number */ + uint32_t expstatsn; + /** Reserved */ + uint8_t reserved_b[16]; +}; + +/** Login request opcode */ +#define ISCSI_OPCODE_LOGIN_REQUEST 0x03 + +/** Willingness to transition to next stage */ +#define ISCSI_LOGIN_FLAG_TRANSITION 0x80 + +/** Key=value pairs continued in subsequent request */ +#define ISCSI_LOGIN_FLAG_CONTINUE 0x40 + +/* Current stage values and mask */ +#define ISCSI_LOGIN_CSG_MASK 0x0c +#define ISCSI_LOGIN_CSG_SECURITY_NEGOTIATION 0x00 +#define ISCSI_LOGIN_CSG_OPERATIONAL_NEGOTIATION 0x04 +#define ISCSI_LOGIN_CSG_FULL_FEATURE_PHASE 0x0c + +/* Next stage values and mask */ +#define ISCSI_LOGIN_NSG_MASK 0x03 +#define ISCSI_LOGIN_NSG_SECURITY_NEGOTIATION 0x00 +#define ISCSI_LOGIN_NSG_OPERATIONAL_NEGOTIATION 0x01 +#define ISCSI_LOGIN_NSG_FULL_FEATURE_PHASE 0x03 + +/** ISID IANA format marker */ +#define ISCSI_ISID_IANA 0x40000000 + +/** Fen Systems Ltd. IANA enterprise number + * + * Permission is hereby granted to use Fen Systems Ltd.'s IANA + * enterprise number with this iSCSI implementation. + */ +#define IANA_EN_FEN_SYSTEMS 10019 + +/** + * iSCSI login response basic header segment + * + */ +struct iscsi_bhs_login_response { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Maximum supported version number */ + uint8_t version_max; + /** Minimum supported version number */ + uint8_t version_min; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** Initiator session ID (IANA format) enterprise number and flags */ + uint32_t isid_iana_en; + /** Initiator session ID (IANA format) qualifier */ + uint16_t isid_iana_qual; + /** Target session identifying handle */ + uint16_t tsih; + /** Initiator Task Tag */ + uint32_t itt; + /** Reserved */ + uint32_t reserved_a; + /** Status sequence number */ + uint32_t statsn; + /** Expected command sequence number */ + uint32_t expcmdsn; + /** Maximum command sequence number */ + uint32_t maxcmdsn; + /** Status class */ + uint8_t status_class; + /** Status detail */ + uint8_t status_detail; + /** Reserved */ + uint8_t reserved_b[10]; +}; + +/** Login response opcode */ +#define ISCSI_OPCODE_LOGIN_RESPONSE 0x23 + +/* Login response status codes */ +#define ISCSI_STATUS_SUCCESS 0x00 +#define ISCSI_STATUS_REDIRECT 0x01 +#define ISCSI_STATUS_INITIATOR_ERROR 0x02 +#define ISCSI_STATUS_INITIATOR_ERROR_AUTHENTICATION 0x01 +#define ISCSI_STATUS_INITIATOR_ERROR_AUTHORISATION 0x02 +#define ISCSI_STATUS_INITIATOR_ERROR_NOT_FOUND 0x03 +#define ISCSI_STATUS_INITIATOR_ERROR_REMOVED 0x04 +#define ISCSI_STATUS_TARGET_ERROR 0x03 + +/** + * iSCSI SCSI command basic header segment + * + */ +struct iscsi_bhs_scsi_command { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Reserved */ + uint16_t reserved_a; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** SCSI Logical Unit Number */ + struct scsi_lun lun; + /** Initiator Task Tag */ + uint32_t itt; + /** Expected data transfer length */ + uint32_t exp_len; + /** Command sequence number */ + uint32_t cmdsn; + /** Expected status sequence number */ + uint32_t expstatsn; + /** SCSI Command Descriptor Block (CDB) */ + union scsi_cdb cdb; +}; + +/** SCSI command opcode */ +#define ISCSI_OPCODE_SCSI_COMMAND 0x01 + +/** Command will read data */ +#define ISCSI_COMMAND_FLAG_READ 0x40 + +/** Command will write data */ +#define ISCSI_COMMAND_FLAG_WRITE 0x20 + +/* Task attributes */ +#define ISCSI_COMMAND_ATTR_UNTAGGED 0x00 +#define ISCSI_COMMAND_ATTR_SIMPLE 0x01 +#define ISCSI_COMMAND_ATTR_ORDERED 0x02 +#define ISCSI_COMMAND_ATTR_HEAD_OF_QUEUE 0x03 +#define ISCSI_COMMAND_ATTR_ACA 0x04 + +/** + * iSCSI SCSI response basic header segment + * + */ +struct iscsi_bhs_scsi_response { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Response code */ + uint8_t response; + /** SCSI status code */ + uint8_t status; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** Reserved */ + uint8_t reserved_a[8]; + /** Initiator Task Tag */ + uint32_t itt; + /** SNACK tag */ + uint32_t snack; + /** Status sequence number */ + uint32_t statsn; + /** Expected command sequence number */ + uint32_t expcmdsn; + /** Maximum command sequence number */ + uint32_t maxcmdsn; + /** Expected data sequence number */ + uint32_t expdatasn; + /** Reserved */ + uint8_t reserved_b[8]; +}; + +/** SCSI response opcode */ +#define ISCSI_OPCODE_SCSI_RESPONSE 0x21 + +/** SCSI command completed at target */ +#define ISCSI_RESPONSE_COMMAND_COMPLETE 0x00 + +/** SCSI target failure */ +#define ISCSI_RESPONSE_TARGET_FAILURE 0x01 + +/** SCSI sense response code offset + * + * The SCSI response may contain unsolicited sense data in the data + * segment. If it does, this is the offset to the sense response code + * byte, which is the only byte we care about. + */ +#define ISCSI_SENSE_RESPONSE_CODE_OFFSET 2 + +/** + * iSCSI data-in basic header segment + * + */ +struct iscsi_bhs_data_in { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Reserved */ + uint8_t reserved_a; + /** SCSI status code */ + uint8_t status; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** Logical Unit Number */ + struct scsi_lun lun; + /** Initiator Task Tag */ + uint32_t itt; + /** Target Transfer Tag */ + uint32_t ttt; + /** Status sequence number */ + uint32_t statsn; + /** Expected command sequence number */ + uint32_t expcmdsn; + /** Maximum command sequence number */ + uint32_t maxcmdsn; + /** Data sequence number */ + uint32_t datasn; + /** Buffer offset */ + uint32_t offset; + /** Residual count */ + uint32_t residual_count; +}; + +/** Data-in opcode */ +#define ISCSI_OPCODE_DATA_IN 0x25 + +/** Data requires acknowledgement */ +#define ISCSI_DATA_FLAG_ACKNOWLEDGE 0x40 + +/** Data overflow occurred */ +#define ISCSI_DATA_FLAG_OVERFLOW 0x04 + +/** Data underflow occurred */ +#define ISCSI_DATA_FLAG_UNDERFLOW 0x02 + +/** SCSI status code and overflow/underflow flags are valid */ +#define ISCSI_DATA_FLAG_STATUS 0x01 + +/** + * iSCSI data-out basic header segment + * + */ +struct iscsi_bhs_data_out { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Reserved */ + uint16_t reserved_a; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** Logical Unit Number */ + struct scsi_lun lun; + /** Initiator Task Tag */ + uint32_t itt; + /** Target Transfer Tag */ + uint32_t ttt; + /** Reserved */ + uint32_t reserved_b; + /** Expected status sequence number */ + uint32_t expstatsn; + /** Reserved */ + uint32_t reserved_c; + /** Data sequence number */ + uint32_t datasn; + /** Buffer offset */ + uint32_t offset; + /** Reserved */ + uint32_t reserved_d; +}; + +/** Data-out opcode */ +#define ISCSI_OPCODE_DATA_OUT 0x05 + +/** + * iSCSI request to transfer basic header segment + * + */ +struct iscsi_bhs_r2t { + /** Opcode */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Reserved */ + uint16_t reserved_a; + /** Segment lengths */ + union iscsi_segment_lengths lengths; + /** Logical Unit Number */ + struct scsi_lun lun; + /** Initiator Task Tag */ + uint32_t itt; + /** Target Transfer Tag */ + uint32_t ttt; + /** Status sequence number */ + uint32_t statsn; + /** Expected command sequence number */ + uint32_t expcmdsn; + /** Maximum command sequence number */ + uint32_t maxcmdsn; + /** R2T sequence number */ + uint32_t r2tsn; + /** Buffer offset */ + uint32_t offset; + /** Desired data transfer length */ + uint32_t len; +}; + +/** R2T opcode */ +#define ISCSI_OPCODE_R2T 0x31 + +/** + * An iSCSI basic header segment + */ +union iscsi_bhs { + struct iscsi_bhs_common common; + struct iscsi_bhs_common_response common_response; + struct iscsi_bhs_login_request login_request; + struct iscsi_bhs_login_response login_response; + struct iscsi_bhs_scsi_command scsi_command; + struct iscsi_bhs_scsi_response scsi_response; + struct iscsi_bhs_data_in data_in; + struct iscsi_bhs_data_out data_out; + struct iscsi_bhs_r2t r2t; + unsigned char bytes[ sizeof ( struct iscsi_bhs_common ) ]; +}; + +/** State of an iSCSI TX engine */ +enum iscsi_tx_state { + /** Nothing to send */ + ISCSI_TX_IDLE = 0, + /** Sending the basic header segment */ + ISCSI_TX_BHS, + /** Sending the additional header segment */ + ISCSI_TX_AHS, + /** Sending the data segment */ + ISCSI_TX_DATA, + /** Sending the data segment padding */ + ISCSI_TX_DATA_PADDING, +}; + +/** State of an iSCSI RX engine */ +enum iscsi_rx_state { + /** Receiving the basic header segment */ + ISCSI_RX_BHS = 0, + /** Receiving the additional header segment */ + ISCSI_RX_AHS, + /** Receiving the data segment */ + ISCSI_RX_DATA, + /** Receiving the data segment padding */ + ISCSI_RX_DATA_PADDING, +}; + +/** An iSCSI session */ +struct iscsi_session { + /** Reference counter */ + struct refcnt refcnt; + + /** Transport-layer socket */ + struct xfer_interface socket; + + /** Target address */ + char *target_address; + /** Target port */ + unsigned int target_port; + /** Target IQN */ + char *target_iqn; + /** Logical Unit Number (LUN) */ + struct scsi_lun lun; + /** Target socket address (recorded only for iBFT) */ + struct sockaddr target_sockaddr; + + /** Session status + * + * This is the bitwise-OR of zero or more ISCSI_STATUS_XXX + * constants. + */ + int status; + /** Retry count + * + * Number of times that the connection has been retried. + * Reset upon a successful connection. + */ + int retry_count; + + /** Initiator username (if any) */ + char *initiator_username; + /** Initiator password (if any) */ + char *initiator_password; + /** Target username (if any) */ + char *target_username; + /** Target password (if any) */ + char *target_password; + /** CHAP challenge (for target auth only) + * + * This is a block of random data; the first byte is used as + * the CHAP identifier (CHAP_I) and the remainder as the CHAP + * challenge (CHAP_C). + */ + unsigned char chap_challenge[17]; + /** CHAP response (used for both initiator and target auth) */ + struct chap_response chap; + + /** Target session identifying handle + * + * This is assigned by the target when we first log in, and + * must be reused on subsequent login attempts. + */ + uint16_t tsih; + /** Initiator task tag + * + * This is the tag of the current command. It is incremented + * whenever a new command is started. + */ + uint32_t itt; + /** Target transfer tag + * + * This is the tag attached to a sequence of data-out PDUs in + * response to an R2T. + */ + uint32_t ttt; + /** + * Transfer offset + * + * This is the offset for an in-progress sequence of data-out + * PDUs in response to an R2T. + */ + uint32_t transfer_offset; + /** + * Transfer length + * + * This is the length for an in-progress sequence of data-out + * PDUs in response to an R2T. + */ + uint32_t transfer_len; + /** Command sequence number + * + * This is the sequence number of the current command, used to + * fill out the CmdSN field in iSCSI request PDUs. It is + * updated with the value of the ExpCmdSN field whenever we + * receive an iSCSI response PDU containing such a field. + */ + uint32_t cmdsn; + /** Status sequence number + * + * This is the most recent status sequence number present in + * the StatSN field of an iSCSI response PDU containing such a + * field. Whenever we send an iSCSI request PDU, we fill out + * the ExpStatSN field with this value plus one. + */ + uint32_t statsn; + + /** Basic header segment for current TX PDU */ + union iscsi_bhs tx_bhs; + /** State of the TX engine */ + enum iscsi_tx_state tx_state; + /** TX process */ + struct process process; + + /** Basic header segment for current RX PDU */ + union iscsi_bhs rx_bhs; + /** State of the RX engine */ + enum iscsi_rx_state rx_state; + /** Byte offset within the current RX state */ + size_t rx_offset; + /** Length of the current RX state */ + size_t rx_len; + /** Buffer for received data (not always used) */ + void *rx_buffer; + + /** Current SCSI command + * + * Set to NULL when command is complete. + */ + struct scsi_command *command; + /** Instant return code + * + * Set to a non-zero value if all requests should return + * immediately. This can be used to e.g. avoid retrying + * logins that are doomed to fail authentication. + */ + int instant_rc; +}; + +/** iSCSI session is currently in the security negotiation phase */ +#define ISCSI_STATUS_SECURITY_NEGOTIATION_PHASE \ + ( ISCSI_LOGIN_CSG_SECURITY_NEGOTIATION | \ + ISCSI_LOGIN_NSG_OPERATIONAL_NEGOTIATION ) + +/** iSCSI session is currently in the operational parameter + * negotiation phase + */ +#define ISCSI_STATUS_OPERATIONAL_NEGOTIATION_PHASE \ + ( ISCSI_LOGIN_CSG_OPERATIONAL_NEGOTIATION | \ + ISCSI_LOGIN_NSG_FULL_FEATURE_PHASE ) + +/** iSCSI session is currently in the full feature phase */ +#define ISCSI_STATUS_FULL_FEATURE_PHASE ISCSI_LOGIN_CSG_FULL_FEATURE_PHASE + +/** Mask for all iSCSI session phases */ +#define ISCSI_STATUS_PHASE_MASK ( ISCSI_LOGIN_CSG_MASK | ISCSI_LOGIN_NSG_MASK ) + +/** iSCSI session needs to send the initial security negotiation strings */ +#define ISCSI_STATUS_STRINGS_SECURITY 0x0100 + +/** iSCSI session needs to send the CHAP_A string */ +#define ISCSI_STATUS_STRINGS_CHAP_ALGORITHM 0x0200 + +/** iSCSI session needs to send the CHAP response */ +#define ISCSI_STATUS_STRINGS_CHAP_RESPONSE 0x0400 + +/** iSCSI session needs to send the mutual CHAP challenge */ +#define ISCSI_STATUS_STRINGS_CHAP_CHALLENGE 0x0800 + +/** iSCSI session needs to send the operational negotiation strings */ +#define ISCSI_STATUS_STRINGS_OPERATIONAL 0x1000 + +/** Mask for all iSCSI "needs to send" flags */ +#define ISCSI_STATUS_STRINGS_MASK 0xff00 + +/** Target has requested forward (initiator) authentication */ +#define ISCSI_STATUS_AUTH_FORWARD_REQUIRED 0x00010000 + +/** Initiator requires target (reverse) authentication */ +#define ISCSI_STATUS_AUTH_REVERSE_REQUIRED 0x00020000 + +/** Target authenticated itself correctly */ +#define ISCSI_STATUS_AUTH_REVERSE_OK 0x00040000 + +/** Maximum number of retries at connecting */ +#define ISCSI_MAX_RETRIES 2 + +extern int iscsi_attach ( struct scsi_device *scsi, const char *root_path ); +extern void iscsi_detach ( struct scsi_device *scsi ); +extern const char * iscsi_initiator_iqn ( void ); + +#endif /* _GPXE_ISCSI_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/job.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/job.h new file mode 100644 index 0000000..f1bcada --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/job.h @@ -0,0 +1,169 @@ +#ifndef _GPXE_JOB_H +#define _GPXE_JOB_H + +/** @file + * + * Job control interfaces + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stddef.h> +#include <gpxe/interface.h> + +/** Job progress */ +struct job_progress { + /** Amount of operation completed so far + * + * The units for this quantity are arbitrary. @c completed + * divded by @total should give something which approximately + * represents the progress through the operation. For a + * download operation, using byte counts would make sense. + */ + unsigned long completed; + /** Total operation size + * + * See @c completed. A zero value means "total size unknown" + * and is explcitly permitted; users should take this into + * account before calculating @c completed/total. + */ + unsigned long total; +}; + +struct job_interface; + +/** Job control interface operations */ +struct job_interface_operations { + /** Job completed + * + * @v job Job control interface + * @v rc Overall job status code + */ + void ( * done ) ( struct job_interface *job, int rc ); + /** Abort job + * + * @v job Job control interface + */ + void ( * kill ) ( struct job_interface *job ); + /** Get job progress + * + * @v job Job control interface + * @v progress Progress data to fill in + */ + void ( * progress ) ( struct job_interface *job, + struct job_progress *progress ); +}; + +/** A job control interface */ +struct job_interface { + /** Generic object communication interface */ + struct interface intf; + /** Operations for received messages */ + struct job_interface_operations *op; +}; + +extern struct job_interface null_job; +extern struct job_interface_operations null_job_ops; + +extern void job_done ( struct job_interface *job, int rc ); +extern void job_kill ( struct job_interface *job ); +extern void job_progress ( struct job_interface *job, + struct job_progress *progress ); + +extern void ignore_job_done ( struct job_interface *job, int rc ); +extern void ignore_job_kill ( struct job_interface *job ); +extern void ignore_job_progress ( struct job_interface *job, + struct job_progress *progress ); + +/** + * Initialise a job control interface + * + * @v job Job control interface + * @v op Job control interface operations + * @v refcnt Containing object reference counter, or NULL + */ +static inline void job_init ( struct job_interface *job, + struct job_interface_operations *op, + struct refcnt *refcnt ) { + job->intf.dest = &null_job.intf; + job->intf.refcnt = refcnt; + job->op = op; +} + +/** + * Get job control interface from generic object communication interface + * + * @v intf Generic object communication interface + * @ret job Job control interface + */ +static inline __attribute__ (( always_inline )) struct job_interface * +intf_to_job ( struct interface *intf ) { + return container_of ( intf, struct job_interface, intf ); +} + +/** + * Get reference to destination job control interface + * + * @v job Job control interface + * @ret dest Destination interface + */ +static inline __attribute__ (( always_inline )) struct job_interface * +job_get_dest ( struct job_interface *job ) { + return intf_to_job ( intf_get ( job->intf.dest ) ); +} + +/** + * Drop reference to job control interface + * + * @v job Job control interface + */ +static inline __attribute__ (( always_inline )) void +job_put ( struct job_interface *job ) { + intf_put ( &job->intf ); +} + +/** + * Plug a job control interface into a new destination interface + * + * @v job Job control interface + * @v dest New destination interface + */ +static inline void job_plug ( struct job_interface *job, + struct job_interface *dest ) { + plug ( &job->intf, &dest->intf ); +} + +/** + * Plug two job control interfaces together + * + * @v a Job control interface A + * @v b Job control interface B + */ +static inline void job_plug_plug ( struct job_interface *a, + struct job_interface *b ) { + plug_plug ( &a->intf, &b->intf ); +} + +/** + * Unplug a job control interface + * + * @v job Job control interface + */ +static inline void job_unplug ( struct job_interface *job ) { + plug ( &job->intf, &null_job.intf ); +} + +/** + * Stop using a job control interface + * + * @v job Job control interface + * + * After calling this method, no further messages will be received via + * the interface. + */ +static inline void job_nullify ( struct job_interface *job ) { + job->op = &null_job_ops; +}; + +#endif /* _GPXE_JOB_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/keys.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/keys.h new file mode 100644 index 0000000..25bc9bc --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/keys.h @@ -0,0 +1,81 @@ +#ifndef _GPXE_KEYS_H +#define _GPXE_KEYS_H + +/** @file + * + * Key definitions + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* + * Symbolic names for some standard ASCII characters + * + */ + +#define NUL 0x00 +#define CTRL_A 0x01 +#define CTRL_B 0x02 +#define CTRL_C 0x03 +#define CTRL_D 0x04 +#define CTRL_E 0x05 +#define CTRL_F 0x06 +#define CTRL_G 0x07 +#define CTRL_H 0x08 +#define CTRL_I 0x09 +#define CTRL_J 0x0a +#define CTRL_K 0x0b +#define CTRL_L 0x0c +#define CTRL_M 0x0d +#define CTRL_N 0x0e +#define CTRL_O 0x0f +#define CTRL_P 0x10 +#define CTRL_Q 0x11 +#define CTRL_R 0x12 +#define CTRL_S 0x13 +#define CTRL_T 0x14 +#define CTRL_U 0x15 +#define CTRL_V 0x16 +#define CTRL_W 0x17 +#define CTRL_X 0x18 +#define CTRL_Y 0x19 +#define CTRL_Z 0x1a + +#define BACKSPACE CTRL_H +#define TAB CTRL_I +#define LF CTRL_J +#define CR CTRL_M +#define ESC 0x1b + +/* + * Special keys outside the normal ASCII range + * + * + * The names are chosen to match those used by curses. The values are + * chosen to facilitate easy conversion from a received ANSI escape + * sequence to a KEY_XXX constant. + */ + +#define KEY_ANSI( n, terminator ) ( 0x100 * ( (n) + 1 ) + (terminator) ) + +#define KEY_MIN 0x101 +#define KEY_UP KEY_ANSI ( 0, 'A' ) /**< Up arrow */ +#define KEY_DOWN KEY_ANSI ( 0, 'B' ) /**< Down arrow */ +#define KEY_RIGHT KEY_ANSI ( 0, 'C' ) /**< Right arrow */ +#define KEY_LEFT KEY_ANSI ( 0, 'D' ) /**< Left arrow */ +#define KEY_END KEY_ANSI ( 0, 'F' ) /**< End */ +#define KEY_HOME KEY_ANSI ( 0, 'H' ) /**< Home */ +#define KEY_IC KEY_ANSI ( 2, '~' ) /**< Insert */ +#define KEY_DC KEY_ANSI ( 3, '~' ) /**< Delete */ +#define KEY_PPAGE KEY_ANSI ( 5, '~' ) /**< Page up */ +#define KEY_NPAGE KEY_ANSI ( 6, '~' ) /**< Page down */ +#define KEY_F8 KEY_ANSI ( 19, '~' ) /**< F8 (for PXE) */ + +/* Not in the [KEY_MIN,KEY_MAX] range; terminals seem to send these as + * normal ASCII values. + */ +#define KEY_BACKSPACE BACKSPACE +#define KEY_ENTER LF + +#endif /* _GPXE_KEYS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/linebuf.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/linebuf.h new file mode 100644 index 0000000..cfa2147 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/linebuf.h @@ -0,0 +1,30 @@ +#ifndef _GPXE_LINEBUF_H +#define _GPXE_LINEBUF_H + +/** @file + * + * Line buffering + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <stddef.h> + +/** A line buffer */ +struct line_buffer { + /** Current string in the buffer */ + char *data; + /** Length of current string, excluding the terminating NUL */ + size_t len; + /** String is ready to read */ + int ready; +}; + +extern char * buffered_line ( struct line_buffer *linebuf ); +extern ssize_t line_buffer ( struct line_buffer *linebuf, + const char *data, size_t len ); +extern void empty_line_buffer ( struct line_buffer *linebuf ); + +#endif /* _GPXE_LINEBUF_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/linux_compat.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/linux_compat.h new file mode 100644 index 0000000..577512e --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/linux_compat.h @@ -0,0 +1,27 @@ +#ifndef _GPXE_LINUX_COMPAT_H +#define _GPXE_LINUX_COMPAT_H + +/** @file + * + * Linux code compatibility + * + * This file exists to ease the building of Linux source code within + * gPXE. This is intended to facilitate quick testing; it is not + * intended to be a substitute for proper porting. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <errno.h> +#include <stdio.h> +#include <byteswap.h> +#include <gpxe/bitops.h> + +#define __init +#define __exit +#define __initdata +#define __exitdata +#define printk printf + +#endif /* _GPXE_LINUX_COMPAT_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/login_ui.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/login_ui.h new file mode 100644 index 0000000..4196f7b --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/login_ui.h @@ -0,0 +1,14 @@ +#ifndef _GPXE_LOGIN_UI_H +#define _GPXE_LOGIN_UI_H + +/** @file + * + * Login UI + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +extern int login_ui ( void ); + +#endif /* _GPXE_LOGIN_UI_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/malloc.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/malloc.h new file mode 100644 index 0000000..c02a866 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/malloc.h @@ -0,0 +1,59 @@ +#ifndef _GPXE_MALLOC_H +#define _GPXE_MALLOC_H + +#include <stdint.h> + +/** @file + * + * Dynamic memory allocation + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* + * Prototypes for the standard functions (malloc() et al) are in + * stdlib.h. Include <gpxe/malloc.h> only if you need the + * non-standard functions, such as malloc_dma(). + * + */ +#include <stdlib.h> + +extern size_t freemem; + +extern void * __malloc alloc_memblock ( size_t size, size_t align ); +extern void free_memblock ( void *ptr, size_t size ); +extern void mpopulate ( void *start, size_t len ); +extern void mdumpfree ( void ); + +/** + * Allocate memory for DMA + * + * @v size Requested size + * @v align Physical alignment + * @ret ptr Memory, or NULL + * + * Allocates physically-aligned memory for DMA. + * + * @c align must be a power of two. @c size may not be zero. + */ +static inline void * __malloc malloc_dma ( size_t size, size_t phys_align ) { + return alloc_memblock ( size, phys_align ); +} + +/** + * Free memory allocated with malloc_dma() + * + * @v ptr Memory allocated by malloc_dma(), or NULL + * @v size Size of memory, as passed to malloc_dma() + * + * Memory allocated with malloc_dma() can only be freed with + * free_dma(); it cannot be freed with the standard free(). + * + * If @c ptr is NULL, no action is taken. + */ +static inline void free_dma ( void *ptr, size_t size ) { + free_memblock ( ptr, size ); +} + +#endif /* _GPXE_MALLOC_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/mca.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/mca.h new file mode 100644 index 0000000..da9d73e --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/mca.h @@ -0,0 +1,108 @@ +/* + * MCA bus driver code + * + * Abstracted from 3c509.c. + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#ifndef MCA_H +#define MCA_H + +#include <gpxe/isa_ids.h> +#include <gpxe/device.h> +#include <gpxe/tables.h> + +/* + * MCA constants + * + */ +#define MCA_MOTHERBOARD_SETUP_REG 0x94 +#define MCA_ADAPTER_SETUP_REG 0x96 +#define MCA_MAX_SLOT_NR 0x07 /* Must be 2^n - 1 */ +#define MCA_POS_REG(n) (0x100+(n)) + +/* Is there a standard that would define this? */ +#define GENERIC_MCA_VENDOR ISA_VENDOR ( 'M', 'C', 'A' ) + +/** An MCA device ID list entry */ +struct mca_device_id { + /** Name */ + const char *name; + /** Device ID */ + uint16_t id; +}; + +/** An MCA device */ +struct mca_device { + /** Generic device */ + struct device dev; + /** Slot number */ + unsigned int slot; + /** POS register values */ + unsigned char pos[8]; + /** Driver for this device */ + struct mca_driver *driver; + /** Driver-private data + * + * Use mca_set_drvdata() and mca_get_drvdata() to access + * this field. + */ + void *priv; + /** Driver name */ + const char *driver_name; +}; + +#define MCA_ID(mca) ( ( (mca)->pos[1] << 8 ) + (mca)->pos[0] ) + +/** An MCA driver */ +struct mca_driver { + /** MCA ID table */ + struct mca_device_id *ids; + /** Number of entries in MCA ID table */ + unsigned int id_count; + /** + * Probe device + * + * @v mca MCA device + * @v id Matching entry in ID table + * @ret rc Return status code + */ + int ( * probe ) ( struct mca_device *mca, + const struct mca_device_id *id ); + /** + * Remove device + * + * @v mca MCA device + */ + void ( * remove ) ( struct mca_device *mca ); +}; + +/** MCA driver table */ +#define MCA_DRIVERS __table ( struct mca_driver, "mca_drivers" ) + +/** Declare an MCA driver */ +#define __mca_driver __table_entry ( MCA_DRIVERS, 01 ) + +/** + * Set MCA driver-private data + * + * @v mca MCA device + * @v priv Private data + */ +static inline void mca_set_drvdata ( struct mca_device *mca, void *priv ) { + mca->priv = priv; +} + +/** + * Get MCA driver-private data + * + * @v mca MCA device + * @ret priv Private data + */ +static inline void * mca_get_drvdata ( struct mca_device *mca ) { + return mca->priv; +} + +#endif diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/md5.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/md5.h new file mode 100644 index 0000000..03d65c1 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/md5.h @@ -0,0 +1,24 @@ +#ifndef _GPXE_MD5_H +#define _GPXE_MD5_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct digest_algorithm; + +#include <stdint.h> + +#define MD5_DIGEST_SIZE 16 +#define MD5_BLOCK_WORDS 16 +#define MD5_HASH_WORDS 4 + +struct md5_ctx { + u32 hash[MD5_HASH_WORDS]; + u32 block[MD5_BLOCK_WORDS]; + u64 byte_count; +}; + +#define MD5_CTX_SIZE sizeof ( struct md5_ctx ) + +extern struct digest_algorithm md5_algorithm; + +#endif /* _GPXE_MD5_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/memmap.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/memmap.h new file mode 100644 index 0000000..dc5bec3 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/memmap.h @@ -0,0 +1,36 @@ +#ifndef _GPXE_MEMMAP_H +#define _GPXE_MEMMAP_H + +#include <stdint.h> + +/** + * @file + * + * Memory mapping + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** A usable memory region */ +struct memory_region { + /** Physical start address */ + uint64_t start; + /** Physical end address */ + uint64_t end; +}; + +/** Maximum number of memory regions we expect to encounter */ +#define MAX_MEMORY_REGIONS 8 + +/** A memory map */ +struct memory_map { + /** Memory regions */ + struct memory_region regions[MAX_MEMORY_REGIONS]; + /** Number of used regions */ + unsigned int count; +}; + +extern void get_memmap ( struct memory_map *memmap ); + +#endif /* _GPXE_MEMMAP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/monojob.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/monojob.h new file mode 100644 index 0000000..35ff4fd --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/monojob.h @@ -0,0 +1,17 @@ +#ifndef _GPXE_MONOJOB_H +#define _GPXE_MONOJOB_H + +/** @file + * + * Single foreground job + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct job_interface; + +extern struct job_interface monojob; +extern int monojob_wait ( const char *string ); + +#endif /* _GPXE_MONOJOB_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/net80211.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/net80211.h new file mode 100644 index 0000000..d924941 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/net80211.h @@ -0,0 +1,1016 @@ +#ifndef _GPXE_NET80211_H +#define _GPXE_NET80211_H + +#include <gpxe/process.h> +#include <gpxe/ieee80211.h> +#include <gpxe/iobuf.h> +#include <gpxe/netdevice.h> +#include <gpxe/rc80211.h> + +/** @file + * + * The gPXE 802.11 MAC layer. + */ + +/* + * Major things NOT YET supported: + * - any type of security + * - 802.11n + * + * Major things that probably will NEVER be supported, barring a + * compelling use case and/or corporate sponsorship: + * - QoS + * - 802.1X authentication ("WPA Enterprise") + * - Contention-free periods + * - "ad-hoc" networks (IBSS), monitor mode, host AP mode + * - hidden networks on the 5GHz band due to regulatory issues + * - spectrum management on the 5GHz band (TPC and DFS), as required + * in some non-US regulatory domains + * - Clause 14 PHYs (Frequency-Hopping Spread Spectrum on 2.4GHz) + * and Clause 16 PHYs (infrared) - I'm not aware of any real-world + * use of these. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* All 802.11 devices are handled using a generic "802.11 device" + net_device, with a link in its `priv' field to a net80211_device + which we use to handle 802.11-specific details. */ + + +/** @defgroup net80211_band RF bands on which an 802.11 device can transmit */ +/** @{ */ + +/** The 2.4 GHz ISM band, unlicensed in most countries */ +#define NET80211_BAND_2GHZ 0 +/** The band from 4.9 GHz to 5.7 GHz, which tends to be more restricted */ +#define NET80211_BAND_5GHZ 1 +/** Number of RF bands */ +#define NET80211_NR_BANDS 2 + +/** Bitmask for the 2GHz band */ +#define NET80211_BAND_BIT_2GHZ (1 << 0) +/** Bitmask for the 5GHz band */ +#define NET80211_BAND_BIT_5GHZ (1 << 1) + +/** @} */ + + +/** @defgroup net80211_mode 802.11 operation modes supported by hardware */ +/** @{ */ + +/** 802.11a: 54 Mbps operation using OFDM signaling on the 5GHz band */ +#define NET80211_MODE_A (1 << 0) + +/** 802.11b: 1-11 Mbps operation using DSSS/CCK signaling on the 2.4GHz band */ +#define NET80211_MODE_B (1 << 1) + +/** 802.11g: 54 Mbps operation using ERP/OFDM signaling on the 2.4GHz band */ +#define NET80211_MODE_G (1 << 2) + +/** 802.11n: High-rate operation using MIMO technology on 2.4GHz or 5GHz */ +#define NET80211_MODE_N (1 << 3) + +/** @} */ + + +/** @defgroup net80211_cfg Constants for the net80211 config callback */ +/** @{ */ + +/** Channel choice (@c dev->channel) or regulatory parameters have changed */ +#define NET80211_CFG_CHANNEL (1 << 0) + +/** Requested transmission rate (@c dev->rate) has changed */ +#define NET80211_CFG_RATE (1 << 1) + +/** Association has been established with a new BSS (@c dev->bssid) */ +#define NET80211_CFG_ASSOC (1 << 2) + +/** Low-level link parameters (short preamble, protection, etc) have changed */ +#define NET80211_CFG_PHY_PARAMS (1 << 3) + +/** @} */ + + +/** An 802.11 security handshaking protocol */ +enum net80211_security_proto { + /** No security handshaking + * + * This might be used with an open network or with WEP, as + * WEP does not have a cryptographic handshaking phase. + */ + NET80211_SECPROT_NONE = 0, + + /** Pre-shared key handshaking + * + * This implements the "WPA Personal" handshake. 802.1X + * authentication is not performed -- the user supplies a + * pre-shared key directly -- but there is a 4-way handshake + * between client and AP to verify that both have the same key + * without revealing the contents of that key. + */ + NET80211_SECPROT_PSK = 1, + + /** Full EAP 802.1X handshaking + * + * This implements the "WPA Enterprise" handshake, connecting + * to an 802.1X authentication server to provide credentials + * and receive a pairwise master key (PMK), which is then used + * in the same 4-way handshake as the PSK method. + */ + NET80211_SECPROT_EAP = 2, +}; + + +/** An 802.11 data encryption algorithm */ +enum net80211_crypto_alg { + /** No security, an "Open" network */ + NET80211_CRYPT_NONE = 0, + + /** Network protected with WEP (awful RC4-based system) + * + * WEP uses a naive application of RC4, with a monotonically + * increasing initialization vector that is prepended to the + * key to initialize the RC4 keystream. It is highly insecure + * and can be completely cracked or subverted using automated, + * robust, freely available tools (aircrack-ng) in minutes. + * + * 40-bit and 104-bit WEP are differentiated only by the size + * of the key. They may be advertised as 64-bit and 128-bit, + * counting the non-random IV as part of the key bits. + */ + NET80211_CRYPT_WEP = 1, + + /** Network protected with TKIP (better RC4-based system) + * + * Usually known by its trade name of WPA (Wi-Fi Protected + * Access), TKIP implements a message integrity code (MIC) + * called Michael, a timestamp counter for replay prevention, + * and a key mixing function that together remove almost all + * the security problems with WEP. Countermeasures are + * implemented to prevent high data-rate attacks. + * + * There exists one known attack on TKIP, that allows one to + * send between 7 and 15 arbitrary short data packets on a + * QoS-enabled network given about an hour of data + * gathering. Since gPXE does not support QoS for 802.11 + * networks, this is not a threat to us. The only other method + * is a brute-force passphrase attack. + */ + NET80211_CRYPT_TKIP = 2, + + /** Network protected with CCMP (AES-based system) + * + * Often called WPA2 in commerce, or RSNA (Robust Security + * Network Architecture) in the 802.11 standard, CCMP is + * highly secure and does not have any known attack vectors. + * Since it is based on a block cipher, the statistical + * correlation and "chopchop" attacks used with great success + * against WEP and minor success against TKIP fail. + */ + NET80211_CRYPT_CCMP = 3, +}; + + +/** @defgroup net80211_state Bits for the 802.11 association state field */ +/** @{ */ + +/** An error code indicating the failure mode, or 0 if successful */ +#define NET80211_STATUS_MASK 0x7F + +/** Whether the error code provided is a "reason" code, not a "status" code */ +#define NET80211_IS_REASON 0x80 + +/** Whether we have found the network we will be associating with */ +#define NET80211_PROBED (1 << 8) + +/** Whether we have successfully authenticated with the network + * + * This usually has nothing to do with actual security; it is a + * holdover from older 802.11 implementation ideas. + */ +#define NET80211_AUTHENTICATED (1 << 9) + +/** Whether we have successfully associated with the network */ +#define NET80211_ASSOCIATED (1 << 10) + +/** Whether we have completed security handshaking with the network + * + * Once this is set, we can send data packets. For that reason this + * bit is set even in cases where no security handshaking is + * required. + */ +#define NET80211_CRYPTO_SYNCED (1 << 11) + +/** Whether the auto-association task is running */ +#define NET80211_WORKING (1 << 12) + +/** Whether the auto-association task is waiting for a reply from the AP */ +#define NET80211_WAITING (1 << 13) + +/** Whether the auto-association task should be suppressed + * + * This is set by the `iwlist' command so that it can open the device + * without starting another probe process that will interfere with its + * own. + */ +#define NET80211_NO_ASSOC (1 << 14) + +/** Whether this association was performed using a broadcast SSID + * + * If the user opened this device without netX/ssid set, the device's + * SSID will be set to that of the network it chooses to associate + * with, but the netX/ssid setting will remain blank. If we don't + * remember that we started from no specified SSID, it will appear + * every time settings are updated (e.g. after DHCP) that we need to + * reassociate due to the difference between the set SSID and our own. + */ +#define NET80211_AUTO_SSID (1 << 15) + + +/** @} */ + + +/** @defgroup net80211_phy 802.11 physical layer flags */ +/** @{ */ + +/** Whether to use RTS/CTS or CTS-to-self protection for transmissions + * + * Since the RTS or CTS is transmitted using 802.11b signaling, and + * includes a field indicating the amount of time that will be used by + * transmission of the following packet, this serves as an effective + * protection mechanism to avoid 802.11b clients interfering with + * 802.11g clients on mixed networks. + */ +#define NET80211_PHY_USE_PROTECTION (1 << 1) + +/** Whether to use 802.11b short preamble operation + * + * Short-preamble operation can moderately increase throughput on + * 802.11b networks operating between 2Mbps and 11Mbps. It is + * irrelevant for 802.11g data rates, since they use a different + * modulation scheme. + */ +#define NET80211_PHY_USE_SHORT_PREAMBLE (1 << 2) + +/** Whether to use 802.11g short slot operation + * + * This affects a low-level timing parameter of 802.11g transmissions. + */ +#define NET80211_PHY_USE_SHORT_SLOT (1 << 3) + +/** @} */ + + +/** The maximum number of TX rates we allow to be configured simultaneously */ +#define NET80211_MAX_RATES 16 + +/** The maximum number of channels we allow to be configured simultaneously */ +#define NET80211_MAX_CHANNELS 32 + +/** Seconds we'll wait to get all fragments of a packet */ +#define NET80211_FRAG_TIMEOUT 2 + +/** The number of fragments we can receive at once + * + * The 802.11 standard requires that this be at least 3. + */ +#define NET80211_NR_CONCURRENT_FRAGS 3 + +/** Maximum TX power to allow (dBm), if we don't get a regulatory hint */ +#define NET80211_REG_TXPOWER 20 + + +struct net80211_device; + +/** Operations that must be implemented by an 802.11 driver */ +struct net80211_device_operations { + /** Open 802.11 device + * + * @v dev 802.11 device + * @ret rc Return status code + * + * This method should allocate RX I/O buffers and enable the + * hardware to start transmitting and receiving packets on the + * channels its net80211_register() call indicated it could + * handle. It does not need to tune the antenna to receive + * packets on any particular channel. + */ + int ( * open ) ( struct net80211_device *dev ); + + /** Close 802.11 network device + * + * @v dev 802.11 device + * + * This method should stop the flow of packets, and call + * net80211_tx_complete() for any packets remaining in the + * device's TX queue. + */ + void ( * close ) ( struct net80211_device *dev ); + + /** Transmit packet on 802.11 network device + * + * @v dev 802.11 device + * @v iobuf I/O buffer + * @ret rc Return status code + * + * This method should cause the hardware to initiate + * transmission of the I/O buffer, using the channel and rate + * most recently indicated by an appropriate call to the + * @c config callback. The 802.11 layer guarantees that said + * channel and rate will be the same as those currently + * reflected in the fields of @a dev. + * + * If this method returns success, the I/O buffer remains + * owned by the network layer's TX queue, and the driver must + * eventually call net80211_tx_complete() to free the buffer + * whether transmission succeeded or not. If this method + * returns failure, it will be interpreted as "failure to + * enqueue buffer" and the I/O buffer will be immediately + * released. + * + * This method is guaranteed to be called only when the device + * is open. + */ + int ( * transmit ) ( struct net80211_device *dev, + struct io_buffer *iobuf ); + + /** Poll for completed and received packets + * + * @v dev 802.11 device + * + * This method should cause the hardware to check for + * completed transmissions and received packets. Any received + * packets should be delivered via net80211_rx(), and + * completed transmissions should be indicated using + * net80211_tx_complete(). + * + * This method is guaranteed to be called only when the device + * is open. + */ + void ( * poll ) ( struct net80211_device *dev ); + + /** Enable or disable interrupts + * + * @v dev 802.11 device + * @v enable If TRUE, interrupts should be enabled + */ + void ( * irq ) ( struct net80211_device *dev, int enable ); + + /** Update hardware state to match 802.11 layer state + * + * @v dev 802.11 device + * @v changed Set of flags indicating what may have changed + * @ret rc Return status code + * + * This method should cause the hardware state to be + * reinitialized from the state indicated in fields of + * net80211_device, in the areas indicated by bits set in + * @a changed. If the hardware is unable to do so, this method + * may return an appropriate error indication. + * + * This method is guaranteed to be called only when the device + * is open. + */ + int ( * config ) ( struct net80211_device *dev, int changed ); +}; + +/** An 802.11 RF channel. */ +struct net80211_channel +{ + /** The band with which this channel is associated */ + u8 band; + + /** A channel number interpreted according to the band + * + * The 2.4GHz band uses channel numbers from 1-13 at 5MHz + * intervals such that channel 1 is 2407 MHz; channel 14, + * legal for use only in Japan, is defined separately as 2484 + * MHz. Adjacent channels will overlap, since 802.11 + * transmissions use a 20 MHz (4-channel) bandwidth. Most + * commonly, channels 1, 6, and 11 are used. + * + * The 5GHz band uses channel numbers derived directly from + * the frequency; channel 0 is 5000 MHz, and channels are + * always spaced 5 MHz apart. Channel numbers over 180 are + * relative to 4GHz instead of 5GHz, but these are rarely + * seen. Most channels are not legal for use. + */ + u8 channel_nr; + + /** The center frequency for this channel + * + * Currently a bandwidth of 20 MHz is assumed. + */ + u16 center_freq; + + /** Hardware channel value */ + u16 hw_value; + + /** Maximum allowable transmit power, in dBm + * + * This should be interpreted as EIRP, the power supplied to + * an ideal isotropic antenna in order to achieve the same + * average signal intensity as the real hardware at a + * particular distance. + * + * Currently no provision is made for directional antennas. + */ + u8 maxpower; +}; + +/** Information on the capabilities of an 802.11 hardware device + * + * In its probe callback, an 802.11 driver must read hardware + * registers to determine the appropriate contents of this structure, + * fill it, and pass it to net80211_register() so that the 802.11 + * layer knows how to treat the hardware and what to advertise as + * supported to access points. + */ +struct net80211_hw_info +{ + /** Default hardware MAC address. + * + * The user may change this by setting the @c netX/mac setting + * before the driver's open function is called; in that case + * the driver must set the hardware MAC address to the address + * contained in the wrapping net_device's ll_addr field, or if + * that is impossible, set that ll_addr field back to the + * unchangeable hardware MAC address. + */ + u8 hwaddr[ETH_ALEN]; + + /** A bitwise OR of the 802.11x modes supported by this device */ + int modes; + + /** A bitwise OR of the bands on which this device can communicate */ + int bands; + + /** A set of flags indicating peculiarities of this device. */ + enum { + /** Received frames include a frame check sequence. */ + NET80211_HW_RX_HAS_FCS = (1 << 1), + + /** Hardware doesn't support 2.4GHz short preambles + * + * This is only relevant for 802.11b operation above + * 2Mbps. All 802.11g devices support short preambles. + */ + NET80211_HW_NO_SHORT_PREAMBLE = (1 << 2), + + /** Hardware doesn't support 802.11g short slot operation */ + NET80211_HW_NO_SHORT_SLOT = (1 << 3), + } flags; + + /** Signal strength information that can be provided by the device + * + * Signal strength is passed to net80211_rx(), primarily to + * allow determination of the closest access point for a + * multi-AP network. The units are provided for completeness + * of status displays. + */ + enum { + /** No signal strength information supported */ + NET80211_SIGNAL_NONE = 0, + /** Signal strength in arbitrary units */ + NET80211_SIGNAL_ARBITRARY, + /** Signal strength in decibels relative to arbitrary base */ + NET80211_SIGNAL_DB, + /** Signal strength in decibels relative to 1mW */ + NET80211_SIGNAL_DBM, + } signal_type; + + /** Maximum signal in arbitrary cases + * + * If signal_type is NET80211_SIGNAL_ARBITRARY or + * NET80211_SIGNAL_DB, the driver should report it on a scale + * from 0 to signal_max. + */ + unsigned signal_max; + + /** List of RF channels supported by the card */ + struct net80211_channel channels[NET80211_MAX_CHANNELS]; + + /** Number of supported channels */ + int nr_channels; + + /** List of transmission rates supported by the card, indexed by band + * + * Rates should be in 100kbps increments (e.g. 11 Mbps would + * be represented as the number 110). + */ + u16 rates[NET80211_NR_BANDS][NET80211_MAX_RATES]; + + /** Number of supported rates, indexed by band */ + int nr_rates[NET80211_NR_BANDS]; + + /** Estimate of the time required to change channels, in microseconds + * + * If this is not known, a guess on the order of a few + * milliseconds (value of 1000-5000) is reasonable. + */ + unsigned channel_change_time; +}; + +/** Structure tracking received fragments for a packet + * + * We set up a fragment cache entry when we receive a packet marked as + * fragment 0 with the "more fragments" bit set in its frame control + * header. We are required by the 802.11 standard to track 3 + * fragmented packets arriving simultaneously; if we receive more we + * may drop some. Upon receipt of a new fragment-0 packet, if no entry + * is available or expired, we take over the most @e recent entry for + * the new packet, since we don't want to starve old entries from ever + * finishing at all. If we get a fragment after the zeroth with no + * cache entry for its packet, we drop it. + */ +struct net80211_frag_cache +{ + /** Whether this cache entry is in use */ + u8 in_use; + + /** Sequence number of this MSDU (packet) */ + u16 seqnr; + + /** Timestamp from point at which first fragment was collected */ + u32 start_ticks; + + /** Buffers for each fragment */ + struct io_buffer *iob[16]; +}; + +/** Interface to an 802.11 cryptographic algorithm + * + * Cryptographic algorithms define a net80211_crypto structure + * statically, using a gPXE linker table to make it available to the + * 802.11 layer. When the algorithm needs to be used, the 802.11 code + * will allocate a copy of the static definition plus whatever space + * the algorithm has requested for private state, and point + * net80211_device::crypto at it. + */ +struct net80211_crypto +{ + /** The cryptographic algorithm implemented */ + enum net80211_crypto_alg algorithm; + + /** Initialize cryptographic algorithm using a given key + * + * @v crypto 802.11 cryptographic algorithm + * @v key Pointer to key bytes + * @v keylen Number of key bytes + * @ret rc Return status code + * + * This method is passed the communication key provided by the + * security handshake handler, which will already be in the + * low-level form required. + */ + int ( * initialize ) ( struct net80211_crypto *crypto, u8 *key, + int keylen ); + + /** Encrypt a frame using the cryptographic algorithm + * + * @v crypto 802.11 cryptographic algorithm + * @v iob I/O buffer + * @ret eiob Newly allocated I/O buffer with encrypted packet + * + * This method is called to encrypt a single frame. It is + * guaranteed that initialize() will have completed + * successfully before this method is called. + * + * The frame passed already has an 802.11 header prepended, + * but the PROTECTED bit in the frame control field will not + * be set; this method is responsible for setting it. The + * returned I/O buffer should contain a complete copy of @a + * iob, including the 802.11 header, but with the PROTECTED + * bit set, the data encrypted, and whatever encryption + * headers/trailers are necessary added. + * + * This method should never free the passed I/O buffer. + * + * Return NULL if the packet could not be encrypted, due to + * memory limitations or otherwise. + */ + struct io_buffer * ( * encrypt ) ( struct net80211_crypto *crypto, + struct io_buffer *iob ); + + /** Decrypt a frame using the cryptographic algorithm + * + * @v crypto 802.11 cryptographic algorithm + * @v eiob Encrypted I/O buffer + * @ret iob Newly allocated I/O buffer with decrypted packet + * + * This method is called to decrypt a single frame. It is + * guaranteed that initialize() will have completed + * successfully before this method is called. + * + * Decryption follows the reverse of the pattern used for + * encryption: this method must copy the 802.11 header into + * the returned packet, decrypt the data stream, remove any + * encryption header or trailer, and clear the PROTECTED bit + * in the frame control header. + * + * This method should never free the passed I/O buffer. + * + * Return NULL if memory was not available for decryption, if + * a consistency or integrity check on the decrypted frame + * failed, or if the decrypted frame should not be processed + * by the network stack for any other reason. + */ + struct io_buffer * ( * decrypt ) ( struct net80211_crypto *crypto, + struct io_buffer *iob ); + + /** Length of private data requested to be allocated */ + int priv_len; + + /** Private data for the algorithm to store key and state info */ + void *priv; +}; + + +struct net80211_probe_ctx; +struct net80211_assoc_ctx; + + +/** Structure encapsulating the complete state of an 802.11 device + * + * An 802.11 device is always wrapped by a network device, and this + * network device is always pointed to by the @a netdev field. In + * general, operations should never be performed by 802.11 code using + * netdev functions directly. It is usually the case that the 802.11 + * layer might need to do some processing or bookkeeping on top of + * what the netdevice code will do. + */ +struct net80211_device +{ + /** The net_device that wraps us. */ + struct net_device *netdev; + + /** List of 802.11 devices. */ + struct list_head list; + + /** 802.11 device operations */ + struct net80211_device_operations *op; + + /** Driver private data */ + void *priv; + + /** Information about the hardware, provided to net80211_register() */ + struct net80211_hw_info *hw; + + /* ---------- Channel and rate fields ---------- */ + + /** A list of all possible channels we might use */ + struct net80211_channel channels[NET80211_MAX_CHANNELS]; + + /** The number of channels in the channels array */ + u8 nr_channels; + + /** The channel currently in use, as an index into the channels array */ + u8 channel; + + /** A list of all possible TX rates we might use + * + * Rates are in units of 100 kbps. + */ + u16 rates[NET80211_MAX_RATES]; + + /** The number of transmission rates in the rates array */ + u8 nr_rates; + + /** The rate currently in use, as an index into the rates array */ + u8 rate; + + /** The rate to use for RTS/CTS transmissions + * + * This is always the fastest basic rate that is not faster + * than the data rate in use. Also an index into the rates array. + */ + u8 rtscts_rate; + + /** Bitmask of basic rates + * + * If bit N is set in this value, with the LSB considered to + * be bit 0, then rate N in the rates array is a "basic" rate. + * + * We don't decide which rates are "basic"; our AP does, and + * we respect its wishes. We need to be able to identify basic + * rates in order to calculate the duration of a CTS packet + * used for 802.11 g/b interoperability. + */ + u32 basic_rates; + + /* ---------- Association fields ---------- */ + + /** The asynchronous association process. + * + * When an 802.11 netdev is opened, or when the user changes + * the SSID setting on an open 802.11 device, an + * autoassociation task is started by net80211_autoassocate() + * to associate with the new best network. The association is + * asynchronous, but no packets can be transmitted until it is + * complete. If it is successful, the wrapping net_device is + * set as "link up". If it fails, @c assoc_rc will be set with + * an error indication. + */ + struct process proc_assoc; + + /** Network with which we are associating + * + * This will be NULL when we are not actively in the process + * of associating with a network we have already successfully + * probed for. + */ + struct net80211_wlan *associating; + + /** Context for the association process + * + * This is a probe_ctx if the @c PROBED flag is not set in @c + * state, and an assoc_ctx otherwise. + */ + union { + struct net80211_probe_ctx *probe; + struct net80211_assoc_ctx *assoc; + } ctx; + + /** State of our association to the network + * + * Since the association process happens asynchronously, it's + * necessary to have some channel of communication so the + * driver can say "I got an association reply and we're OK" or + * similar. This variable provides that link. It is a bitmask + * of any of NET80211_PROBED, NET80211_AUTHENTICATED, + * NET80211_ASSOCIATED, NET80211_CRYPTO_SYNCED to indicate how + * far along in associating we are; NET80211_WORKING if the + * association task is running; and NET80211_WAITING if a + * packet has been sent that we're waiting for a reply to. We + * can only be crypto-synced if we're associated, we can + * only be associated if we're authenticated, we can only be + * authenticated if we've probed. + * + * If an association process fails (that is, we receive a + * packet with an error indication), the error code is copied + * into bits 6-0 of this variable and bit 7 is set to specify + * what type of error code it is. An AP can provide either a + * "status code" (0-51 are defined) explaining why it refused + * an association immediately, or a "reason code" (0-45 are + * defined) explaining why it canceled an association after it + * had originally OK'ed it. Status and reason codes serve + * similar functions, but they use separate error message + * tables. A gPXE-formatted return status code (negative) is + * placed in @c assoc_rc. + * + * If the failure to associate is indicated by a status code, + * the NET80211_IS_REASON bit will be clear; if it is + * indicated by a reason code, the bit will be set. If we were + * successful, both zero status and zero reason mean success, + * so there is no ambiguity. + * + * To prevent association when opening the device, user code + * can set the NET80211_NO_ASSOC bit. The final bit in this + * variable, NET80211_AUTO_SSID, is used to remember whether + * we picked our SSID through automated probing as opposed to + * user specification; the distinction becomes relevant in the + * settings applicator. + */ + u16 state; + + /** Return status code associated with @c state */ + int assoc_rc; + + /* ---------- Parameters of currently associated network ---------- */ + + /** 802.11 cryptographic algorithm for our current network + * + * For an open network, this will be set to NULL. + */ + struct net80211_crypto *crypto; + + /** MAC address of the access point most recently associated */ + u8 bssid[ETH_ALEN]; + + /** SSID of the access point we are or will be associated with + * + * Although the SSID field in 802.11 packets is generally not + * NUL-terminated, here and in net80211_wlan we add a NUL for + * convenience. + */ + char essid[IEEE80211_MAX_SSID_LEN+1]; + + /** Association ID given to us by the AP */ + u16 aid; + + /** TSFT value for last beacon received, microseconds */ + u64 last_beacon_timestamp; + + /** Time between AP sending beacons, microseconds */ + u32 tx_beacon_interval; + + /** Smoothed average time between beacons, microseconds */ + u32 rx_beacon_interval; + + /* ---------- Physical layer information ---------- */ + + /** Physical layer options + * + * These control the use of CTS protection, short preambles, + * and short-slot operation. + */ + int phy_flags; + + /** Signal strength of last received packet */ + int last_signal; + + /** Rate control state */ + struct rc80211_ctx *rctl; + + /* ---------- Packet handling state ---------- */ + + /** Fragment reassembly state */ + struct net80211_frag_cache frags[NET80211_NR_CONCURRENT_FRAGS]; + + /** The sequence number of the last packet we sent */ + u16 last_tx_seqnr; + + /** Packet duplication elimination state + * + * We are only required to handle immediate duplicates for + * each direct sender, and since we can only have one direct + * sender (the AP), we need only keep the sequence control + * field from the most recent packet we've received. Thus, + * this field stores the last sequence control field we've + * received for a packet from the AP. + */ + u16 last_rx_seq; + + /** RX management packet queue + * + * Sometimes we want to keep probe, beacon, and action packets + * that we receive, such as when we're scanning for networks. + * Ordinarily we drop them because they are sent at a large + * volume (ten beacons per second per AP, broadcast) and we + * have no need of them except when we're scanning. + * + * When keep_mgmt is TRUE, received probe, beacon, and action + * management packets will be stored in this queue. + */ + struct list_head mgmt_queue; + + /** RX management packet info queue + * + * We need to keep track of the signal strength for management + * packets we're keeping, because that provides the only way + * to distinguish between multiple APs for the same network. + * Since we can't extend io_buffer to store signal, this field + * heads a linked list of "RX packet info" structures that + * contain that signal strength field. Its entries always + * parallel the entries in mgmt_queue, because the two queues + * are always added to or removed from in parallel. + */ + struct list_head mgmt_info_queue; + + /** Whether to store management packets + * + * Received beacon, probe, and action packets will be added to + * mgmt_queue (and their signal strengths added to + * mgmt_info_queue) only when this variable is TRUE. It should + * be set by net80211_keep_mgmt() (which returns the old + * value) only when calling code is prepared to poll the + * management queue frequently, because packets will otherwise + * pile up and exhaust memory. + */ + int keep_mgmt; +}; + +/** Structure representing a probed network. + * + * This is returned from the net80211_probe_finish functions and + * passed to the low-level association functions. At least essid, + * bssid, channel, beacon, and security must be filled in if you want + * to build this structure manually. + */ +struct net80211_wlan +{ + /** The human-readable ESSID (network name) + * + * Although the 802.11 SSID field is generally not + * NUL-terminated, the gPXE code adds an extra NUL (and + * expects one in this structure) for convenience. + */ + char essid[IEEE80211_MAX_SSID_LEN+1]; + + /** MAC address of the strongest-signal access point for this ESSID */ + u8 bssid[ETH_ALEN]; + + /** Signal strength of beacon frame from that access point */ + int signal; + + /** The channel on which that access point communicates + * + * This is a raw channel number (net80211_channel::channel_nr), + * so that it will not be affected by reconfiguration of the + * device channels array. + */ + int channel; + + /** The complete beacon or probe-response frame received */ + struct io_buffer *beacon; + + /** Security handshaking method used on the network */ + enum net80211_security_proto handshaking; + + /** Cryptographic algorithm used on the network */ + enum net80211_crypto_alg crypto; + + /** Link to allow chaining multiple structures into a list to + be returned from net80211_probe_finish_all(). */ + struct list_head list; +}; + + +/** + * @defgroup net80211_probe 802.11 network location API + * @{ + */ +int net80211_prepare_probe ( struct net80211_device *dev, int band, + int active ); +struct net80211_probe_ctx * net80211_probe_start ( struct net80211_device *dev, + const char *essid, + int active ); +int net80211_probe_step ( struct net80211_probe_ctx *ctx ); +struct net80211_wlan * +net80211_probe_finish_best ( struct net80211_probe_ctx *ctx ); +struct list_head *net80211_probe_finish_all ( struct net80211_probe_ctx *ctx ); + +void net80211_free_wlan ( struct net80211_wlan *wlan ); +void net80211_free_wlanlist ( struct list_head *list ); +/** @} */ + + +/** + * @defgroup net80211_mgmt 802.11 network management API + * @{ + */ +struct net80211_device * net80211_get ( struct net_device *netdev ); +void net80211_autoassociate ( struct net80211_device *dev ); + +int net80211_change_channel ( struct net80211_device *dev, int channel ); +void net80211_set_rate_idx ( struct net80211_device *dev, int rate ); + +int net80211_keep_mgmt ( struct net80211_device *dev, int enable ); +struct io_buffer * net80211_mgmt_dequeue ( struct net80211_device *dev, + int *signal ); +int net80211_tx_mgmt ( struct net80211_device *dev, u16 fc, + u8 bssid[ETH_ALEN], struct io_buffer *iob ); +/** @} */ + + +/** + * @defgroup net80211_assoc 802.11 network association API + * @{ + */ +int net80211_prepare_assoc ( struct net80211_device *dev, + struct net80211_wlan *wlan ); +int net80211_send_auth ( struct net80211_device *dev, + struct net80211_wlan *wlan, int method ); +int net80211_send_assoc ( struct net80211_device *dev, + struct net80211_wlan *wlan ); +/** @} */ + + +/** + * @defgroup net80211_driver 802.11 driver interface API + * @{ + */ +struct net80211_device *net80211_alloc ( size_t priv_size ); +int net80211_register ( struct net80211_device *dev, + struct net80211_device_operations *ops, + struct net80211_hw_info *hw ); +u16 net80211_duration ( struct net80211_device *dev, int bytes, u16 rate ); +void net80211_rx ( struct net80211_device *dev, struct io_buffer *iob, + int signal, u16 rate ); +void net80211_rx_err ( struct net80211_device *dev, + struct io_buffer *iob, int rc ); +void net80211_tx_complete ( struct net80211_device *dev, + struct io_buffer *iob, int retries, int rc ); +void net80211_unregister ( struct net80211_device *dev ); +void net80211_free ( struct net80211_device *dev ); +/** @} */ + +/** + * Calculate duration field for a CTS control frame + * + * @v dev 802.11 device + * @v size Size of the packet being cleared to send + * + * A CTS control frame's duration field captures the frame being + * protected and its 10-byte ACK. + */ +static inline u16 net80211_cts_duration ( struct net80211_device *dev, + int size ) +{ + return ( net80211_duration ( dev, 10, + dev->rates[dev->rtscts_rate] ) + + net80211_duration ( dev, size, dev->rates[dev->rate] ) ); +} + +#endif diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/netdevice.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/netdevice.h new file mode 100644 index 0000000..fd77d89 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/netdevice.h @@ -0,0 +1,525 @@ +#ifndef _GPXE_NETDEVICE_H +#define _GPXE_NETDEVICE_H + +/** @file + * + * Network device management + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/list.h> +#include <gpxe/tables.h> +#include <gpxe/refcnt.h> +#include <gpxe/settings.h> + +struct io_buffer; +struct net_device; +struct net_protocol; +struct ll_protocol; +struct device; + +/** Maximum length of a hardware address + * + * The longest currently-supported link-layer address is for IPoIB. + */ +#define MAX_HW_ADDR_LEN 8 + +/** Maximum length of a link-layer address + * + * The longest currently-supported link-layer address is for IPoIB. + */ +#define MAX_LL_ADDR_LEN 20 + +/** Maximum length of a link-layer header + * + * The longest currently-supported link-layer header is for 802.11: a + * 24-byte frame header plus an 8-byte 802.3 LLC/SNAP header. (The + * IPoIB link-layer pseudo-header doesn't actually include link-layer + * addresses; see ipoib.c for details). + */ +#define MAX_LL_HEADER_LEN 32 + +/** Maximum length of a network-layer address */ +#define MAX_NET_ADDR_LEN 4 + +/** + * A network-layer protocol + * + */ +struct net_protocol { + /** Protocol name */ + const char *name; + /** + * Process received packet + * + * @v iobuf I/O buffer + * @v netdev Network device + * @v ll_source Link-layer source address + * + * This method takes ownership of the I/O buffer. + */ + int ( * rx ) ( struct io_buffer *iobuf, struct net_device *netdev, + const void *ll_source ); + /** + * Transcribe network-layer address + * + * @v net_addr Network-layer address + * @ret string Human-readable transcription of address + * + * This method should convert the network-layer address into a + * human-readable format (e.g. dotted quad notation for IPv4). + * + * The buffer used to hold the transcription is statically + * allocated. + */ + const char * ( *ntoa ) ( const void * net_addr ); + /** Network-layer protocol + * + * This is an ETH_P_XXX constant, in network-byte order + */ + uint16_t net_proto; + /** Network-layer address length */ + uint8_t net_addr_len; +}; + +/** + * A link-layer protocol + * + */ +struct ll_protocol { + /** Protocol name */ + const char *name; + /** + * Add link-layer header + * + * @v netdev Network device + * @v iobuf I/O buffer + * @v ll_dest Link-layer destination address + * @v ll_source Source link-layer address + * @v net_proto Network-layer protocol, in network-byte order + * @ret rc Return status code + */ + int ( * push ) ( struct net_device *netdev, struct io_buffer *iobuf, + const void *ll_dest, const void *ll_source, + uint16_t net_proto ); + /** + * Remove link-layer header + * + * @v netdev Network device + * @v iobuf I/O buffer + * @ret ll_dest Link-layer destination address + * @ret ll_source Source link-layer address + * @ret net_proto Network-layer protocol, in network-byte order + * @ret rc Return status code + */ + int ( * pull ) ( struct net_device *netdev, struct io_buffer *iobuf, + const void **ll_dest, const void **ll_source, + uint16_t *net_proto ); + /** + * Initialise link-layer address + * + * @v hw_addr Hardware address + * @v ll_addr Link-layer address to fill in + */ + void ( * init_addr ) ( const void *hw_addr, void *ll_addr ); + /** + * Transcribe link-layer address + * + * @v ll_addr Link-layer address + * @ret string Human-readable transcription of address + * + * This method should convert the link-layer address into a + * human-readable format. + * + * The buffer used to hold the transcription is statically + * allocated. + */ + const char * ( * ntoa ) ( const void *ll_addr ); + /** + * Hash multicast address + * + * @v af Address family + * @v net_addr Network-layer address + * @v ll_addr Link-layer address to fill in + * @ret rc Return status code + */ + int ( * mc_hash ) ( unsigned int af, const void *net_addr, + void *ll_addr ); + /** Link-layer protocol + * + * This is an ARPHRD_XXX constant, in network byte order. + */ + uint16_t ll_proto; + /** Hardware address length */ + uint8_t hw_addr_len; + /** Link-layer address length */ + uint8_t ll_addr_len; + /** Link-layer header length */ + uint8_t ll_header_len; +}; + +/** Network device operations */ +struct net_device_operations { + /** Open network device + * + * @v netdev Network device + * @ret rc Return status code + * + * This method should allocate RX I/O buffers and enable + * the hardware to start transmitting and receiving packets. + */ + int ( * open ) ( struct net_device *netdev ); + /** Close network device + * + * @v netdev Network device + * + * This method should stop the flow of packets, and free up + * any packets that are currently in the device's TX queue. + */ + void ( * close ) ( struct net_device *netdev ); + /** Transmit packet + * + * @v netdev Network device + * @v iobuf I/O buffer + * @ret rc Return status code + * + * This method should cause the hardware to initiate + * transmission of the I/O buffer. + * + * If this method returns success, the I/O buffer remains + * owned by the net device's TX queue, and the net device must + * eventually call netdev_tx_complete() to free the buffer. + * If this method returns failure, the I/O buffer is + * immediately released; the failure is interpreted as + * "failure to enqueue buffer". + * + * This method is guaranteed to be called only when the device + * is open. + */ + int ( * transmit ) ( struct net_device *netdev, + struct io_buffer *iobuf ); + /** Poll for completed and received packets + * + * @v netdev Network device + * + * This method should cause the hardware to check for + * completed transmissions and received packets. Any received + * packets should be delivered via netdev_rx(). + * + * This method is guaranteed to be called only when the device + * is open. + */ + void ( * poll ) ( struct net_device *netdev ); + /** Enable or disable interrupts + * + * @v netdev Network device + * @v enable Interrupts should be enabled + */ + void ( * irq ) ( struct net_device *netdev, int enable ); +}; + +/** Network device error */ +struct net_device_error { + /** Error status code */ + int rc; + /** Error count */ + unsigned int count; +}; + +/** Maximum number of unique errors that we will keep track of */ +#define NETDEV_MAX_UNIQUE_ERRORS 4 + +/** Network device statistics */ +struct net_device_stats { + /** Count of successful completions */ + unsigned int good; + /** Count of error completions */ + unsigned int bad; + /** Error breakdowns */ + struct net_device_error errors[NETDEV_MAX_UNIQUE_ERRORS]; +}; + +/** + * A network device + * + * This structure represents a piece of networking hardware. It has + * properties such as a link-layer address and methods for + * transmitting and receiving raw packets. + * + * Note that this structure must represent a generic network device, + * not just an Ethernet device. + */ +struct net_device { + /** Reference counter */ + struct refcnt refcnt; + /** List of network devices */ + struct list_head list; + /** List of open network devices */ + struct list_head open_list; + /** Name of this network device */ + char name[8]; + /** Underlying hardware device */ + struct device *dev; + + /** Network device operations */ + struct net_device_operations *op; + + /** Link-layer protocol */ + struct ll_protocol *ll_protocol; + /** Hardware address + * + * This is an address which is an intrinsic property of the + * hardware, e.g. an address held in EEPROM. + * + * Note that the hardware address may not be the same length + * as the link-layer address. + */ + uint8_t hw_addr[MAX_HW_ADDR_LEN]; + /** Link-layer address + * + * This is the current link-layer address assigned to the + * device. It can be changed at runtime. + */ + uint8_t ll_addr[MAX_LL_ADDR_LEN]; + /** Link-layer broadcast address */ + const uint8_t *ll_broadcast; + + /** Current device state + * + * This is the bitwise-OR of zero or more NETDEV_XXX constants. + */ + unsigned int state; + /** Link status code + * + * Zero indicates that the link is up; any other value + * indicates the error preventing link-up. + */ + int link_rc; + /** Maximum packet length + * + * This length includes any link-layer headers. + */ + size_t max_pkt_len; + /** TX packet queue */ + struct list_head tx_queue; + /** RX packet queue */ + struct list_head rx_queue; + /** TX statistics */ + struct net_device_stats tx_stats; + /** RX statistics */ + struct net_device_stats rx_stats; + + /** Configuration settings applicable to this device */ + struct generic_settings settings; + + /** Driver private data */ + void *priv; +}; + +/** Network device is open */ +#define NETDEV_OPEN 0x0001 + +/** Link-layer protocol table */ +#define LL_PROTOCOLS __table ( struct ll_protocol, "ll_protocols" ) + +/** Declare a link-layer protocol */ +#define __ll_protocol __table_entry ( LL_PROTOCOLS, 01 ) + +/** Network-layer protocol table */ +#define NET_PROTOCOLS __table ( struct net_protocol, "net_protocols" ) + +/** Declare a network-layer protocol */ +#define __net_protocol __table_entry ( NET_PROTOCOLS, 01 ) + +extern struct list_head net_devices; +extern struct net_device_operations null_netdev_operations; +extern struct settings_operations netdev_settings_operations; + +/** + * Initialise a network device + * + * @v netdev Network device + * @v op Network device operations + */ +static inline void netdev_init ( struct net_device *netdev, + struct net_device_operations *op ) { + netdev->op = op; +} + +/** + * Stop using a network device + * + * @v netdev Network device + * + * Drivers should call this method immediately before the final call + * to netdev_put(). + */ +static inline void netdev_nullify ( struct net_device *netdev ) { + netdev->op = &null_netdev_operations; +} + +/** + * Get printable network device link-layer address + * + * @v netdev Network device + * @ret name Link-layer address + */ +static inline const char * netdev_addr ( struct net_device *netdev ) { + return netdev->ll_protocol->ntoa ( netdev->ll_addr ); +} + +/** Iterate over all network devices */ +#define for_each_netdev( netdev ) \ + list_for_each_entry ( (netdev), &net_devices, list ) + +/** There exist some network devices + * + * @ret existence Existence of network devices + */ +static inline int have_netdevs ( void ) { + return ( ! list_empty ( &net_devices ) ); +} + +/** + * Get reference to network device + * + * @v netdev Network device + * @ret netdev Network device + */ +static inline __attribute__ (( always_inline )) struct net_device * +netdev_get ( struct net_device *netdev ) { + ref_get ( &netdev->refcnt ); + return netdev; +} + +/** + * Drop reference to network device + * + * @v netdev Network device + */ +static inline __attribute__ (( always_inline )) void +netdev_put ( struct net_device *netdev ) { + ref_put ( &netdev->refcnt ); +} + +/** + * Get driver private area for this network device + * + * @v netdev Network device + * @ret priv Driver private area for this network device + */ +static inline __attribute__ (( always_inline )) void * +netdev_priv ( struct net_device *netdev ) { + return netdev->priv; +} + +/** + * Get per-netdevice configuration settings block + * + * @v netdev Network device + * @ret settings Settings block + */ +static inline __attribute__ (( always_inline )) struct settings * +netdev_settings ( struct net_device *netdev ) { + return &netdev->settings.settings; +} + +/** + * Initialise a per-netdevice configuration settings block + * + * @v generics Generic settings block + * @v refcnt Containing object reference counter, or NULL + * @v name Settings block name + */ +static inline __attribute__ (( always_inline )) void +netdev_settings_init ( struct net_device *netdev ) { + generic_settings_init ( &netdev->settings, + &netdev->refcnt, netdev->name ); + netdev->settings.settings.op = &netdev_settings_operations; +} + +/** + * Mark network device as having link up + * + * @v netdev Network device + */ +static inline __attribute__ (( always_inline )) void +netdev_link_up ( struct net_device *netdev ) { + netdev->link_rc = 0; +} + +/** + * Mark network device as having link down due to a specific error + * + * @v netdev Network device + * @v rc Link status code + */ +static inline __attribute__ (( always_inline )) void +netdev_link_err ( struct net_device *netdev, int rc ) { + netdev->link_rc = rc; +} + +/** + * Check link state of network device + * + * @v netdev Network device + * @ret link_up Link is up + */ +static inline __attribute__ (( always_inline )) int +netdev_link_ok ( struct net_device *netdev ) { + return ( netdev->link_rc == 0 ); +} + +extern void netdev_link_down ( struct net_device *netdev ); +extern int netdev_tx ( struct net_device *netdev, struct io_buffer *iobuf ); +extern void netdev_tx_complete_err ( struct net_device *netdev, + struct io_buffer *iobuf, int rc ); +extern void netdev_tx_complete_next_err ( struct net_device *netdev, int rc ); +extern void netdev_rx ( struct net_device *netdev, struct io_buffer *iobuf ); +extern void netdev_rx_err ( struct net_device *netdev, + struct io_buffer *iobuf, int rc ); +extern void netdev_poll ( struct net_device *netdev ); +extern struct io_buffer * netdev_rx_dequeue ( struct net_device *netdev ); +extern struct net_device * alloc_netdev ( size_t priv_size ); +extern int register_netdev ( struct net_device *netdev ); +extern int netdev_open ( struct net_device *netdev ); +extern void netdev_close ( struct net_device *netdev ); +extern void unregister_netdev ( struct net_device *netdev ); +extern void netdev_irq ( struct net_device *netdev, int enable ); +extern struct net_device * find_netdev ( const char *name ); +extern struct net_device * find_netdev_by_location ( unsigned int bus_type, + unsigned int location ); +extern struct net_device * last_opened_netdev ( void ); +extern int net_tx ( struct io_buffer *iobuf, struct net_device *netdev, + struct net_protocol *net_protocol, const void *ll_dest ); +extern int net_rx ( struct io_buffer *iobuf, struct net_device *netdev, + uint16_t net_proto, const void *ll_source ); + +/** + * Complete network transmission + * + * @v netdev Network device + * @v iobuf I/O buffer + * + * The packet must currently be in the network device's TX queue. + */ +static inline void netdev_tx_complete ( struct net_device *netdev, + struct io_buffer *iobuf ) { + netdev_tx_complete_err ( netdev, iobuf, 0 ); +} + +/** + * Complete network transmission + * + * @v netdev Network device + * + * Completes the oldest outstanding packet in the TX queue. + */ +static inline void netdev_tx_complete_next ( struct net_device *netdev ) { + netdev_tx_complete_next_err ( netdev, 0 ); +} + +#endif /* _GPXE_NETDEVICE_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/null_nap.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/null_nap.h new file mode 100644 index 0000000..0f46eaa --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/null_nap.h @@ -0,0 +1,23 @@ +#ifndef _GPXE_NULL_NAP_H +#define _GPXE_NULL_NAP_H + +/** @file + * + * Null CPU sleeping + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#ifdef NAP_NULL +#define NAP_PREFIX_null +#else +#define NAP_PREFIX_null __null_ +#endif + +static inline __always_inline void +NAP_INLINE ( null, cpu_nap ) ( void ) { + /* Do nothing */ +} + +#endif /* _GPXE_NULL_NAP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/nvo.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/nvo.h new file mode 100644 index 0000000..c965070 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/nvo.h @@ -0,0 +1,55 @@ +#ifndef _GPXE_NVO_H +#define _GPXE_NVO_H + +/** @file + * + * Non-volatile stored options + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/dhcpopts.h> +#include <gpxe/settings.h> + +struct nvs_device; +struct refcnt; + +/** + * A fragment of a non-volatile storage device used for stored options + */ +struct nvo_fragment { + /** Starting address of fragment within NVS device */ + unsigned int address; + /** Length of fragment */ + size_t len; +}; + +/** + * A block of non-volatile stored options + */ +struct nvo_block { + /** Settings block */ + struct settings settings; + /** Underlying non-volatile storage device */ + struct nvs_device *nvs; + /** List of option-containing fragments + * + * The list is terminated by a fragment with a length of zero. + */ + struct nvo_fragment *fragments; + /** Total length of option-containing fragments */ + size_t total_len; + /** Option-containing data */ + void *data; + /** DHCP options block */ + struct dhcp_options dhcpopts; +}; + +extern void nvo_init ( struct nvo_block *nvo, struct nvs_device *nvs, + struct nvo_fragment *fragments, struct refcnt *refcnt ); +extern int register_nvo ( struct nvo_block *nvo, struct settings *parent ); +extern void unregister_nvo ( struct nvo_block *nvo ); + +#endif /* _GPXE_NVO_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/nvs.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/nvs.h new file mode 100644 index 0000000..5c90c65 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/nvs.h @@ -0,0 +1,68 @@ +#ifndef _GPXE_NVS_H +#define _GPXE_NVS_H + +/** @file + * + * Non-volatile storage + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/** A non-volatile storage device */ +struct nvs_device { + /** Word length + * + * This is expressed as the base-2 logarithm of the word + * length in bytes. A value of 0 therefore translates as + * 8-bit words, and a value of 1 translates as 16-bit words. + */ + unsigned int word_len_log2; + /** Device size (in words) */ + unsigned int size; + /** Data block size (in words) + * + * This is the block size used by the device. It must be a + * power of two. Data reads and writes must not cross a block + * boundary. + * + * Many devices allow reads to cross a block boundary, and + * restrict only writes. For the sake of simplicity, we + * assume that the same restriction applies to both reads and + * writes. + */ + unsigned int block_size; + /** Read data from device + * + * @v nvs NVS device + * @v address Address from which to read + * @v data Data buffer + * @v len Length of data buffer + * @ret rc Return status code + * + * Reads may not cross a block boundary. + */ + int ( * read ) ( struct nvs_device *nvs, unsigned int address, + void *data, size_t len ); + /** Write data to device + * + * @v nvs NVS device + * @v address Address to which to write + * @v data Data buffer + * @v len Length of data buffer + * @ret rc Return status code + * + * Writes may not cross a block boundary. + */ + int ( * write ) ( struct nvs_device *nvs, unsigned int address, + const void *data, size_t len ); +}; + +extern int nvs_read ( struct nvs_device *nvs, unsigned int address, + void *data, size_t len ); +extern int nvs_write ( struct nvs_device *nvs, unsigned int address, + const void *data, size_t len ); + +#endif /* _GPXE_NVS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/open.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/open.h new file mode 100644 index 0000000..ebf754d --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/open.h @@ -0,0 +1,105 @@ +#ifndef _GPXE_OPEN_H +#define _GPXE_OPEN_H + +/** @file + * + * Data transfer interface opening + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdarg.h> +#include <gpxe/tables.h> +#include <gpxe/socket.h> + +struct xfer_interface; +struct uri; + +/** Location types */ +enum { + /** Location is a URI + * + * Parameter list for open() is: + * + * struct uri *uri; + */ + LOCATION_URI = 1, + /** Location is a URI string + * + * Parameter list for open() is: + * + * const char *uri_string; + */ + LOCATION_URI_STRING, + /** Location is a socket + * + * Parameter list for open() is: + * + * int semantics; + * struct sockaddr *peer; + * struct sockaddr *local; + */ + LOCATION_SOCKET, +}; + +/** A URI opener */ +struct uri_opener { + /** URI protocol name + * + * This is the "scheme" portion of the URI, e.g. "http" or + * "file". + */ + const char *scheme; + /** Open URI + * + * @v xfer Data transfer interface + * @v uri URI + * @ret rc Return status code + */ + int ( * open ) ( struct xfer_interface *xfer, struct uri *uri ); +}; + +/** URI opener table */ +#define URI_OPENERS __table ( struct uri_opener, "uri_openers" ) + +/** Register a URI opener */ +#define __uri_opener __table_entry ( URI_OPENERS, 01 ) + +/** A socket opener */ +struct socket_opener { + /** Communication semantics (e.g. SOCK_STREAM) */ + int semantics; + /** Address family (e.g. AF_INET) */ + int family; + /** Open socket + * + * @v xfer Data transfer interface + * @v peer Peer socket address + * @v local Local socket address, or NULL + * @ret rc Return status code + */ + int ( * open ) ( struct xfer_interface *xfer, struct sockaddr *peer, + struct sockaddr *local ); +}; + +/** Socket opener table */ +#define SOCKET_OPENERS __table ( struct socket_opener, "socket_openers" ) + +/** Register a socket opener */ +#define __socket_opener __table_entry ( SOCKET_OPENERS, 01 ) + +extern int xfer_open_uri ( struct xfer_interface *xfer, struct uri *uri ); +extern int xfer_open_uri_string ( struct xfer_interface *xfer, + const char *uri_string ); +extern int xfer_open_named_socket ( struct xfer_interface *xfer, + int semantics, struct sockaddr *peer, + const char *name, struct sockaddr *local ); +extern int xfer_open_socket ( struct xfer_interface *xfer, int semantics, + struct sockaddr *peer, struct sockaddr *local ); +extern int xfer_vopen ( struct xfer_interface *xfer, int type, va_list args ); +extern int xfer_open ( struct xfer_interface *xfer, int type, ... ); +extern int xfer_vreopen ( struct xfer_interface *xfer, int type, + va_list args ); + +#endif /* _GPXE_OPEN_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/pci_io.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/pci_io.h new file mode 100644 index 0000000..8b2729a --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/pci_io.h @@ -0,0 +1,124 @@ +#ifndef _GPXE_PCI_IO_H +#define _GPXE_PCI_IO_H + +/** @file + * + * PCI I/O API + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/api.h> +#include <config/ioapi.h> + +/** + * Calculate static inline PCI I/O API function name + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @ret _subsys_func Subsystem API function + */ +#define PCIAPI_INLINE( _subsys, _api_func ) \ + SINGLE_API_INLINE ( PCIAPI_PREFIX_ ## _subsys, _api_func ) + +/** + * Provide a PCI I/O API implementation + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @v _func Implementing function + */ +#define PROVIDE_PCIAPI( _subsys, _api_func, _func ) \ + PROVIDE_SINGLE_API ( PCIAPI_PREFIX_ ## _subsys, _api_func, _func ) + +/** + * Provide a static inline PCI I/O API implementation + * + * @v _prefix Subsystem prefix + * @v _api_func API function + */ +#define PROVIDE_PCIAPI_INLINE( _subsys, _api_func ) \ + PROVIDE_SINGLE_API_INLINE ( PCIAPI_PREFIX_ ## _subsys, _api_func ) + +/* Include all architecture-independent I/O API headers */ +#include <gpxe/efi/efi_pci.h> + +/* Include all architecture-dependent I/O API headers */ +#include <bits/pci_io.h> + +/** + * Determine maximum PCI bus number within system + * + * @ret max_bus Maximum bus number + */ +int pci_max_bus ( void ); + +/** + * Read byte from PCI configuration space + * + * @v pci PCI device + * @v where Location within PCI configuration space + * @v value Value read + * @ret rc Return status code + */ +int pci_read_config_byte ( struct pci_device *pci, unsigned int where, + uint8_t *value ); + +/** + * Read 16-bit word from PCI configuration space + * + * @v pci PCI device + * @v where Location within PCI configuration space + * @v value Value read + * @ret rc Return status code + */ +int pci_read_config_word ( struct pci_device *pci, unsigned int where, + uint16_t *value ); + +/** + * Read 32-bit dword from PCI configuration space + * + * @v pci PCI device + * @v where Location within PCI configuration space + * @v value Value read + * @ret rc Return status code + */ +int pci_read_config_dword ( struct pci_device *pci, unsigned int where, + uint32_t *value ); + +/** + * Write byte to PCI configuration space + * + * @v pci PCI device + * @v where Location within PCI configuration space + * @v value Value to be written + * @ret rc Return status code + */ +int pci_write_config_byte ( struct pci_device *pci, unsigned int where, + uint8_t value ); + +/** + * Write 16-bit word to PCI configuration space + * + * @v pci PCI device + * @v where Location within PCI configuration space + * @v value Value to be written + * @ret rc Return status code + */ +int pci_write_config_word ( struct pci_device *pci, unsigned int where, + uint16_t value ); + +/** + * Write 32-bit dword to PCI configuration space + * + * @v pci PCI device + * @v where Location within PCI configuration space + * @v value Value to be written + * @ret rc Return status code + */ +int pci_write_config_dword ( struct pci_device *pci, unsigned int where, + uint32_t value ); + +#endif /* _GPXE_PCI_IO_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/pcibackup.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/pcibackup.h new file mode 100644 index 0000000..3d295c0 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/pcibackup.h @@ -0,0 +1,33 @@ +#ifndef _GPXE_PCIBACKUP_H +#define _GPXE_PCIBACKUP_H + +/** @file + * + * PCI configuration space backup and restoration + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/** A PCI configuration space backup */ +struct pci_config_backup { + uint32_t dwords[64]; +}; + +/** PCI configuration space backup exclusion list end marker */ +#define PCI_CONFIG_BACKUP_EXCLUDE_END 0xff + +/** Define a PCI configuration space backup exclusion list */ +#define PCI_CONFIG_BACKUP_EXCLUDE(...) \ + { __VA_ARGS__, PCI_CONFIG_BACKUP_EXCLUDE_END } + +extern void pci_backup ( struct pci_device *pci, + struct pci_config_backup *backup, + const uint8_t *exclude ); +extern void pci_restore ( struct pci_device *pci, + struct pci_config_backup *backup, + const uint8_t *exclude ); + +#endif /* _GPXE_PCIBACKUP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/posix_io.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/posix_io.h new file mode 100644 index 0000000..3063dff --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/posix_io.h @@ -0,0 +1,87 @@ +#ifndef _GPXE_POSIX_IO_H +#define _GPXE_POSIX_IO_H + +/** @file + * + * POSIX-like I/O + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/uaccess.h> + +/** Minimum file descriptor that will ever be allocated */ +#define POSIX_FD_MIN ( 1 ) + +/** Maximum file descriptor that will ever be allocated */ +#define POSIX_FD_MAX ( 31 ) + +/** File descriptor set as used for select() */ +typedef uint32_t fd_set; + +extern int open ( const char *uri_string ); +extern ssize_t read_user ( int fd, userptr_t buffer, + off_t offset, size_t len ); +extern int select ( fd_set *readfds, int wait ); +extern ssize_t fsize ( int fd ); +extern int close ( int fd ); + +/** + * Zero a file descriptor set + * + * @v set File descriptor set + */ +static inline __attribute__ (( always_inline )) void +FD_ZERO ( fd_set *set ) { + *set = 0; +} + +/** + * Set a bit within a file descriptor set + * + * @v fd File descriptor + * @v set File descriptor set + */ +static inline __attribute__ (( always_inline )) void +FD_SET ( int fd, fd_set *set ) { + *set |= ( 1 << fd ); +} + +/** + * Clear a bit within a file descriptor set + * + * @v fd File descriptor + * @v set File descriptor set + */ +static inline __attribute__ (( always_inline )) void +FD_CLR ( int fd, fd_set *set ) { + *set &= ~( 1 << fd ); +} + +/** + * Test a bit within a file descriptor set + * + * @v fd File descriptor + * @v set File descriptor set + * @ret is_set Corresponding bit is set + */ +static inline __attribute__ (( always_inline )) int +FD_ISSET ( int fd, fd_set *set ) { + return ( *set & ( 1 << fd ) ); +} + +/** + * Read data from file + * + * @v fd File descriptor + * @v buf Data buffer + * @v len Maximum length to read + * @ret len Actual length read, or negative error number + */ +static inline ssize_t read ( int fd, void *buf, size_t len ) { + return read_user ( fd, virt_to_user ( buf ), 0, len ); +} + +#endif /* _GPXE_POSIX_IO_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/process.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/process.h new file mode 100644 index 0000000..944858d --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/process.h @@ -0,0 +1,80 @@ +#ifndef _GPXE_PROCESS_H +#define _GPXE_PROCESS_H + +/** @file + * + * Processes + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/list.h> +#include <gpxe/refcnt.h> +#include <gpxe/tables.h> + +/** A process */ +struct process { + /** List of processes */ + struct list_head list; + /** + * Single-step the process + * + * This method should execute a single step of the process. + * Returning from this method is isomorphic to yielding the + * CPU to another process. + */ + void ( * step ) ( struct process *process ); + /** Reference counter + * + * If this interface is not part of a reference-counted + * object, this field may be NULL. + */ + struct refcnt *refcnt; +}; + +extern void process_add ( struct process *process ); +extern void process_del ( struct process *process ); +extern void step ( void ); + +/** + * Initialise process without adding to process list + * + * @v process Process + * @v step Process' step() method + */ +static inline __attribute__ (( always_inline )) void +process_init_stopped ( struct process *process, + void ( * step ) ( struct process *process ), + struct refcnt *refcnt ) { + INIT_LIST_HEAD ( &process->list ); + process->step = step; + process->refcnt = refcnt; +} + +/** + * Initialise process and add to process list + * + * @v process Process + * @v step Process' step() method + */ +static inline __attribute__ (( always_inline )) void +process_init ( struct process *process, + void ( * step ) ( struct process *process ), + struct refcnt *refcnt ) { + process_init_stopped ( process, step, refcnt ); + process_add ( process ); +} + +/** Permanent process table */ +#define PERMANENT_PROCESSES __table ( struct process, "processes" ) + +/** + * Declare a permanent process + * + * Permanent processes will be automatically added to the process list + * at initialisation time. + */ +#define __permanent_process __table_entry ( PERMANENT_PROCESSES, 01 ) + +#endif /* _GPXE_PROCESS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/profile.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/profile.h new file mode 100644 index 0000000..a5bdd3a --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/profile.h @@ -0,0 +1,80 @@ +#ifndef _GPXE_PROFILE_H +#define _GPXE_PROFILE_H + +/** @file + * + * Profiling + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/** + * A data structure for storing profiling information + */ +union profiler { + /** Timestamp (in CPU-specific "ticks") */ + uint64_t timestamp; + /** Registers returned by rdtsc. + * + * This part should really be architecture-specific code. + */ + struct { + uint32_t eax; + uint32_t edx; + } rdtsc; +}; + +/** + * Static per-object profiler, for use with simple_profile() + */ +static union profiler simple_profiler; + +/** + * Perform profiling + * + * @v profiler Profiler data structure + * @ret delta Elapsed ticks since last call to profile(). + * + * Call profile() both before and after the code you wish to measure. + * The "after" call will return the measurement. For example: + * + * @code + * + * profile ( &profiler ); + * ... do something here ... + * printf ( "It took %ld ticks to execute\n", profile ( &profiler ) ); + * + * @endcode + */ +static inline __attribute__ (( always_inline )) unsigned long +profile ( union profiler *profiler ) { + uint64_t last_timestamp = profiler->timestamp; + + __asm__ __volatile__ ( "rdtsc" : + "=a" ( profiler->rdtsc.eax ), + "=d" ( profiler->rdtsc.edx ) ); + return ( profiler->timestamp - last_timestamp ); +} + +/** + * Perform profiling + * + * @ret delta Elapsed ticks since last call to profile(). + * + * When you only need one profiler, you can avoid the hassle of + * creating your own @c profiler data structure by using + * simple_profile() instead. + * + * simple_profile() is equivalent to profile(&simple_profiler), where + * @c simple_profiler is a @c profiler data structure that is static + * to each object which includes @c profile.h. + */ +static inline __attribute__ (( always_inline )) unsigned long +simple_profile ( void ) { + return profile ( &simple_profiler ); +} + +#endif /* _GPXE_PROFILE_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/ramdisk.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ramdisk.h new file mode 100644 index 0000000..31a1d99 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/ramdisk.h @@ -0,0 +1,24 @@ +#ifndef _GPXE_RAMDISK_H +#define _GPXE_RAMDISK_H + +/** + * @file + * + * RAM disks + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/uaccess.h> +#include <gpxe/blockdev.h> + +struct ramdisk { + struct block_device blockdev; + userptr_t data; +}; + +extern int init_ramdisk ( struct ramdisk *ramdisk, userptr_t data, size_t len, + unsigned int blksize ); + +#endif /* _GPXE_RAMDISK_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/rarp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/rarp.h new file mode 100644 index 0000000..7ade831 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/rarp.h @@ -0,0 +1,16 @@ +#ifndef _GPXE_RARP_H +#define _GPXE_RARP_H + +/** @file + * + * Reverse Address Resolution Protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct net_protocol; + +extern struct net_protocol rarp_protocol; + +#endif /* _GPXE_RARP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/rc80211.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/rc80211.h new file mode 100644 index 0000000..0856896 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/rc80211.h @@ -0,0 +1,19 @@ +#ifndef _GPXE_RC80211_H +#define _GPXE_RC80211_H + +/** @file + * + * Rate-control algorithm prototype for 802.11. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct net80211_device; +struct rc80211_ctx; + +struct rc80211_ctx * rc80211_init ( struct net80211_device *dev ); +void rc80211_update_tx ( struct net80211_device *dev, int retries, int rc ); +void rc80211_update_rx ( struct net80211_device *dev, int retry, u16 rate ); +void rc80211_free ( struct rc80211_ctx *ctx ); + +#endif /* _GPXE_RC80211_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/refcnt.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/refcnt.h new file mode 100644 index 0000000..e56f1d3 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/refcnt.h @@ -0,0 +1,46 @@ +#ifndef _GPXE_REFCNT_H +#define _GPXE_REFCNT_H + +/** @file + * + * Reference counting + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** + * A reference counter + * + * This data structure is designed to be embedded within a + * reference-counted object. + * + * Reference-counted objects are freed when their reference count + * drops below zero. This means that a freshly allocated-and-zeroed + * reference-counted object will be freed on the first call to + * ref_put(). + */ +struct refcnt { + /** Current reference count + * + * When this count is decremented below zero, the free() + * method will be called. + */ + int refcnt; + /** Free containing object + * + * This method is called when the reference count is + * decremented below zero. + * + * If this method is left NULL, the standard library free() + * function will be called. The upshot of this is that you + * may omit the free() method if the @c refcnt object is the + * first element of your reference-counted struct. + */ + void ( * free ) ( struct refcnt *refcnt ); +}; + +extern struct refcnt * ref_get ( struct refcnt *refcnt ); +extern void ref_put ( struct refcnt *refcnt ); + +#endif /* _GPXE_REFCNT_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/resolv.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/resolv.h new file mode 100644 index 0000000..33bb098 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/resolv.h @@ -0,0 +1,170 @@ +#ifndef _GPXE_RESOLV_H +#define _GPXE_RESOLV_H + +/** @file + * + * Name resolution + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/refcnt.h> +#include <gpxe/interface.h> +#include <gpxe/tables.h> +#include <gpxe/socket.h> + +struct resolv_interface; + +/** Name resolution interface operations */ +struct resolv_interface_operations { + /** Name resolution completed + * + * @v resolv Name resolution interface + * @v sa Completed socket address (if successful) + * @v rc Final status code + */ + void ( * done ) ( struct resolv_interface *resolv, + struct sockaddr *sa, int rc ); +}; + +/** A name resolution interface */ +struct resolv_interface { + /** Generic object communication interface */ + struct interface intf; + /** Operations for received messages */ + struct resolv_interface_operations *op; +}; + +extern struct resolv_interface null_resolv; +extern struct resolv_interface_operations null_resolv_ops; + +/** + * Initialise a name resolution interface + * + * @v resolv Name resolution interface + * @v op Name resolution interface operations + * @v refcnt Containing object reference counter, or NULL + */ +static inline void resolv_init ( struct resolv_interface *resolv, + struct resolv_interface_operations *op, + struct refcnt *refcnt ) { + resolv->intf.dest = &null_resolv.intf; + resolv->intf.refcnt = refcnt; + resolv->op = op; +} + +/** + * Get name resolution interface from generic object communication interface + * + * @v intf Generic object communication interface + * @ret resolv Name resolution interface + */ +static inline __attribute__ (( always_inline )) struct resolv_interface * +intf_to_resolv ( struct interface *intf ) { + return container_of ( intf, struct resolv_interface, intf ); +} + +/** + * Get reference to destination name resolution interface + * + * @v resolv Name resolution interface + * @ret dest Destination interface + */ +static inline __attribute__ (( always_inline )) struct resolv_interface * +resolv_get_dest ( struct resolv_interface *resolv ) { + return intf_to_resolv ( intf_get ( resolv->intf.dest ) ); +} + +/** + * Drop reference to name resolution interface + * + * @v resolv name resolution interface + */ +static inline __attribute__ (( always_inline )) void +resolv_put ( struct resolv_interface *resolv ) { + intf_put ( &resolv->intf ); +} + +/** + * Plug a name resolution interface into a new destination interface + * + * @v resolv Name resolution interface + * @v dest New destination interface + */ +static inline __attribute__ (( always_inline )) void +resolv_plug ( struct resolv_interface *resolv, struct resolv_interface *dest ) { + plug ( &resolv->intf, &dest->intf ); +} + +/** + * Plug two name resolution interfaces together + * + * @v a Name resolution interface A + * @v b Name resolution interface B + */ +static inline __attribute__ (( always_inline )) void +resolv_plug_plug ( struct resolv_interface *a, struct resolv_interface *b ) { + plug_plug ( &a->intf, &b->intf ); +} + +/** + * Unplug a name resolution interface + * + * @v resolv Name resolution interface + */ +static inline __attribute__ (( always_inline )) void +resolv_unplug ( struct resolv_interface *resolv ) { + plug ( &resolv->intf, &null_resolv.intf ); +} + +/** + * Stop using a name resolution interface + * + * @v resolv Name resolution interface + * + * After calling this method, no further messages will be received via + * the interface. + */ +static inline void resolv_nullify ( struct resolv_interface *resolv ) { + resolv->op = &null_resolv_ops; +}; + +/** A name resolver */ +struct resolver { + /** Name of this resolver (e.g. "DNS") */ + const char *name; + /** Start name resolution + * + * @v resolv Name resolution interface + * @v name Name to resolve + * @v sa Socket address to complete + * @ret rc Return status code + */ + int ( * resolv ) ( struct resolv_interface *resolv, const char *name, + struct sockaddr *sa ); +}; + +/** Numeric resolver priority */ +#define RESOLV_NUMERIC 01 + +/** Normal resolver priority */ +#define RESOLV_NORMAL 02 + +/** Resolvers table */ +#define RESOLVERS __table ( struct resolver, "resolvers" ) + +/** Register as a name resolver */ +#define __resolver( resolv_order ) __table_entry ( RESOLVERS, resolv_order ) + +extern void resolv_done ( struct resolv_interface *resolv, + struct sockaddr *sa, int rc ); +extern void ignore_resolv_done ( struct resolv_interface *resolv, + struct sockaddr *sa, int rc ); +extern struct resolv_interface_operations null_resolv_ops; +extern struct resolv_interface null_resolv; + +extern int resolv ( struct resolv_interface *resolv, const char *name, + struct sockaddr *sa ); + +#endif /* _GPXE_RESOLV_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/retry.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/retry.h new file mode 100644 index 0000000..ada0204 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/retry.h @@ -0,0 +1,81 @@ +#ifndef _GPXE_RETRY_H +#define _GPXE_RETRY_H + +/** @file + * + * Retry timers + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/list.h> + +/** Default timeout value */ +#define DEFAULT_MIN_TIMEOUT ( TICKS_PER_SEC / 4 ) + +/** Limit after which the timeout will be deemed permanent */ +#define DEFAULT_MAX_TIMEOUT ( 10 * TICKS_PER_SEC ) + +/** A retry timer */ +struct retry_timer { + /** List of active timers */ + struct list_head list; + /** Timer is currently running */ + unsigned int running; + /** Timeout value (in ticks) */ + unsigned long timeout; + /** Minimum timeout value (in ticks) + * + * A value of zero means "use default timeout." + */ + unsigned long min_timeout; + /** Maximum timeout value before failure (in ticks) + * + * A value of zero means "use default timeout." + */ + unsigned long max_timeout; + /** Start time (in ticks) */ + unsigned long start; + /** Retry count */ + unsigned int count; + /** Timer expired callback + * + * @v timer Retry timer + * @v fail Failure indicator + * + * The timer will already be stopped when this method is + * called. The failure indicator will be True if the retry + * timeout has already exceeded @c MAX_TIMEOUT. + */ + void ( * expired ) ( struct retry_timer *timer, int over ); +}; + +extern void start_timer ( struct retry_timer *timer ); +extern void start_timer_fixed ( struct retry_timer *timer, + unsigned long timeout ); +extern void stop_timer ( struct retry_timer *timer ); + +/** + * Start timer with no delay + * + * @v timer Retry timer + * + * This starts the timer running with a zero timeout value. + */ +static inline void start_timer_nodelay ( struct retry_timer *timer ) { + start_timer_fixed ( timer, 0 ); +} + +/** + * Test to see if timer is currently running + * + * @v timer Retry timer + * @ret running Non-zero if timer is running + */ +static inline __attribute__ (( always_inline )) unsigned long +timer_running ( struct retry_timer *timer ) { + return ( timer->running ); +} + +#endif /* _GPXE_RETRY_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/rotate.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/rotate.h new file mode 100644 index 0000000..0371c57 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/rotate.h @@ -0,0 +1,29 @@ +#ifndef _GPXE_ROTATE_H +#define _GPXE_ROTATE_H + +/** @file + * + * Bit operations + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +static inline uint32_t rol32 ( uint32_t data, unsigned int rotation ) { + return ( ( data << rotation ) | ( data >> ( 32 - rotation ) ) ); +} + +static inline uint32_t ror32 ( uint32_t data, unsigned int rotation ) { + return ( ( data >> rotation ) | ( data << ( 32 - rotation ) ) ); +} + +static inline uint64_t rol64 ( uint64_t data, unsigned int rotation ) { + return ( ( data << rotation ) | ( data >> ( 64 - rotation ) ) ); +} + +static inline uint64_t ror64 ( uint64_t data, unsigned int rotation ) { + return ( ( data >> rotation ) | ( data << ( 64 - rotation ) ) ); +} + +#endif /* _GPXE_ROTATE_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/rsa.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/rsa.h new file mode 100644 index 0000000..5052ad4 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/rsa.h @@ -0,0 +1,12 @@ +#ifndef _GPXE_RSA_H +#define _GPXE_RSA_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct pubkey_algorithm; + +extern struct pubkey_algorithm rsa_algorithm; + +#include "crypto/axtls/crypto.h" + +#endif /* _GPXE_RSA_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/sanboot.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/sanboot.h new file mode 100644 index 0000000..6ec2ec2 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/sanboot.h @@ -0,0 +1,18 @@ +#ifndef _GPXE_SANBOOT_H +#define _GPXE_SANBOOT_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/tables.h> + +struct sanboot_protocol { + const char *prefix; + int ( * boot ) ( const char *root_path ); +}; + +#define SANBOOT_PROTOCOLS \ + __table ( struct sanboot_protocol, "sanboot_protocols" ) + +#define __sanboot_protocol __table_entry ( SANBOOT_PROTOCOLS, 01 ) + +#endif /* _GPXE_SANBOOT_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/scsi.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/scsi.h new file mode 100644 index 0000000..9741697 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/scsi.h @@ -0,0 +1,281 @@ +#ifndef _GPXE_SCSI_H +#define _GPXE_SCSI_H + +#include <stdint.h> +#include <gpxe/blockdev.h> +#include <gpxe/uaccess.h> +#include <gpxe/refcnt.h> + +/** @file + * + * SCSI devices + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** + * @defgroup scsiops SCSI operation codes + * @{ + */ + +#define SCSI_OPCODE_READ_10 0x28 /**< READ (10) */ +#define SCSI_OPCODE_READ_16 0x88 /**< READ (16) */ +#define SCSI_OPCODE_WRITE_10 0x2a /**< WRITE (10) */ +#define SCSI_OPCODE_WRITE_16 0x8a /**< WRITE (16) */ +#define SCSI_OPCODE_READ_CAPACITY_10 0x25 /**< READ CAPACITY (10) */ +#define SCSI_OPCODE_SERVICE_ACTION_IN 0x9e /**< SERVICE ACTION IN */ +#define SCSI_SERVICE_ACTION_READ_CAPACITY_16 0x10 /**< READ CAPACITY (16) */ + +/** @} */ + +/** + * @defgroup scsiflags SCSI flags + * @{ + */ + +#define SCSI_FL_FUA_NV 0x02 /**< Force unit access to NVS */ +#define SCSI_FL_FUA 0x08 /**< Force unit access */ +#define SCSI_FL_DPO 0x10 /**< Disable cache page out */ + +/** @} */ + +/** + * @defgroup scsicdbs SCSI command data blocks + * @{ + */ + +/** A SCSI "READ (10)" CDB */ +struct scsi_cdb_read_10 { + /** Opcode (0x28) */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Start address + * + * This is a logical block number, in big-endian order. + */ + uint32_t lba; + /** Group number */ + uint8_t group; + /** Transfer length + * + * This is a logical block count, in big-endian order. + */ + uint16_t len; + /** Control byte */ + uint8_t control; +} __attribute__ (( packed )); + +/** A SCSI "READ (16)" CDB */ +struct scsi_cdb_read_16 { + /** Opcode (0x88) */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Start address + * + * This is a logical block number, in big-endian order. + */ + uint64_t lba; + /** Transfer length + * + * This is a logical block count, in big-endian order. + */ + uint32_t len; + /** Group number */ + uint8_t group; + /** Control byte */ + uint8_t control; +} __attribute__ (( packed )); + +/** A SCSI "WRITE (10)" CDB */ +struct scsi_cdb_write_10 { + /** Opcode (0x2a) */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Start address + * + * This is a logical block number, in big-endian order. + */ + uint32_t lba; + /** Group number */ + uint8_t group; + /** Transfer length + * + * This is a logical block count, in big-endian order. + */ + uint16_t len; + /** Control byte */ + uint8_t control; +} __attribute__ (( packed )); + +/** A SCSI "WRITE (16)" CDB */ +struct scsi_cdb_write_16 { + /** Opcode (0x8a) */ + uint8_t opcode; + /** Flags */ + uint8_t flags; + /** Start address + * + * This is a logical block number, in big-endian order. + */ + uint64_t lba; + /** Transfer length + * + * This is a logical block count, in big-endian order. + */ + uint32_t len; + /** Group number */ + uint8_t group; + /** Control byte */ + uint8_t control; +} __attribute__ (( packed )); + +/** A SCSI "READ CAPACITY (10)" CDB */ +struct scsi_cdb_read_capacity_10 { + /** Opcode (0x25) */ + uint8_t opcode; + /** Reserved */ + uint8_t reserved_a; + /** Logical block address + * + * Applicable only if the PMI bit is set. + */ + uint32_t lba; + /** Reserved */ + uint8_t reserved_b[3]; + /** Control byte */ + uint8_t control; +} __attribute__ (( packed )); + +/** SCSI "READ CAPACITY (10)" parameter data */ +struct scsi_capacity_10 { + /** Maximum logical block number */ + uint32_t lba; + /** Block length in bytes */ + uint32_t blksize; +} __attribute__ (( packed )); + +/** A SCSI "READ CAPACITY (16)" CDB */ +struct scsi_cdb_read_capacity_16 { + /** Opcode (0x9e) */ + uint8_t opcode; + /** Service action */ + uint8_t service_action; + /** Logical block address + * + * Applicable only if the PMI bit is set. + */ + uint64_t lba; + /** Transfer length + * + * This is the size of the data-in buffer, in bytes. + */ + uint32_t len; + /** Reserved */ + uint8_t reserved; + /** Control byte */ + uint8_t control; +} __attribute__ (( packed )); + +/** SCSI "READ CAPACITY (16)" parameter data */ +struct scsi_capacity_16 { + /** Maximum logical block number */ + uint64_t lba; + /** Block length in bytes */ + uint32_t blksize; + /** Reserved */ + uint8_t reserved[20]; +} __attribute__ (( packed )); + +/** A SCSI Command Data Block */ +union scsi_cdb { + struct scsi_cdb_read_10 read10; + struct scsi_cdb_read_16 read16; + struct scsi_cdb_write_10 write10; + struct scsi_cdb_write_16 write16; + struct scsi_cdb_read_capacity_10 readcap10; + struct scsi_cdb_read_capacity_16 readcap16; + unsigned char bytes[16]; +}; + +/** printf() format for dumping a scsi_cdb */ +#define SCSI_CDB_FORMAT "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:" \ + "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x" + +/** printf() parameters for dumping a scsi_cdb */ +#define SCSI_CDB_DATA(cdb) \ + (cdb).bytes[0], (cdb).bytes[1], (cdb).bytes[2], (cdb).bytes[3], \ + (cdb).bytes[4], (cdb).bytes[5], (cdb).bytes[6], (cdb).bytes[7], \ + (cdb).bytes[8], (cdb).bytes[9], (cdb).bytes[10], (cdb).bytes[11], \ + (cdb).bytes[12], (cdb).bytes[13], (cdb).bytes[14], (cdb).bytes[15] + +/** @} */ + +/** A SCSI command */ +struct scsi_command { + /** CDB for this command */ + union scsi_cdb cdb; + /** Data-out buffer (may be NULL) */ + userptr_t data_out; + /** Data-out buffer length + * + * Must be zero if @c data_out is NULL + */ + size_t data_out_len; + /** Data-in buffer (may be NULL) */ + userptr_t data_in; + /** Data-in buffer length + * + * Must be zero if @c data_in is NULL + */ + size_t data_in_len; + /** SCSI status code */ + uint8_t status; + /** SCSI sense response code */ + uint8_t sense_response; + /** Command status code */ + int rc; +}; + +/** A SCSI LUN + * + * This is a four-level LUN as specified by SAM-2, in big-endian + * order. + */ +struct scsi_lun { + uint16_t u16[4]; +} __attribute__ (( packed )); + +/** A SCSI device */ +struct scsi_device { + /** Block device interface */ + struct block_device blockdev; + /** + * Issue SCSI command + * + * @v scsi SCSI device + * @v command SCSI command + * @ret rc Return status code + * + * Note that a successful return status code indicates only + * that the SCSI command was issued. The caller must check + * the status field in the command structure to see when the + * command completes and whether, for example, the device + * returned CHECK CONDITION or some other non-success status + * code. + */ + int ( * command ) ( struct scsi_device *scsi, + struct scsi_command *command ); + /** Backing device */ + struct refcnt *backend; +}; + +extern int scsi_detached_command ( struct scsi_device *scsi, + struct scsi_command *command ); +extern int init_scsidev ( struct scsi_device *scsi ); +extern int scsi_parse_lun ( const char *lun_string, struct scsi_lun *lun ); + +#endif /* _GPXE_SCSI_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/segment.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/segment.h new file mode 100644 index 0000000..5b59c54 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/segment.h @@ -0,0 +1,17 @@ +#ifndef _GPXE_SEGMENT_H +#define _GPXE_SEGMENT_H + +/** + * @file + * + * Executable image segments + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/uaccess.h> + +extern int prep_segment ( userptr_t segment, size_t filesz, size_t memsz ); + +#endif /* _GPXE_SEGMENT_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/serial.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/serial.h new file mode 100644 index 0000000..a72ca7e --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/serial.h @@ -0,0 +1,16 @@ +#ifndef _GPXE_SERIAL_H +#define _GPXE_SERIAL_H + +/** @file + * + * Serial driver functions + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +extern void serial_putc ( int ch ); +extern int serial_getc ( void ); +extern int serial_ischar ( void ); + +#endif /* _GPXE_SERIAL_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/settings.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/settings.h new file mode 100644 index 0000000..09934b6 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/settings.h @@ -0,0 +1,334 @@ +#ifndef _GPXE_SETTINGS_H +#define _GPXE_SETTINGS_H + +/** @file + * + * Configuration settings + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/tables.h> +#include <gpxe/list.h> +#include <gpxe/refcnt.h> + +struct settings; +struct in_addr; +union uuid; + +/** A setting */ +struct setting { + /** Name + * + * This is the human-readable name for the setting. + */ + const char *name; + /** Description */ + const char *description; + /** Setting type + * + * This identifies the type of setting (e.g. string, IPv4 + * address, etc.). + */ + struct setting_type *type; + /** DHCP option number, if applicable */ + unsigned int tag; +}; + +/** Configuration setting table */ +#define SETTINGS __table ( struct setting, "settings" ) + +/** Declare a configuration setting */ +#define __setting __table_entry ( SETTINGS, 01 ) + +/** Settings block operations */ +struct settings_operations { + /** Store value of setting + * + * @v settings Settings block + * @v setting Setting to store + * @v data Setting data, or NULL to clear setting + * @v len Length of setting data + * @ret rc Return status code + */ + int ( * store ) ( struct settings *settings, struct setting *setting, + const void *data, size_t len ); + /** Fetch value of setting + * + * @v settings Settings block + * @v setting Setting to fetch + * @v data Buffer to fill with setting data + * @v len Length of buffer + * @ret len Length of setting data, or negative error + * + * The actual length of the setting will be returned even if + * the buffer was too small. + */ + int ( * fetch ) ( struct settings *settings, struct setting *setting, + void *data, size_t len ); + /** Clear settings block + * + * @v settings Settings block + */ + void ( * clear ) ( struct settings *settings ); +}; + +/** A settings block */ +struct settings { + /** Reference counter */ + struct refcnt *refcnt; + /** Name */ + const char *name; + /** Tag magic + * + * This value will be ORed in to any numerical tags + * constructed by parse_setting_name(), and can be used to + * avoid e.g. attempting to retrieve the subnet mask from + * SMBIOS, or the system UUID from DHCP. + */ + unsigned int tag_magic; + /** Parent settings block */ + struct settings *parent; + /** Sibling settings blocks */ + struct list_head siblings; + /** Child settings blocks */ + struct list_head children; + /** Settings block operations */ + struct settings_operations *op; +}; + +/** + * A setting type + * + * This represents a type of setting (e.g. string, IPv4 address, + * etc.). + */ +struct setting_type { + /** Name + * + * This is the name exposed to the user (e.g. "string"). + */ + const char *name; + /** Parse and set value of setting + * + * @v settings Settings block + * @v setting Setting to store + * @v value Formatted setting data + * @ret rc Return status code + */ + int ( * storef ) ( struct settings *settings, struct setting *setting, + const char *value ); + /** Fetch and format value of setting + * + * @v settings Settings block + * @v setting Setting to fetch + * @v buf Buffer to contain formatted value + * @v len Length of buffer + * @ret len Length of formatted value, or negative error + */ + int ( * fetchf ) ( struct settings *settings, struct setting *setting, + char *buf, size_t len ); +}; + +/** Configuration setting type table */ +#define SETTING_TYPES __table ( struct setting_type, "setting_types" ) + +/** Declare a configuration setting type */ +#define __setting_type __table_entry ( SETTING_TYPES, 01 ) + +/** + * A settings applicator + * + */ +struct settings_applicator { + /** Apply updated settings + * + * @ret rc Return status code + */ + int ( * apply ) ( void ); +}; + +/** Settings applicator table */ +#define SETTINGS_APPLICATORS \ + __table ( struct settings_applicator, "settings_applicators" ) + +/** Declare a settings applicator */ +#define __settings_applicator __table_entry ( SETTINGS_APPLICATORS, 01 ) + +/** + * A generic settings block + * + */ +struct generic_settings { + /** Settings block */ + struct settings settings; + /** List of generic settings */ + struct list_head list; +}; + +extern struct settings_operations generic_settings_operations; +extern int generic_settings_store ( struct settings *settings, + struct setting *setting, + const void *data, size_t len ); +extern int generic_settings_fetch ( struct settings *settings, + struct setting *setting, + void *data, size_t len ); +extern void generic_settings_clear ( struct settings *settings ); + +extern int register_settings ( struct settings *settings, + struct settings *parent ); +extern void unregister_settings ( struct settings *settings ); + +extern int store_setting ( struct settings *settings, struct setting *setting, + const void *data, size_t len ); +extern int fetch_setting ( struct settings *settings, struct setting *setting, + void *data, size_t len ); +extern int fetch_setting_len ( struct settings *settings, + struct setting *setting ); +extern int fetch_string_setting ( struct settings *settings, + struct setting *setting, + char *data, size_t len ); +extern int fetch_string_setting_copy ( struct settings *settings, + struct setting *setting, + char **data ); +extern int fetch_ipv4_setting ( struct settings *settings, + struct setting *setting, struct in_addr *inp ); +extern int fetch_int_setting ( struct settings *settings, + struct setting *setting, long *value ); +extern int fetch_uint_setting ( struct settings *settings, + struct setting *setting, + unsigned long *value ); +extern long fetch_intz_setting ( struct settings *settings, + struct setting *setting ); +extern unsigned long fetch_uintz_setting ( struct settings *settings, + struct setting *setting ); +extern int fetch_uuid_setting ( struct settings *settings, + struct setting *setting, union uuid *uuid ); +extern void clear_settings ( struct settings *settings ); +extern int setting_cmp ( struct setting *a, struct setting *b ); + +extern struct settings * find_settings ( const char *name ); + +extern int storef_setting ( struct settings *settings, + struct setting *setting, + const char *value ); +extern int storef_named_setting ( const char *name, const char *value ); +extern int fetchf_named_setting ( const char *name, char *buf, size_t len ); + +extern struct setting_type setting_type_string __setting_type; +extern struct setting_type setting_type_ipv4 __setting_type; +extern struct setting_type setting_type_int8 __setting_type; +extern struct setting_type setting_type_int16 __setting_type; +extern struct setting_type setting_type_int32 __setting_type; +extern struct setting_type setting_type_uint8 __setting_type; +extern struct setting_type setting_type_uint16 __setting_type; +extern struct setting_type setting_type_uint32 __setting_type; +extern struct setting_type setting_type_hex __setting_type; +extern struct setting_type setting_type_uuid __setting_type; + +extern struct setting ip_setting __setting; +extern struct setting netmask_setting __setting; +extern struct setting gateway_setting __setting; +extern struct setting dns_setting __setting; +extern struct setting domain_setting __setting; +extern struct setting hostname_setting __setting; +extern struct setting filename_setting __setting; +extern struct setting root_path_setting __setting; +extern struct setting username_setting __setting; +extern struct setting password_setting __setting; +extern struct setting priority_setting __setting; +extern struct setting uuid_setting __setting; +extern struct setting next_server_setting __setting; +extern struct setting mac_setting __setting; +extern struct setting user_class_setting __setting; + +/** + * Initialise a settings block + * + * @v settings Settings block + * @v op Settings block operations + * @v refcnt Containing object reference counter, or NULL + * @v name Settings block name + * @v tag_magic Tag magic + */ +static inline void settings_init ( struct settings *settings, + struct settings_operations *op, + struct refcnt *refcnt, + const char *name, + unsigned int tag_magic ) { + INIT_LIST_HEAD ( &settings->siblings ); + INIT_LIST_HEAD ( &settings->children ); + settings->op = op; + settings->refcnt = refcnt; + settings->name = name; + settings->tag_magic = tag_magic; +} + +/** + * Initialise a settings block + * + * @v generics Generic settings block + * @v refcnt Containing object reference counter, or NULL + * @v name Settings block name + */ +static inline void generic_settings_init ( struct generic_settings *generics, + struct refcnt *refcnt, + const char *name ) { + settings_init ( &generics->settings, &generic_settings_operations, + refcnt, name, 0 ); + INIT_LIST_HEAD ( &generics->list ); +} + +/** + * Delete setting + * + * @v settings Settings block + * @v setting Setting to delete + * @ret rc Return status code + */ +static inline int delete_setting ( struct settings *settings, + struct setting *setting ) { + return store_setting ( settings, setting, NULL, 0 ); +} + +/** + * Fetch and format value of setting + * + * @v settings Settings block, or NULL to search all blocks + * @v setting Setting to fetch + * @v type Settings type + * @v buf Buffer to contain formatted value + * @v len Length of buffer + * @ret len Length of formatted value, or negative error + */ +static inline int fetchf_setting ( struct settings *settings, + struct setting *setting, + char *buf, size_t len ) { + return setting->type->fetchf ( settings, setting, buf, len ); +} + +/** + * Delete named setting + * + * @v name Name of setting + * @ret rc Return status code + */ +static inline int delete_named_setting ( const char *name ) { + return storef_named_setting ( name, NULL ); +} + +/** + * Check existence of setting + * + * @v settings Settings block, or NULL to search all blocks + * @v setting Setting to fetch + * @ret exists Setting exists + */ +static inline int setting_exists ( struct settings *settings, + struct setting *setting ) { + return ( fetch_setting_len ( settings, setting ) >= 0 ); +} + +#endif /* _GPXE_SETTINGS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/settings_ui.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/settings_ui.h new file mode 100644 index 0000000..a82d733 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/settings_ui.h @@ -0,0 +1,16 @@ +#ifndef _GPXE_SETTINGS_UI_H +#define _GPXE_SETTINGS_UI_H + +/** @file + * + * Option configuration console + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +struct settings; + +extern int settings_ui ( struct settings *settings ) __nonnull; + +#endif /* _GPXE_SETTINGS_UI_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/shell.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/shell.h new file mode 100644 index 0000000..a65a344 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/shell.h @@ -0,0 +1,14 @@ +#ifndef _GPXE_SHELL_H +#define _GPXE_SHELL_H + +/** @file + * + * Minimal command shell + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +extern void shell ( void ); + +#endif /* _GPXE_SHELL_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/shell_banner.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/shell_banner.h new file mode 100644 index 0000000..28482be --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/shell_banner.h @@ -0,0 +1,14 @@ +#ifndef _GPXE_SHELL_BANNER_H +#define _GPXE_SHELL_BANNER_H + +/** @file + * + * Shell startup banner + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +extern int shell_banner ( void ); + +#endif /* _GPXE_SHELL_BANNER_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/smbios.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/smbios.h new file mode 100644 index 0000000..4df25c3 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/smbios.h @@ -0,0 +1,161 @@ +#ifndef _GPXE_SMBIOS_H +#define _GPXE_SMBIOS_H + +/** @file + * + * System Management BIOS + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/api.h> +#include <config/general.h> +#include <gpxe/uaccess.h> + +/** + * Provide an SMBIOS API implementation + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @v _func Implementing function + */ +#define PROVIDE_SMBIOS( _subsys, _api_func, _func ) \ + PROVIDE_SINGLE_API ( SMBIOS_PREFIX_ ## _subsys, _api_func, _func ) + +/* Include all architecture-independent SMBIOS API headers */ +#include <gpxe/efi/efi_smbios.h> + +/* Include all architecture-dependent SMBIOS API headers */ +#include <bits/smbios.h> + +/** Signature for SMBIOS entry point */ +#define SMBIOS_SIGNATURE \ + ( ( '_' << 0 ) + ( 'S' << 8 ) + ( 'M' << 16 ) + ( '_' << 24 ) ) + +/** + * SMBIOS entry point + * + * This is the single table which describes the list of SMBIOS + * structures. It is located by scanning through the BIOS segment. + */ +struct smbios_entry { + /** Signature + * + * Must be equal to SMBIOS_SIGNATURE + */ + uint32_t signature; + /** Checksum */ + uint8_t checksum; + /** Length */ + uint8_t len; + /** Major version */ + uint8_t major; + /** Minor version */ + uint8_t minor; + /** Maximum structure size */ + uint16_t max; + /** Entry point revision */ + uint8_t revision; + /** Formatted area */ + uint8_t formatted[5]; + /** DMI Signature */ + uint8_t dmi_signature[5]; + /** DMI checksum */ + uint8_t dmi_checksum; + /** Structure table length */ + uint16_t smbios_len; + /** Structure table address */ + uint32_t smbios_address; + /** Number of SMBIOS structures */ + uint16_t smbios_count; + /** BCD revision */ + uint8_t bcd_revision; +} __attribute__ (( packed )); + +/** An SMBIOS structure header */ +struct smbios_header { + /** Type */ + uint8_t type; + /** Length */ + uint8_t len; + /** Handle */ + uint16_t handle; +} __attribute__ (( packed )); + +/** SMBIOS structure descriptor */ +struct smbios_structure { + /** Copy of SMBIOS structure header */ + struct smbios_header header; + /** Offset of structure within SMBIOS */ + size_t offset; + /** Length of strings section */ + size_t strings_len; +}; + +/** SMBIOS system information structure */ +struct smbios_system_information { + /** SMBIOS structure header */ + struct smbios_header header; + /** Manufacturer string */ + uint8_t manufacturer; + /** Product string */ + uint8_t product; + /** Version string */ + uint8_t version; + /** Serial number string */ + uint8_t serial; + /** UUID */ + uint8_t uuid[16]; + /** Wake-up type */ + uint8_t wakeup; +} __attribute__ (( packed )); + +/** SMBIOS system information structure type */ +#define SMBIOS_TYPE_SYSTEM_INFORMATION 1 + +/** SMBIOS enclosure information structure */ +struct smbios_enclosure_information { + /** SMBIOS structure header */ + struct smbios_header header; + /** Manufacturer string */ + uint8_t manufacturer; + /** Type string */ + uint8_t type; + /** Version string */ + uint8_t version; + /** Serial number string */ + uint8_t serial; + /** Asset tag */ + uint8_t asset_tag; +} __attribute__ (( packed )); + +/** SMBIOS enclosure information structure type */ +#define SMBIOS_TYPE_ENCLOSURE_INFORMATION 3 + +/** + * SMBIOS entry point descriptor + * + * This contains the information from the SMBIOS entry point that we + * care about. + */ +struct smbios { + /** Start of SMBIOS structures */ + userptr_t address; + /** Length of SMBIOS structures */ + size_t len; + /** Number of SMBIOS structures */ + unsigned int count; +}; + +extern int find_smbios ( struct smbios *smbios ); +extern int find_smbios_structure ( unsigned int type, + struct smbios_structure *structure ); +extern int read_smbios_structure ( struct smbios_structure *structure, + void *data, size_t len ); +extern int read_smbios_string ( struct smbios_structure *structure, + unsigned int index, + void *data, size_t len ); + +#endif /* _GPXE_SMBIOS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/socket.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/socket.h new file mode 100644 index 0000000..9ea0db9 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/socket.h @@ -0,0 +1,101 @@ +#ifndef _GPXE_SOCKET_H +#define _GPXE_SOCKET_H + +/** @file + * + * Socket addresses + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/** + * @defgroup commtypes Communication semantics + * + * @{ + */ + +/** Connection-based, reliable streams */ +extern int tcp_sock_stream; +#define TCP_SOCK_STREAM 0x1 +#define SOCK_STREAM tcp_sock_stream + +/** Connectionless, unreliable streams */ +extern int udp_sock_dgram; +#define UDP_SOCK_DGRAM 0x2 +#define SOCK_DGRAM udp_sock_dgram + +/** @} */ + +/** + * Name communication semantics + * + * @v semantics Communication semantics (e.g. SOCK_STREAM) + * @ret name Name of communication semantics + */ +static inline __attribute__ (( always_inline )) const char * +socket_semantics_name ( int semantics ) { + /* Cannot use a switch() because of the {TCP_UDP}_SOCK_XXX hack */ + if ( semantics == SOCK_STREAM ) { + return "SOCK_STREAM"; + } else if ( semantics == SOCK_DGRAM ) { + return "SOCK_DGRAM"; + } else { + return "SOCK_UNKNOWN"; + } +} + +/** + * @defgroup addrfam Address families + * + * @{ + */ +#define AF_INET 1 /**< IPv4 Internet addresses */ +#define AF_INET6 2 /**< IPv6 Internet addresses */ +/** @} */ + +/** + * Name address family + * + * @v family Address family (e.g. AF_INET) + * @ret name Name of address family + */ +static inline __attribute__ (( always_inline )) const char * +socket_family_name ( int family ) { + switch ( family ) { + case AF_INET: return "AF_INET"; + case AF_INET6: return "AF_INET6"; + default: return "AF_UNKNOWN"; + } +} + +/** A socket address family */ +typedef uint16_t sa_family_t; + +/** Length of a @c struct @c sockaddr */ +#define SA_LEN 32 + +/** + * Generalized socket address structure + * + * This contains the fields common to socket addresses for all address + * families. + */ +struct sockaddr { + /** Socket address family + * + * This is an AF_XXX constant. + */ + sa_family_t sa_family; + /** Padding + * + * This ensures that a struct @c sockaddr_tcpip is large + * enough to hold a socket address for any TCP/IP address + * family. + */ + char pad[ SA_LEN - sizeof ( sa_family_t ) ]; +} __attribute__ (( may_alias )); + +#endif /* _GPXE_SOCKET_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/spi.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/spi.h new file mode 100644 index 0000000..8e4a676 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/spi.h @@ -0,0 +1,258 @@ +#ifndef _GPXE_SPI_H +#define _GPXE_SPI_H + +/** @file + * + * SPI interface + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/nvs.h> + +/** + * @defgroup spicmds SPI commands + * @{ + */ + +/** Write status register */ +#define SPI_WRSR 0x01 + +/** Write data to memory array */ +#define SPI_WRITE 0x02 + +/** Read data from memory array */ +#define SPI_READ 0x03 + +/** Reset write enable latch */ +#define SPI_WRDI 0x04 + +/** Read status register */ +#define SPI_RDSR 0x05 + +/** Set write enable latch */ +#define SPI_WREN 0x06 + +/** + * @defgroup atmelcmds Atmel-specific SPI commands + * @{ + */ + +/** Erase one sector in memory array (Not supported on all devices) */ +#define ATMEL_SECTOR_ERASE 0x52 + +/** Erase all sections in memory array (Not supported on all devices) */ +#define ATMEL_CHIP_ERASE 0x62 + +/** Read manufacturer and product ID (Not supported on all devices) */ +#define ATMEL_RDID 0x15 + +/** @} */ + +/** @} */ + +/** + * @defgroup spistatus SPI status register bits (not present on all devices) + * @{ + */ + +/** Write-protect pin enabled */ +#define SPI_STATUS_WPEN 0x80 + +/** Block protection bit 2 */ +#define SPI_STATUS_BP2 0x10 + +/** Block protection bit 1 */ +#define SPI_STATUS_BP1 0x08 + +/** Block protection bit 0 */ +#define SPI_STATUS_BP0 0x04 + +/** State of the write enable latch */ +#define SPI_STATUS_WEN 0x02 + +/** Device busy flag */ +#define SPI_STATUS_NRDY 0x01 + +/** @} */ + +/** + * An SPI device + * + * This data structure represents a physical SPI device attached to an + * SPI bus. + */ +struct spi_device { + /** NVS device */ + struct nvs_device nvs; + /** SPI bus to which device is attached */ + struct spi_bus *bus; + /** Slave number */ + unsigned int slave; + /** Command length, in bits */ + unsigned int command_len; + /** Address length, in bits */ + unsigned int address_len; + /** Address is munged + * + * Some devices with 9-bit addresses (e.g. AT25040A EEPROM) + * use bit 3 of the command byte as address bit A8, rather + * than having a two-byte address. If this flag is set, then + * commands should be munged in this way. + */ + unsigned int munge_address : 1; +}; + +/** + * SPI magic autodetection address length + * + * Set @c spi_device::address_len to @c SPI_AUTODETECT_ADDRESS_LEN if + * the address length should be autodetected. + */ +#define SPI_AUTODETECT_ADDRESS_LEN 0 + +static inline __attribute__ (( always_inline )) struct spi_device * +nvs_to_spi ( struct nvs_device *nvs ) { + return container_of ( nvs, struct spi_device, nvs ); +} + +/** + * An SPI bus + * + * This data structure represents an SPI bus controller capable of + * issuing commands to attached SPI devices. + */ +struct spi_bus { + /** SPI interface mode + * + * This is the bitwise OR of zero or more of @c SPI_MODE_CPHA + * and @c SPI_MODE_CPOL. It is also the number conventionally + * used to describe the SPI interface mode. For example, SPI + * mode 1 is the mode in which CPOL=0 and CPHA=1, which + * therefore corresponds to a mode value of (0|SPI_MODE_CPHA) + * which, happily, equals 1. + */ + unsigned int mode; + /** + * Read/write data via SPI bus + * + * @v bus SPI bus + * @v device SPI device + * @v command Command + * @v address Address to read/write (<0 for no address) + * @v data_out TX data buffer (or NULL) + * @v data_in RX data buffer (or NULL) + * @v len Length of data buffer(s) + * + * This issues the specified command and optional address to + * the SPI device, then reads and/or writes data to/from the + * data buffers. + */ + int ( * rw ) ( struct spi_bus *bus, struct spi_device *device, + unsigned int command, int address, + const void *data_out, void *data_in, size_t len ); +}; + +/** Clock phase (CPHA) mode bit + * + * Phase 0 is sample on rising edge, shift data on falling edge. + * + * Phase 1 is shift data on rising edge, sample data on falling edge. + */ +#define SPI_MODE_CPHA 0x01 + +/** Clock polarity (CPOL) mode bit + * + * This bit reflects the idle state of the clock line (SCLK). + */ +#define SPI_MODE_CPOL 0x02 + +/** Slave select polarity mode bit + * + * This bit reflects that active state of the slave select lines. It + * is not part of the normal SPI mode number (which covers only @c + * SPI_MODE_CPOL and @c SPI_MODE_CPHA), but is included here for + * convenience. + */ +#define SPI_MODE_SSPOL 0x10 + +/** Microwire-compatible mode + * + * This is SPI mode 1 (i.e. CPOL=0, CPHA=1), and is compatible with + * the original Microwire protocol. + */ +#define SPI_MODE_MICROWIRE 1 + +/** Microwire/Plus-compatible mode + * + * This is SPI mode 0 (i.e. CPOL=0, CPHA=0), and is compatible with + * the Microwire/Plus protocol + */ +#define SPI_MODE_MICROWIRE_PLUS 0 + +/** Threewire-compatible mode + * + * This mode is compatible with Atmel's series of "three-wire" + * interfaces. + */ +#define SPI_MODE_THREEWIRE ( SPI_MODE_MICROWIRE_PLUS | SPI_MODE_SSPOL ) + +extern int spi_read ( struct nvs_device *nvs, unsigned int address, + void *data, size_t len ); +extern int spi_write ( struct nvs_device *nvs, unsigned int address, + const void *data, size_t len ); + +/** + * @defgroup spidevs SPI device types + * @{ + */ + +static inline __attribute__ (( always_inline )) void +init_spi ( struct spi_device *device ) { + device->nvs.word_len_log2 = 0; + device->command_len = 8, + device->nvs.read = spi_read; + device->nvs.write = spi_write; +} + +/** Atmel AT25F1024 serial flash */ +static inline __attribute__ (( always_inline )) void +init_at25f1024 ( struct spi_device *device ) { + device->address_len = 24; + device->nvs.size = ( 128 * 1024 ); + device->nvs.block_size = 256; + init_spi ( device ); +} + +/** Atmel 25040 serial EEPROM */ +static inline __attribute__ (( always_inline )) void +init_at25040 ( struct spi_device *device ) { + device->address_len = 8; + device->munge_address = 1; + device->nvs.size = 512; + device->nvs.block_size = 8; + init_spi ( device ); +} + +/** ST M25P32 serial flash */ +static inline __attribute__ (( always_inline )) void +init_m25p32 ( struct spi_device *device ) { + device->address_len = 24; + device->nvs.size = ( 4 * 1024 * 1024 ); + device->nvs.block_size = 256; + init_spi ( device ); +} + +/** Microchip 25XX640 serial EEPROM */ +static inline __attribute__ (( always_inline )) void +init_mc25xx640 ( struct spi_device *device ) { + device->address_len = 16; + device->nvs.size = ( 8 * 1024 ); + device->nvs.block_size = 32; + init_spi ( device ); +} + +/** @} */ + +#endif /* _GPXE_SPI_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/spi_bit.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/spi_bit.h new file mode 100644 index 0000000..8bd2519 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/spi_bit.h @@ -0,0 +1,63 @@ +#ifndef _GPXE_SPI_BIT_H +#define _GPXE_SPI_BIT_H + +/** @file + * + * SPI bit-bashing interface + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/spi.h> +#include <gpxe/bitbash.h> + +/** A bit-bashing SPI bus */ +struct spi_bit_basher { + /** SPI bus */ + struct spi_bus bus; + /** Bit-bashing interface */ + struct bit_basher basher; + /** Endianness of data + * + * SPI commands and addresses are always big-endian (i.e. MSB + * transmitted first on the wire), but some cards + * (e.g. natsemi) choose to regard the data stored in the + * EEPROM as little-endian (i.e. LSB transmitted first on the + * wire). + */ + int endianness; +}; + +/** Bit indices used for SPI bit-bashing interface */ +enum { + /** Serial clock */ + SPI_BIT_SCLK = 0, + /** Master Out Slave In */ + SPI_BIT_MOSI, + /** Master In Slave Out */ + SPI_BIT_MISO, + /** Slave 0 select */ + SPI_BIT_SS0, +}; + +/** + * Determine bit index for a particular slave + * + * @v slave Slave number + * @ret index Bit index (i.e. SPI_BIT_SSN, where N=slave) + */ +#define SPI_BIT_SS( slave ) ( SPI_BIT_SS0 + (slave) ) + +/** Delay between SCLK transitions */ +#define SPI_BIT_UDELAY 1 + +/** SPI bit basher treats data as big-endian */ +#define SPI_BIT_BIG_ENDIAN 0 + +/** SPI bit basher treats data as little-endian */ +#define SPI_BIT_LITTLE_ENDIAN 1 + +extern void init_spi_bit_basher ( struct spi_bit_basher *spibit ); + +#endif /* _GPXE_SPI_BIT_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/srp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/srp.h new file mode 100644 index 0000000..85f39b9 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/srp.h @@ -0,0 +1,868 @@ +#ifndef _GPXE_SRP_H +#define _GPXE_SRP_H + +/** @file + * + * SCSI RDMA Protocol + * + */ + +FILE_LICENCE ( BSD2 ); + +#include <stdint.h> +#include <byteswap.h> +#include <gpxe/iobuf.h> +#include <gpxe/xfer.h> +#include <gpxe/scsi.h> + +/***************************************************************************** + * + * Common fields + * + ***************************************************************************** + */ + +/** An SRP information unit tag */ +struct srp_tag { + uint32_t dwords[2]; +} __attribute__ (( packed )); + +/** An SRP port ID */ +struct srp_port_id { + uint8_t bytes[16]; +} __attribute__ (( packed )); + +/** An SRP port ID pair */ +struct srp_port_ids { + /** Initiator port ID */ + struct srp_port_id initiator; + /** Target port ID */ + struct srp_port_id target; +} __attribute__ (( packed )); + +/** SRP information unit common fields */ +struct srp_common { + /** Information unit type */ + uint8_t type; + /** Reserved */ + uint8_t reserved0[7]; + /** Tag */ + struct srp_tag tag; +} __attribute__ (( packed )); + +/***************************************************************************** + * + * Login request + * + ***************************************************************************** + */ + +/** An SRP login request information unit */ +struct srp_login_req { + /** Information unit type + * + * This must be @c SRP_LOGIN_REQ + */ + uint8_t type; + /** Reserved */ + uint8_t reserved0[7]; + /** Tag */ + struct srp_tag tag; + /** Requested maximum initiator to target IU length */ + uint32_t max_i_t_iu_len; + /** Reserved */ + uint8_t reserved1[4]; + /** Required buffer formats + * + * This is the bitwise OR of one or more @c + * SRP_LOGIN_REQ_FMT_XXX constants. + */ + uint16_t required_buffer_formats; + /** Flags + * + * This is the bitwise OR of zero or more @c + * SRP_LOGIN_REQ_FLAG_XXX and @c SRP_LOGIN_REQ_MCA_XXX + * constants. + */ + uint8_t flags; + /** Reserved */ + uint8_t reserved2[5]; + /** Initiator and target port identifiers */ + struct srp_port_ids port_ids; +} __attribute__ (( packed )); + +/** Type of an SRP login request */ +#define SRP_LOGIN_REQ 0x00 + +/** Require indirect data buffer descriptor format */ +#define SRP_LOGIN_REQ_FMT_IDBD 0x04 + +/** Require direct data buffer descriptor format */ +#define SRP_LOGIN_REQ_FMT_DDBD 0x02 + +/** Use solicited notification for asynchronous events */ +#define SRP_LOGIN_REQ_FLAG_AESOLNT 0x40 + +/** Use solicited notification for credit request */ +#define SRP_LOGIN_REQ_FLAG_CRSOLNT 0x20 + +/** Use solicited notification for logouts */ +#define SRP_LOGIN_REQ_FLAG_LOSOLNT 0x10 + +/** Multi-channel action mask */ +#define SRP_LOGIN_REQ_MCA_MASK 0x03 + +/** Single RDMA channel operation */ +#define SRP_LOGIN_REQ_MCA_SINGLE_CHANNEL 0x00 + +/** Multiple independent RDMA channel operation */ +#define SRP_LOGIN_REQ_MCA_MULTIPLE_CHANNELS 0x01 + +/***************************************************************************** + * + * Login response + * + ***************************************************************************** + */ + +/** An SRP login response */ +struct srp_login_rsp { + /** Information unit type + * + * This must be @c SRP_LOGIN_RSP + */ + uint8_t type; + /** Reserved */ + uint8_t reserved0[3]; + /** Request limit delta */ + uint32_t request_limit_delta; + /** Tag */ + struct srp_tag tag; + /** Maximum initiator to target IU length */ + uint32_t max_i_t_iu_len; + /** Maximum target to initiator IU length */ + uint32_t max_t_i_iu_len; + /** Supported buffer formats + * + * This is the bitwise OR of one or more @c + * SRP_LOGIN_RSP_FMT_XXX constants. + */ + uint16_t supported_buffer_formats; + /** Flags + * + * This is the bitwise OR of zero or more @c + * SRP_LOGIN_RSP_FLAG_XXX and @c SRP_LOGIN_RSP_MCR_XXX + * constants. + */ + uint8_t flags; + /** Reserved */ + uint8_t reserved1[25]; +} __attribute__ (( packed )); + +/** Type of an SRP login response */ +#define SRP_LOGIN_RSP 0xc0 + +/** Indirect data buffer descriptor format supported */ +#define SRP_LOGIN_RSP_FMT_IDBD 0x04 + +/** Direct data buffer descriptor format supported */ +#define SRP_LOGIN_RSP_FMT_DDBD 0x02 + +/** Solicited notification is supported */ +#define SRP_LOGIN_RSP_FLAG_SOLNTSUP 0x10 + +/** Multi-channel result mask */ +#define SRP_LOGIN_RSP_MCR_MASK 0x03 + +/** No existing RDMA channels were associated with the same I_T nexus */ +#define SRP_LOGIN_RSP_MCR_NO_EXISTING_CHANNELS 0x00 + +/** One or more existing RDMA channels were terminated */ +#define SRP_LOGIN_RSP_MCR_EXISTING_CHANNELS_TERMINATED 0x01 + +/** One or more existing RDMA channels continue to operate independently */ +#define SRP_LOGIN_RSP_MCR_EXISTING_CHANNELS_CONTINUE 0x02 + +/***************************************************************************** + * + * Login rejection + * + ***************************************************************************** + */ + +/** An SRP login rejection */ +struct srp_login_rej { + /** Information unit type + * + * This must be @c SRP_LOGIN_REJ + */ + uint8_t type; + /** Reserved */ + uint8_t reserved0[3]; + /** Reason + * + * This is a @c SRP_LOGIN_REJ_REASON_XXX constant. + */ + uint32_t reason; + /** Tag */ + struct srp_tag tag; + /** Reserved */ + uint8_t reserved1[8]; + /** Supported buffer formats + * + * This is the bitwise OR of one or more @c + * SRP_LOGIN_REJ_FMT_XXX constants. + */ + uint16_t supported_buffer_formats; + /** Reserved */ + uint8_t reserved2[6]; +} __attribute__ (( packed )); + +/** Type of an SRP login rejection */ +#define SRP_LOGIN_REJ 0xc2 + +/** Unable to establish RDMA channel, no reason specified */ +#define SRP_LOGIN_REJ_REASON_UNKNOWN 0x00010000UL + +/** Insufficient RDMA channel resources */ +#define SRP_LOGIN_REJ_REASON_INSUFFICIENT_RESOURCES 0x00010001UL + +/** Requested maximum initiator to target IU length value too large */ +#define SRP_LOGIN_REJ_REASON_BAD_MAX_I_T_IU_LEN 0x00010002UL + +/** Unable to associate RDMA channel with specified I_T nexus */ +#define SRP_LOGIN_REJ_REASON_CANNOT_ASSOCIATE 0x00010003UL + +/** One or more requested data buffer descriptor formats are not supported */ +#define SRP_LOGIN_REJ_REASON_UNSUPPORTED_BUFFER_FORMAT 0x00010004UL + +/** SRP target port does not support multiple RDMA channels per I_T nexus */ +#define SRP_LOGIN_REJ_REASON_NO_MULTIPLE_CHANNELS 0x00010005UL + +/** RDMA channel limit reached for this initiator */ +#define SRP_LOGIN_REJ_REASON_NO_MORE_CHANNELS 0x00010006UL + +/** Indirect data buffer descriptor format supported */ +#define SRP_LOGIN_REJ_FMT_IDBD 0x04 + +/** Direct data buffer descriptor format supported */ +#define SRP_LOGIN_REJ_FMT_DDBD 0x02 + +/***************************************************************************** + * + * Initiator logout + * + ***************************************************************************** + */ + +/** An SRP initiator logout request */ +struct srp_i_logout { + /** Information unit type + * + * This must be @c SRP_I_LOGOUT + */ + uint8_t type; + /** Reserved */ + uint8_t reserved0[7]; + /** Tag */ + struct srp_tag tag; +} __attribute__ (( packed )); + +/** Type of an SRP initiator logout request */ +#define SRP_I_LOGOUT 0x03 + +/***************************************************************************** + * + * Target logout + * + ***************************************************************************** + */ + +/** An SRP target logout request */ +struct srp_t_logout { + /** Information unit type + * + * This must be @c SRP_T_LOGOUT + */ + uint8_t type; + /** Flags + * + * This is the bitwise OR of zero or more @c + * SRP_T_LOGOUT_FLAG_XXX constants. + */ + uint8_t flags; + /** Reserved */ + uint8_t reserved0[2]; + /** Reason + * + * This is a @c SRP_T_LOGOUT_REASON_XXX constant. + */ + uint32_t reason; + /** Tag */ + struct srp_tag tag; +} __attribute__ (( packed )); + +/** Type of an SRP target logout request */ +#define SRP_T_LOGOUT 0x80 + +/** The initiator specified solicited notification of logouts */ +#define SRP_T_LOGOUT_FLAG_SOLNT 0x01 + +/** No reason specified */ +#define SRP_T_LOGOUT_REASON_UNKNOWN 0x00000000UL + +/** Inactive RDMA channel (reclaiming resources) */ +#define SRP_T_LOGOUT_REASON_INACTIVE 0x00000001UL + +/** Invalid information unit type code received by SRP target port */ +#define SRP_T_LOGOUT_REASON_INVALID_TYPE 0x00000002UL + +/** SRP initiator port sent response with no corresponding request */ +#define SRP_T_LOGOUT_REASON_SPURIOUS_RESPONSE 0x00000003UL + +/** RDMA channel disconnected due to multi-channel action code in new login */ +#define SRP_T_LOGOUT_REASON_MCA 0x00000004UL + +/** Unsuppported format code value specified in data-out buffer descriptor */ +#define SRP_T_LOGOUT_UNSUPPORTED_DATA_OUT_FORMAT 0x00000005UL + +/** Unsuppported format code value specified in data-in buffer descriptor */ +#define SRP_T_LOGOUT_UNSUPPORTED_DATA_IN_FORMAT 0x00000006UL + +/** Invalid length for IU type */ +#define SRP_T_LOGOUT_INVALID_IU_LEN 0x00000008UL + +/***************************************************************************** + * + * Task management + * + ***************************************************************************** + */ + +/** An SRP task management request */ +struct srp_tsk_mgmt { + /** Information unit type + * + * This must be @c SRP_TSK_MGMT + */ + uint8_t type; + /** Flags + * + * This is the bitwise OR of zero or more + * @c SRP_TSK_MGMT_FLAG_XXX constants. + */ + uint8_t flags; + /** Reserved */ + uint8_t reserved0[6]; + /** Tag */ + struct srp_tag tag; + /** Reserved */ + uint8_t reserved1[4]; + /** Logical unit number */ + struct scsi_lun lun; + /** Reserved */ + uint8_t reserved2[2]; + /** Task management function + * + * This is a @c SRP_TASK_MGMT_FUNC_XXX constant + */ + uint8_t function; + /** Reserved */ + uint8_t reserved3[1]; + /** Tag of task to be managed */ + struct srp_tag managed_tag; + /** Reserved */ + uint8_t reserved4[8]; +} __attribute__ (( packed )); + +/** Type of an SRP task management request */ +#define SRP_TSK_MGMT 0x01 + +/** Use solicited notification for unsuccessful completions */ +#define SRP_TSK_MGMT_FLAG_UCSOLNT 0x04 + +/** Use solicited notification for successful completions */ +#define SRP_TSK_MGMT_FLAG_SCSOLNT 0x02 + +/** The task manager shall perform an ABORT TASK function */ +#define SRP_TSK_MGMT_FUNC_ABORT_TASK 0x01 + +/** The task manager shall perform an ABORT TASK SET function */ +#define SRP_TSK_MGMT_FUNC_ABORT_TASK_SET 0x02 + +/** The task manager shall perform a CLEAR TASK SET function */ +#define SRP_TSK_MGMT_FUNC_CLEAR_TASK_SET 0x04 + +/** The task manager shall perform a LOGICAL UNIT RESET function */ +#define SRP_TSK_MGMT_FUNC_LOGICAL_UNIT_RESET 0x08 + +/** The task manager shall perform a CLEAR ACA function */ +#define SRP_TSK_MGMT_FUNC_CLEAR_ACA 0x40 + +/***************************************************************************** + * + * SCSI command + * + ***************************************************************************** + */ + +/** An SRP SCSI command */ +struct srp_cmd { + /** Information unit type + * + * This must be @c SRP_CMD + */ + uint8_t type; + /** Flags + * + * This is the bitwise OR of zero or more @c SRP_CMD_FLAG_XXX + * constants. + */ + uint8_t flags; + /** Reserved */ + uint8_t reserved0[3]; + /** Data buffer descriptor formats + * + * This is the bitwise OR of one @c SRP_CMD_DO_FMT_XXX and one @c + * SRP_CMD_DI_FMT_XXX constant. + */ + uint8_t data_buffer_formats; + /** Data-out buffer descriptor count */ + uint8_t data_out_buffer_count; + /** Data-in buffer descriptor count */ + uint8_t data_in_buffer_count; + /** Tag */ + struct srp_tag tag; + /** Reserved */ + uint8_t reserved1[4]; + /** Logical unit number */ + struct scsi_lun lun; + /** Reserved */ + uint8_t reserved2[1]; + /** Task attribute + * + * This is a @c SRP_CMD_TASK_ATTR_XXX constant. + */ + uint8_t task_attr; + /** Reserved */ + uint8_t reserved3[1]; + /** Additional CDB length */ + uint8_t additional_cdb_len; + /** Command data block */ + union scsi_cdb cdb; +} __attribute__ (( packed )); + +/** Type of an SRP SCSI command */ +#define SRP_CMD 0x02 + +/** Use solicited notification for unsuccessful completions */ +#define SRP_CMD_FLAG_UCSOLNT 0x04 + +/** Use solicited notification for successful completions */ +#define SRP_CMD_FLAG_SCSOLNT 0x02 + +/** Data-out buffer format mask */ +#define SRP_CMD_DO_FMT_MASK 0xf0 + +/** Direct data-out buffer format */ +#define SRP_CMD_DO_FMT_DIRECT 0x10 + +/** Indirect data-out buffer format */ +#define SRP_CMD_DO_FMT_INDIRECT 0x20 + +/** Data-in buffer format mask */ +#define SRP_CMD_DI_FMT_MASK 0x0f + +/** Direct data-in buffer format */ +#define SRP_CMD_DI_FMT_DIRECT 0x01 + +/** Indirect data-in buffer format */ +#define SRP_CMD_DI_FMT_INDIRECT 0x02 + +/** Use the rules for a simple task attribute */ +#define SRP_CMD_TASK_ATTR_SIMPLE 0x00 + +/** Use the rules for a head of queue task attribute */ +#define SRP_CMD_TASK_ATTR_QUEUE_HEAD 0x01 + +/** Use the rules for an ordered task attribute */ +#define SRP_CMD_TASK_ATTR_ORDERED 0x02 + +/** Use the rules for an automatic contingent allegiance task attribute */ +#define SRP_CMD_TASK_ATTR_AUTOMATIC_CONTINGENT_ALLEGIANCE 0x08 + +/** An SRP memory descriptor */ +struct srp_memory_descriptor { + /** Virtual address */ + uint64_t address; + /** Memory handle */ + uint32_t handle; + /** Data length */ + uint32_t len; +} __attribute__ (( packed )); + +/***************************************************************************** + * + * SCSI response + * + ***************************************************************************** + */ + +/** An SRP SCSI response */ +struct srp_rsp { + /** Information unit type + * + * This must be @c SRP_RSP + */ + uint8_t type; + /** Flags + * + * This is the bitwise OR of zero or more @c SRP_RSP_FLAG_XXX + * constants. + */ + uint8_t flags; + /** Reserved */ + uint8_t reserved0[2]; + /** Request limit delta */ + uint32_t request_limit_delta; + /** Tag */ + struct srp_tag tag; + /** Reserved */ + uint8_t reserved1[2]; + /** Valid fields + * + * This is the bitwise OR of zero or more @c SRP_RSP_VALID_XXX + * constants. + */ + uint8_t valid; + /** Status + * + * This is the SCSI status code. + */ + uint8_t status; + /** Data-out residual count */ + uint32_t data_out_residual_count; + /** Data-in residual count */ + uint32_t data_in_residual_count; + /** Sense data list length */ + uint32_t sense_data_len; + /** Response data list length */ + uint32_t response_data_len; +} __attribute__ (( packed )); + +/** Type of an SRP SCSI response */ +#define SRP_RSP 0xc1 + +/** The initiator specified solicited notification of this response */ +#define SRP_RSP_FLAG_SOLNT 0x01 + +/** Data-in residual count field is valid and represents an underflow */ +#define SRP_RSP_VALID_DIUNDER 0x20 + +/** Data-in residual count field is valid and represents an overflow */ +#define SRP_RSP_VALID_DIOVER 0x10 + +/** Data-out residual count field is valid and represents an underflow */ +#define SRP_RSP_VALID_DOUNDER 0x08 + +/** Data-out residual count field is valid and represents an overflow */ +#define SRP_RSP_VALID_DOOVER 0x04 + +/** Sense data list length field is valid */ +#define SRP_RSP_VALID_SNSVALID 0x02 + +/** Response data list length field is valid */ +#define SRP_RSP_VALID_RSPVALID 0x01 + +/** + * Get response data portion of SCSI response + * + * @v rsp SCSI response + * @ret response_data Response data, or NULL if not present + */ +static inline void * srp_rsp_response_data ( struct srp_rsp *rsp ) { + return ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ? + ( ( ( void * ) rsp ) + sizeof ( *rsp ) ) : NULL ); +} + +/** + * Get length of response data portion of SCSI response + * + * @v rsp SCSI response + * @ret response_data_len Response data length + */ +static inline size_t srp_rsp_response_data_len ( struct srp_rsp *rsp ) { + return ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ? + ntohl ( rsp->response_data_len ) : 0 ); +} + +/** + * Get sense data portion of SCSI response + * + * @v rsp SCSI response + * @ret sense_data Sense data, or NULL if not present + */ +static inline void * srp_rsp_sense_data ( struct srp_rsp *rsp ) { + return ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ? + ( ( ( void * ) rsp ) + sizeof ( *rsp ) + + srp_rsp_response_data_len ( rsp ) ) : NULL ); +} + +/** + * Get length of sense data portion of SCSI response + * + * @v rsp SCSI response + * @ret sense_data_len Sense data length + */ +static inline size_t srp_rsp_sense_data_len ( struct srp_rsp *rsp ) { + return ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ? + ntohl ( rsp->sense_data_len ) : 0 ); +} + +/***************************************************************************** + * + * Credit request + * + ***************************************************************************** + */ + +/** An SRP credit request */ +struct srp_cred_req { + /** Information unit type + * + * This must be @c SRP_CRED_REQ + */ + uint8_t type; + /** Flags + * + * This is the bitwise OR of zero or more + * @c SRP_CRED_REQ_FLAG_XXX constants. + */ + uint8_t flags; + /** Reserved */ + uint8_t reserved0[2]; + /** Request limit delta */ + uint32_t request_limit_delta; + /** Tag */ + struct srp_tag tag; +} __attribute__ (( packed )); + +/** Type of an SRP credit request */ +#define SRP_CRED_REQ 0x81 + +/** The initiator specified solicited notification of credit requests */ +#define SRP_CRED_REQ_FLAG_SOLNT 0x01 + +/***************************************************************************** + * + * Credit response + * + ***************************************************************************** + */ + +/** An SRP credit response */ +struct srp_cred_rsp { + /** Information unit type + * + * This must be @c SRP_CRED_RSP + */ + uint8_t type; + /** Reserved */ + uint8_t reserved0[7]; + /** Tag */ + struct srp_tag tag; +} __attribute__ (( packed )); + +/** Type of an SRP credit response */ +#define SRP_CRED_RSP 0x41 + +/***************************************************************************** + * + * Asynchronous event request + * + ***************************************************************************** + */ + +/** An SRP asynchronous event request */ +struct srp_aer_req { + /** Information unit type + * + * This must be @c SRP_AER_REQ + */ + uint8_t type; + /** Flags + * + * This is the bitwise OR of zero or more @c + * SRP_AER_REQ_FLAG_XXX constants. + */ + uint8_t flags; + /** Reserved */ + uint8_t reserved0[2]; + /** Request limit delta */ + uint32_t request_limit_delta; + /** Tag */ + struct srp_tag tag; + /** Reserved */ + uint8_t reserved1[4]; + /** Logical unit number */ + struct scsi_lun lun; + /** Sense data list length */ + uint32_t sense_data_len; + /** Reserved */ + uint8_t reserved2[4]; +} __attribute__ (( packed )); + +/** Type of an SRP asynchronous event request */ +#define SRP_AER_REQ 0x82 + +/** The initiator specified solicited notification of asynchronous events */ +#define SRP_AER_REQ_FLAG_SOLNT 0x01 + +/** + * Get sense data portion of asynchronous event request + * + * @v aer_req SRP asynchronous event request + * @ret sense_data Sense data + */ +static inline __always_inline void * +srp_aer_req_sense_data ( struct srp_aer_req *aer_req ) { + return ( ( ( void * ) aer_req ) + sizeof ( *aer_req ) ); +} + +/** + * Get length of sense data portion of asynchronous event request + * + * @v aer_req SRP asynchronous event request + * @ret sense_data_len Sense data length + */ +static inline __always_inline size_t +srp_aer_req_sense_data_len ( struct srp_aer_req *aer_req ) { + return ( ntohl ( aer_req->sense_data_len ) ); +} + +/***************************************************************************** + * + * Asynchronous event response + * + ***************************************************************************** + */ + +/** An SRP asynchronous event response */ +struct srp_aer_rsp { + /** Information unit type + * + * This must be @c SRP_AER_RSP + */ + uint8_t type; + /** Reserved */ + uint8_t reserved0[7]; + /** Tag */ + struct srp_tag tag; +} __attribute__ (( packed )); + +/** Type of an SRP asynchronous event response */ +#define SRP_AER_RSP 0x42 + +/***************************************************************************** + * + * Information units + * + ***************************************************************************** + */ + +/** Maximum length of any initiator-to-target IU that we will send + * + * The longest IU is a SRP_CMD with no additional CDB and two direct + * data buffer descriptors, which comes to 80 bytes. + */ +#define SRP_MAX_I_T_IU_LEN 80 + +/***************************************************************************** + * + * SRP device + * + ***************************************************************************** + */ + +struct srp_device; + +/** An SRP transport type */ +struct srp_transport_type { + /** Length of transport private data */ + size_t priv_len; + /** Parse root path + * + * @v srp SRP device + * @v root_path Root path + * @ret Return status code + */ + int ( * parse_root_path ) ( struct srp_device *srp, + const char *root_path ); + /** Connect SRP session + * + * @v srp SRP device + * @ret rc Return status code + * + * This method should open the underlying socket. + */ + int ( * connect ) ( struct srp_device *srp ); +}; + +/** An SRP device */ +struct srp_device { + /** Reference count */ + struct refcnt refcnt; + + /** Initiator and target port IDs */ + struct srp_port_ids port_ids; + /** Logical unit number */ + struct scsi_lun lun; + /** Memory handle */ + uint32_t memory_handle; + + /** Current state + * + * This is the bitwise-OR of zero or more @c SRP_STATE_XXX + * flags. + */ + unsigned int state; + /** Retry counter */ + unsigned int retry_count; + /** Current SCSI command */ + struct scsi_command *command; + + /** Underlying data transfer interface */ + struct xfer_interface socket; + + /** Transport type */ + struct srp_transport_type *transport; + /** Transport private data */ + char transport_priv[0]; +}; + +/** + * Get SRP transport private data + * + * @v srp SRP device + * @ret priv SRP transport private data + */ +static inline __always_inline void * +srp_transport_priv ( struct srp_device *srp ) { + return ( ( void * ) srp->transport_priv ); +} + +/** SRP state flags */ +enum srp_state { + /** Underlying socket is open */ + SRP_STATE_SOCKET_OPEN = 0x0001, + /** Session is logged in */ + SRP_STATE_LOGGED_IN = 0x0002, +}; + +/** Maximum number of SRP retry attempts */ +#define SRP_MAX_RETRIES 3 + +extern int srp_attach ( struct scsi_device *scsi, const char *root_path ); +extern void srp_detach ( struct scsi_device *scsi ); + +#endif /* _GPXE_SRP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/tables.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tables.h new file mode 100644 index 0000000..7dfced8 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tables.h @@ -0,0 +1,434 @@ +#ifndef _GPXE_TABLES_H +#define _GPXE_TABLES_H + +FILE_LICENCE ( GPL2_OR_LATER ); + +/** @page ifdef_harmful #ifdef considered harmful + * + * Overuse of @c #ifdef has long been a problem in Etherboot. + * Etherboot provides a rich array of features, but all these features + * take up valuable space in a ROM image. The traditional solution to + * this problem has been for each feature to have its own @c #ifdef + * option, allowing the feature to be compiled in only if desired. + * + * The problem with this is that it becomes impossible to compile, let + * alone test, all possible versions of Etherboot. Code that is not + * typically used tends to suffer from bit-rot over time. It becomes + * extremely difficult to predict which combinations of compile-time + * options will result in code that can even compile and link + * correctly. + * + * To solve this problem, we have adopted a new approach from + * Etherboot 5.5 onwards. @c #ifdef is now "considered harmful", and + * its use should be minimised. Separate features should be + * implemented in separate @c .c files, and should \b always be + * compiled (i.e. they should \b not be guarded with a @c #ifdef @c + * MY_PET_FEATURE statement). By making (almost) all code always + * compile, we avoid the problem of bit-rot in rarely-used code. + * + * The file config.h, in combination with the @c make command line, + * specifies the objects that will be included in any particular build + * of Etherboot. For example, suppose that config.h includes the line + * + * @code + * + * #define CONSOLE_SERIAL + * #define DOWNLOAD_PROTO_TFTP + * + * @endcode + * + * When a particular Etherboot image (e.g. @c bin/rtl8139.zdsk) is + * built, the options specified in config.h are used to drag in the + * relevant objects at link-time. For the above example, serial.o and + * tftp.o would be linked in. + * + * There remains one problem to solve: how do these objects get used? + * Traditionally, we had code such as + * + * @code + * + * #ifdef CONSOLE_SERIAL + * serial_init(); + * #endif + * + * @endcode + * + * in main.c, but this reintroduces @c #ifdef and so is a Bad Idea. + * We cannot simply remove the @c #ifdef and make it + * + * @code + * + * serial_init(); + * + * @endcode + * + * because then serial.o would end up always being linked in. + * + * The solution is to use @link tables.h linker tables @endlink. + * + */ + +/** @file + * + * Linker tables + * + * Read @ref ifdef_harmful first for some background on the motivation + * for using linker tables. + * + * This file provides macros for dealing with linker-generated tables + * of fixed-size symbols. We make fairly extensive use of these in + * order to avoid @c #ifdef spaghetti and/or linker symbol pollution. + * For example, instead of having code such as + * + * @code + * + * #ifdef CONSOLE_SERIAL + * serial_init(); + * #endif + * + * @endcode + * + * we make serial.c generate an entry in the initialisation function + * table, and then have a function call_init_fns() that simply calls + * all functions present in this table. If and only if serial.o gets + * linked in, then its initialisation function will be called. We + * avoid linker symbol pollution (i.e. always dragging in serial.o + * just because of a call to serial_init()) and we also avoid @c + * #ifdef spaghetti (having to conditionalise every reference to + * functions in serial.c). + * + * The linker script takes care of assembling the tables for us. All + * our table sections have names of the format @c .tbl.NAME.NN where + * @c NAME designates the data structure stored in the table (e.g. @c + * init_fns) and @c NN is a two-digit decimal number used to impose an + * ordering upon the tables if required. @c NN=00 is reserved for the + * symbol indicating "table start", and @c NN=99 is reserved for the + * symbol indicating "table end". + * + * As an example, suppose that we want to create a "frobnicator" + * feature framework, and allow for several independent modules to + * provide frobnicating services. Then we would create a frob.h + * header file containing e.g. + * + * @code + * + * struct frobnicator { + * const char *name; // Name of the frobnicator + * void ( *frob ) ( void ); // The frobnicating function itself + * }; + * + * #define FROBNICATORS __table ( struct frobnicator, "frobnicators" ) + * + * #define __frobnicator __table_entry ( FROBNICATORS, 01 ) + * + * @endcode + * + * Any module providing frobnicating services would look something + * like + * + * @code + * + * #include "frob.h" + * + * static void my_frob ( void ) { + * // Do my frobnicating + * ... + * } + * + * struct frob my_frobnicator __frobnicator = { + * .name = "my_frob", + * .frob = my_frob, + * }; + * + * @endcode + * + * The central frobnicator code (frob.c) would use the frobnicating + * modules as follows + * + * @code + * + * #include "frob.h" + * + * // Call all linked-in frobnicators + * void frob_all ( void ) { + * struct frob *frob; + * + * for_each_table ( frob, FROBNICATORS ) { + * printf ( "Calling frobnicator \"%s\"\n", frob->name ); + * frob->frob (); + * } + * } + * + * @endcode + * + * See init.h and init.c for a real-life example. + * + */ + +#ifdef DOXYGEN +#define __attribute__( x ) +#endif + +/** + * Declare a linker table + * + * @v type Data type + * @v name Table name + * @ret table Linker table + */ +#define __table( type, name ) ( type, name ) + +/** + * Get linker table data type + * + * @v table Linker table + * @ret type Data type + */ +#define __table_type( table ) __table_extract_type table +#define __table_extract_type( type, name ) type + +/** + * Get linker table name + * + * @v table Linker table + * @ret name Table name + */ +#define __table_name( table ) __table_extract_name table +#define __table_extract_name( type, name ) name + +/** + * Get linker table section name + * + * @v table Linker table + * @v idx Sub-table index + * @ret section Section name + */ +#define __table_section( table, idx ) \ + ".tbl." __table_name ( table ) "." __table_str ( idx ) +#define __table_str( x ) #x + +/** + * Get linker table alignment + * + * @v table Linker table + * @ret align Alignment + */ +#define __table_alignment( table ) __alignof__ ( __table_type ( table ) ) + +/** + * Declare a linker table entry + * + * @v table Linker table + * @v idx Sub-table index + * + * Example usage: + * + * @code + * + * #define FROBNICATORS __table ( struct frobnicator, "frobnicators" ) + * + * #define __frobnicator __table_entry ( FROBNICATORS, 01 ) + * + * struct frobnicator my_frob __frobnicator = { + * ... + * }; + * + * @endcode + */ +#define __table_entry( table, idx ) \ + __attribute__ (( __section__ ( __table_section ( table, idx ) ),\ + __aligned__ ( __table_alignment ( table ) ) )) + +/** + * Get start of linker table entries + * + * @v table Linker table + * @v idx Sub-table index + * @ret entries Start of entries + */ +#define __table_entries( table, idx ) ( { \ + static __table_type ( table ) __table_entries[0] \ + __table_entry ( table, idx ); \ + __table_entries; } ) + +/** + * Get start of linker table + * + * @v table Linker table + * @ret start Start of linker table + * + * Example usage: + * + * @code + * + * #define FROBNICATORS __table ( struct frobnicator, "frobnicators" ) + * + * struct frobnicator *frobs = table_start ( FROBNICATORS ); + * + * @endcode + */ +#define table_start( table ) __table_entries ( table, 00 ) + +/** + * Get end of linker table + * + * @v table Linker table + * @ret end End of linker table + * + * Example usage: + * + * @code + * + * #define FROBNICATORS __table ( struct frobnicator, "frobnicators" ) + * + * struct frobnicator *frobs_end = table_end ( FROBNICATORS ); + * + * @endcode + */ +#define table_end( table ) __table_entries ( table, 99 ) + +/** + * Get number of entries in linker table + * + * @v table Linker table + * @ret num_entries Number of entries in linker table + * + * Example usage: + * + * @code + * + * #define FROBNICATORS __table ( struct frobnicator, "frobnicators" ) + * + * unsigned int num_frobs = table_num_entries ( FROBNICATORS ); + * + * @endcode + * + */ +#define table_num_entries( table ) \ + ( ( unsigned int ) ( table_end ( table ) - \ + table_start ( table ) ) ) + +/** + * Iterate through all entries within a linker table + * + * @v pointer Entry pointer + * @v table Linker table + * + * Example usage: + * + * @code + * + * #define FROBNICATORS __table ( struct frobnicator, "frobnicators" ) + * + * struct frobnicator *frob; + * + * for_each_table_entry ( frob, FROBNICATORS ) { + * ... + * } + * + * @endcode + * + */ +#define for_each_table_entry( pointer, table ) \ + for ( pointer = table_start ( table ) ; \ + pointer < table_end ( table ) ; \ + pointer++ ) + +/** + * Iterate through all entries within a linker table in reverse order + * + * @v pointer Entry pointer + * @v table Linker table + * + * Example usage: + * + * @code + * + * #define FROBNICATORS __table ( struct frobnicator, "frobnicators" ) + * + * struct frobnicator *frob; + * + * for_each_table_entry_reverse ( frob, FROBNICATORS ) { + * ... + * } + * + * @endcode + * + */ +#define for_each_table_entry_reverse( pointer, table ) \ + for ( pointer = ( table_end ( table ) - 1 ) ; \ + pointer >= table_start ( table ) ; \ + pointer-- ) + +/****************************************************************************** + * + * Intel's C compiler chokes on several of the constructs used in this + * file. The workarounds are ugly, so we use them only for an icc + * build. + * + */ +#define ICC_ALIGN_HACK_FACTOR 128 +#ifdef __ICC + +/* + * icc miscompiles zero-length arrays by inserting padding to a length + * of two array elements. We therefore have to generate the + * __table_entries() symbols by hand in asm. + * + */ +#undef __table_entries +#define __table_entries( table, idx ) ( { \ + extern __table_type ( table ) \ + __table_temp_sym ( idx, __LINE__ ) [] \ + __table_entry ( table, idx ) \ + asm ( __table_entries_sym ( table, idx ) ); \ + __asm__ ( ".ifndef %c0\n\t" \ + ".section " __table_section ( table, idx ) "\n\t" \ + ".align %c1\n\t" \ + "\n%c0:\n\t" \ + ".previous\n\t" \ + ".endif\n\t" \ + : : "i" ( __table_temp_sym ( idx, __LINE__ ) ), \ + "i" ( __table_alignment ( table ) ) ); \ + __table_temp_sym ( idx, __LINE__ ); } ) +#define __table_entries_sym( table, idx ) \ + "__tbl_" __table_name ( table ) "_" #idx +#define __table_temp_sym( a, b ) \ + ___table_temp_sym( __table_, a, _, b ) +#define ___table_temp_sym( a, b, c, d ) a ## b ## c ## d + +/* + * icc ignores __attribute__ (( aligned (x) )) when it is used to + * decrease the compiler's default choice of alignment (which may be + * higher than the alignment actually required by the structure). We + * work around this by forcing the alignment to a large multiple of + * the required value (so that we are never attempting to decrease the + * default alignment) and then postprocessing the object file to + * reduce the alignment back down to the "real" value. + * + */ +#undef __table_alignment +#define __table_alignment( table ) \ + ( ICC_ALIGN_HACK_FACTOR * __alignof__ ( __table_type ( table ) ) ) + +/* + * Because of the alignment hack, we must ensure that the compiler + * never tries to place multiple objects within the same section, + * otherwise the assembler will insert padding to the (incorrect) + * alignment boundary. Do this by appending the line number to table + * section names. + * + * Note that we don't need to worry about padding between array + * elements, since the alignment is declared on the variable (i.e. the + * whole array) rather than on the type (i.e. on all individual array + * elements). + */ +#undef __table_section +#define __table_section( table, idx ) \ + ".tbl." __table_name ( table ) "." __table_str ( idx ) \ + "." __table_xstr ( __LINE__ ) +#define __table_xstr( x ) __table_str ( x ) + +#endif /* __ICC */ + +#endif /* _GPXE_TABLES_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/tcp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tcp.h new file mode 100644 index 0000000..7ae7eab --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tcp.h @@ -0,0 +1,318 @@ +#ifndef _GPXE_TCP_H +#define _GPXE_TCP_H + +/** @file + * + * TCP protocol + * + * This file defines the gPXE TCP API. + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/tcpip.h> + +/** + * A TCP header + */ +struct tcp_header { + uint16_t src; /* Source port */ + uint16_t dest; /* Destination port */ + uint32_t seq; /* Sequence number */ + uint32_t ack; /* Acknowledgement number */ + uint8_t hlen; /* Header length (4), Reserved (4) */ + uint8_t flags; /* Reserved (2), Flags (6) */ + uint16_t win; /* Advertised window */ + uint16_t csum; /* Checksum */ + uint16_t urg; /* Urgent pointer */ +}; + +/** @defgroup tcpopts TCP options + * @{ + */ + +/** End of TCP options list */ +#define TCP_OPTION_END 0 + +/** TCP option pad */ +#define TCP_OPTION_NOP 1 + +/** Generic TCP option */ +struct tcp_option { + uint8_t kind; + uint8_t length; +} __attribute__ (( packed )); + +/** TCP MSS option */ +struct tcp_mss_option { + uint8_t kind; + uint8_t length; + uint16_t mss; +} __attribute__ (( packed )); + +/** Code for the TCP MSS option */ +#define TCP_OPTION_MSS 2 + +/** TCP timestamp option */ +struct tcp_timestamp_option { + uint8_t kind; + uint8_t length; + uint32_t tsval; + uint32_t tsecr; +} __attribute__ (( packed )); + +/** Padded TCP timestamp option (used for sending) */ +struct tcp_timestamp_padded_option { + uint8_t nop[2]; + struct tcp_timestamp_option tsopt; +} __attribute__ (( packed )); + +/** Code for the TCP timestamp option */ +#define TCP_OPTION_TS 8 + +/** Parsed TCP options */ +struct tcp_options { + /** MSS option, if present */ + const struct tcp_mss_option *mssopt; + /** Timestampe option, if present */ + const struct tcp_timestamp_option *tsopt; +}; + +/** @} */ + +/* + * TCP flags + */ +#define TCP_CWR 0x80 +#define TCP_ECE 0x40 +#define TCP_URG 0x20 +#define TCP_ACK 0x10 +#define TCP_PSH 0x08 +#define TCP_RST 0x04 +#define TCP_SYN 0x02 +#define TCP_FIN 0x01 + +/** +* @defgroup tcpstates TCP states +* +* The TCP state is defined by a combination of the flags that have +* been sent to the peer, the flags that have been acknowledged by the +* peer, and the flags that have been received from the peer. +* +* @{ +*/ + +/** TCP flags that have been sent in outgoing packets */ +#define TCP_STATE_SENT(flags) ( (flags) << 0 ) +#define TCP_FLAGS_SENT(state) ( ( (state) >> 0 ) & 0xff ) + +/** TCP flags that have been acknowledged by the peer + * + * Note that this applies only to SYN and FIN. + */ +#define TCP_STATE_ACKED(flags) ( (flags) << 8 ) +#define TCP_FLAGS_ACKED(state) ( ( (state) >> 8 ) & 0xff ) + +/** TCP flags that have been received from the peer + * + * Note that this applies only to SYN and FIN, and that once SYN has + * been received, we should always be sending ACK. + */ +#define TCP_STATE_RCVD(flags) ( (flags) << 16 ) +#define TCP_FLAGS_RCVD(state) ( ( (state) >> 16 ) & 0xff ) + +/** TCP flags that are currently being sent in outgoing packets */ +#define TCP_FLAGS_SENDING(state) \ + ( TCP_FLAGS_SENT ( state ) & ~TCP_FLAGS_ACKED ( state ) ) + +/** CLOSED + * + * The connection has not yet been used for anything. + */ +#define TCP_CLOSED TCP_RST + +/** LISTEN + * + * Not currently used as a state; we have no support for listening + * connections. Given a unique value to avoid compiler warnings. + */ +#define TCP_LISTEN 0 + +/** SYN_SENT + * + * SYN has been sent, nothing has yet been received or acknowledged. + */ +#define TCP_SYN_SENT ( TCP_STATE_SENT ( TCP_SYN ) ) + +/** SYN_RCVD + * + * SYN has been sent but not acknowledged, SYN has been received. + */ +#define TCP_SYN_RCVD ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK ) | \ + TCP_STATE_RCVD ( TCP_SYN ) ) + +/** ESTABLISHED + * + * SYN has been sent and acknowledged, SYN has been received. + */ +#define TCP_ESTABLISHED ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK ) | \ + TCP_STATE_ACKED ( TCP_SYN ) | \ + TCP_STATE_RCVD ( TCP_SYN ) ) + +/** FIN_WAIT_1 + * + * SYN has been sent and acknowledged, SYN has been received, FIN has + * been sent but not acknowledged, FIN has not been received. + * + * RFC 793 shows that we can enter FIN_WAIT_1 without have had SYN + * acknowledged, i.e. if the application closes the connection after + * sending and receiving SYN, but before having had SYN acknowledged. + * However, we have to *pretend* that SYN has been acknowledged + * anyway, otherwise we end up sending SYN and FIN in the same + * sequence number slot. Therefore, when we transition from SYN_RCVD + * to FIN_WAIT_1, we have to remember to set TCP_STATE_ACKED(TCP_SYN) + * and increment our sequence number. + */ +#define TCP_FIN_WAIT_1 ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK | TCP_FIN ) | \ + TCP_STATE_ACKED ( TCP_SYN ) | \ + TCP_STATE_RCVD ( TCP_SYN ) ) + +/** FIN_WAIT_2 + * + * SYN has been sent and acknowledged, SYN has been received, FIN has + * been sent and acknowledged, FIN ha not been received. + */ +#define TCP_FIN_WAIT_2 ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK | TCP_FIN ) | \ + TCP_STATE_ACKED ( TCP_SYN | TCP_FIN ) | \ + TCP_STATE_RCVD ( TCP_SYN ) ) + +/** CLOSING / LAST_ACK + * + * SYN has been sent and acknowledged, SYN has been received, FIN has + * been sent but not acknowledged, FIN has been received. + * + * This state actually encompasses both CLOSING and LAST_ACK; they are + * identical with the definition of state that we use. I don't + * *believe* that they need to be distinguished. + */ +#define TCP_CLOSING_OR_LAST_ACK \ + ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK | TCP_FIN ) | \ + TCP_STATE_ACKED ( TCP_SYN ) | \ + TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) ) + +/** TIME_WAIT + * + * SYN has been sent and acknowledged, SYN has been received, FIN has + * been sent and acknowledged, FIN has been received. + */ +#define TCP_TIME_WAIT ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK | TCP_FIN ) | \ + TCP_STATE_ACKED ( TCP_SYN | TCP_FIN ) | \ + TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) ) + +/** CLOSE_WAIT + * + * SYN has been sent and acknowledged, SYN has been received, FIN has + * been received. + */ +#define TCP_CLOSE_WAIT ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK ) | \ + TCP_STATE_ACKED ( TCP_SYN ) | \ + TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) ) + +/** Can send data in current state + * + * We can send data if and only if we have had our SYN acked and we + * have not yet sent our FIN. + */ +#define TCP_CAN_SEND_DATA(state) \ + ( ( (state) & ( TCP_STATE_ACKED ( TCP_SYN ) | \ + TCP_STATE_SENT ( TCP_FIN ) ) ) \ + == TCP_STATE_ACKED ( TCP_SYN ) ) + +/** Have ever been fully established + * + * We have been fully established if we have both received a SYN and + * had our own SYN acked. + */ +#define TCP_HAS_BEEN_ESTABLISHED(state) \ + ( ( (state) & ( TCP_STATE_ACKED ( TCP_SYN ) | \ + TCP_STATE_RCVD ( TCP_SYN ) ) ) \ + == ( TCP_STATE_ACKED ( TCP_SYN ) | TCP_STATE_RCVD ( TCP_SYN ) ) ) + +/** Have closed gracefully + * + * We have closed gracefully if we have both received a FIN and had + * our own FIN acked. + */ +#define TCP_CLOSED_GRACEFULLY(state) \ + ( ( (state) & ( TCP_STATE_ACKED ( TCP_FIN ) | \ + TCP_STATE_RCVD ( TCP_FIN ) ) ) \ + == ( TCP_STATE_ACKED ( TCP_FIN ) | TCP_STATE_RCVD ( TCP_FIN ) ) ) + +/** @} */ + +/** Mask for TCP header length field */ +#define TCP_MASK_HLEN 0xf0 + +/** Smallest port number on which a TCP connection can listen */ +#define TCP_MIN_PORT 1 + +/* Some IOB constants */ +#define MAX_HDR_LEN 100 +#define MAX_IOB_LEN 1500 +#define MIN_IOB_LEN MAX_HDR_LEN + 100 /* To account for padding by LL */ + +/** + * Maxmimum advertised TCP window size + * + * We estimate the TCP window size as the amount of free memory we + * have. This is not strictly accurate (since it ignores any space + * already allocated as RX buffers), but it will do for now. + * + * Since we don't store out-of-order received packets, the + * retransmission penalty is that the whole window contents must be + * resent. This suggests keeping the window size small, but bear in + * mind that the maximum bandwidth on any link is limited to + * + * max_bandwidth = ( tcp_window / round_trip_time ) + * + * With a 48kB window, which probably accurately reflects our amount + * of free memory, and a WAN RTT of say 200ms, this gives a maximum + * bandwidth of 240kB/s. This is sufficiently close to realistic that + * we will need to be careful that our advertised window doesn't end + * up limiting WAN download speeds. + * + * Finally, since the window goes into a 16-bit field and we cannot + * actually use 65536, we use a window size of (65536-4) to ensure + * that payloads remain dword-aligned. + */ +//#define TCP_MAX_WINDOW_SIZE ( 65536 - 4 ) +#define TCP_MAX_WINDOW_SIZE 4096 + +/** + * Path MTU + * + * We really ought to implement Path MTU discovery. Until we do, + * anything with a path MTU greater than this may fail. + */ +#define TCP_PATH_MTU 1460 + +/** + * Advertised TCP MSS + * + * We currently hardcode this to a reasonable value and hope that the + * sender uses path MTU discovery. The alternative is breaking the + * abstraction layer so that we can find out the MTU from the IP layer + * (which would have to find out from the net device layer). + */ +#define TCP_MSS 1460 + +/** TCP maximum segment lifetime + * + * Currently set to 2 minutes, as per RFC 793. + */ +#define TCP_MSL ( 2 * 60 * TICKS_PER_SEC ) + +extern struct tcpip_protocol tcp_protocol; + +#endif /* _GPXE_TCP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/tcpip.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tcpip.h new file mode 100644 index 0000000..f71d7d6 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tcpip.h @@ -0,0 +1,128 @@ +#ifndef _GPXE_TCPIP_H +#define _GPXE_TCPIP_H + +/** @file + * + * Transport-network layer interface + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/socket.h> +#include <gpxe/in.h> +#include <gpxe/tables.h> + +struct io_buffer; +struct net_device; + +/** Empty checksum value + * + * This is the TCP/IP checksum over a zero-length block of data. + */ +#define TCPIP_EMPTY_CSUM 0xffff + +/** + * TCP/IP socket address + * + * This contains the fields common to socket addresses for all TCP/IP + * address families. + */ +struct sockaddr_tcpip { + /** Socket address family (part of struct @c sockaddr) */ + sa_family_t st_family; + /** TCP/IP port */ + uint16_t st_port; + /** Padding + * + * This ensures that a struct @c sockaddr_tcpip is large + * enough to hold a socket address for any TCP/IP address + * family. + */ + char pad[ sizeof ( struct sockaddr ) - + ( sizeof ( sa_family_t ) + sizeof ( uint16_t ) ) ]; +} __attribute__ (( may_alias )); + +/** + * A transport-layer protocol of the TCP/IP stack (eg. UDP, TCP, etc) + */ +struct tcpip_protocol { + /** Protocol name */ + const char *name; + /** + * Process received packet + * + * @v iobuf I/O buffer + * @v st_src Partially-filled source address + * @v st_dest Partially-filled destination address + * @v pshdr_csum Pseudo-header checksum + * @ret rc Return status code + * + * This method takes ownership of the I/O buffer. + */ + int ( * rx ) ( struct io_buffer *iobuf, struct sockaddr_tcpip *st_src, + struct sockaddr_tcpip *st_dest, uint16_t pshdr_csum ); + /** + * Transport-layer protocol number + * + * This is a constant of the type IP_XXX + */ + uint8_t tcpip_proto; +}; + +/** + * A network-layer protocol of the TCP/IP stack (eg. IPV4, IPv6, etc) + */ +struct tcpip_net_protocol { + /** Protocol name */ + const char *name; + /** Network address family */ + sa_family_t sa_family; + /** + * Transmit packet + * + * @v iobuf I/O buffer + * @v tcpip_protocol Transport-layer protocol + * @v st_src Source address, or NULL to use default + * @v st_dest Destination address + * @v netdev Network device (or NULL to route automatically) + * @v trans_csum Transport-layer checksum to complete, or NULL + * @ret rc Return status code + * + * This function takes ownership of the I/O buffer. + */ + int ( * tx ) ( struct io_buffer *iobuf, + struct tcpip_protocol *tcpip_protocol, + struct sockaddr_tcpip *st_src, + struct sockaddr_tcpip *st_dest, + struct net_device *netdev, + uint16_t *trans_csum ); +}; + +/** TCP/IP transport-layer protocol table */ +#define TCPIP_PROTOCOLS __table ( struct tcpip_protocol, "tcpip_protocols" ) + +/** Declare a TCP/IP transport-layer protocol */ +#define __tcpip_protocol __table_entry ( TCPIP_PROTOCOLS, 01 ) + +/** TCP/IP network-layer protocol table */ +#define TCPIP_NET_PROTOCOLS \ + __table ( struct tcpip_net_protocol, "tcpip_net_protocols" ) + +/** Declare a TCP/IP network-layer protocol */ +#define __tcpip_net_protocol __table_entry ( TCPIP_NET_PROTOCOLS, 01 ) + +extern int tcpip_rx ( struct io_buffer *iobuf, uint8_t tcpip_proto, + struct sockaddr_tcpip *st_src, + struct sockaddr_tcpip *st_dest, uint16_t pshdr_csum ); +extern int tcpip_tx ( struct io_buffer *iobuf, struct tcpip_protocol *tcpip, + struct sockaddr_tcpip *st_src, + struct sockaddr_tcpip *st_dest, + struct net_device *netdev, + uint16_t *trans_csum ); +extern uint16_t tcpip_continue_chksum ( uint16_t partial, + const void *data, size_t len ); +extern uint16_t tcpip_chksum ( const void *data, size_t len ); + +#endif /* _GPXE_TCPIP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/tftp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tftp.h new file mode 100644 index 0000000..c57bb25 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tftp.h @@ -0,0 +1,85 @@ +#ifndef _GPXE_TFTP_H +#define _GPXE_TFTP_H + +/** @file + * + * TFTP protocol + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +#define TFTP_PORT 69 /**< Default TFTP server port */ +#define TFTP_DEFAULT_BLKSIZE 512 /**< Default TFTP data block size */ +#define TFTP_MAX_BLKSIZE 1432 + +#define TFTP_RRQ 1 /**< Read request opcode */ +#define TFTP_WRQ 2 /**< Write request opcode */ +#define TFTP_DATA 3 /**< Data block opcode */ +#define TFTP_ACK 4 /**< Data block acknowledgement opcode */ +#define TFTP_ERROR 5 /**< Error opcode */ +#define TFTP_OACK 6 /**< Options acknowledgement opcode */ + +#define TFTP_ERR_FILE_NOT_FOUND 1 /**< File not found */ +#define TFTP_ERR_ACCESS_DENIED 2 /**< Access violation */ +#define TFTP_ERR_DISK_FULL 3 /**< Disk full or allocation exceeded */ +#define TFTP_ERR_ILLEGAL_OP 4 /**< Illegal TFTP operation */ +#define TFTP_ERR_UNKNOWN_TID 5 /**< Unknown transfer ID */ +#define TFTP_ERR_FILE_EXISTS 6 /**< File already exists */ +#define TFTP_ERR_UNKNOWN_USER 7 /**< No such user */ +#define TFTP_ERR_BAD_OPTS 8 /**< Option negotiation failed */ + +#define MTFTP_PORT 1759 /**< Default MTFTP server port */ + +/** A TFTP read request (RRQ) packet */ +struct tftp_rrq { + uint16_t opcode; + char data[0]; +} __attribute__ (( packed )); + +/** A TFTP data (DATA) packet */ +struct tftp_data { + uint16_t opcode; + uint16_t block; + uint8_t data[0]; +} __attribute__ (( packed )); + +/** A TFTP acknowledgement (ACK) packet */ +struct tftp_ack { + uint16_t opcode; + uint16_t block; +} __attribute__ (( packed )); + +/** A TFTP error (ERROR) packet */ +struct tftp_error { + uint16_t opcode; + uint16_t errcode; + char errmsg[0]; +} __attribute__ (( packed )); + +/** A TFTP options acknowledgement (OACK) packet */ +struct tftp_oack { + uint16_t opcode; + char data[0]; +} __attribute__ (( packed )); + +/** The common header of all TFTP packets */ +struct tftp_common { + uint16_t opcode; +} __attribute__ (( packed )); + +/** A union encapsulating all TFTP packet types */ +union tftp_any { + struct tftp_common common; + struct tftp_rrq rrq; + struct tftp_data data; + struct tftp_ack ack; + struct tftp_error error; + struct tftp_oack oack; +}; + +extern void tftp_set_request_blksize ( unsigned int blksize ); + +#endif /* _GPXE_TFTP_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/threewire.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/threewire.h new file mode 100644 index 0000000..e23284a --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/threewire.h @@ -0,0 +1,105 @@ +#ifndef _GPXE_THREEWIRE_H +#define _GPXE_THREEWIRE_H + +/** @file + * + * Three-wire serial interface + * + * The Atmel three-wire interface is a subset of the (newer) SPI + * interface, and is implemented here as a layer on top of the SPI + * support. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/spi.h> +#include <limits.h> + +/** + * @defgroup tcmds Three-wire commands + * @{ + */ + +/** Read data from memory array */ +#define THREEWIRE_READ 0x6 + +/** Write data to memory array */ +#define THREEWIRE_WRITE 0x5 + +/** Write enable */ +#define THREEWIRE_EWEN 0x4 + +/** Address to be used for write enable command */ +#define THREEWIRE_EWEN_ADDRESS INT_MAX + +/** Time to wait for write cycles to complete + * + * This is sufficient for AT93C46/AT93C56 devices, but may need to be + * increased in future when other devices are added. + */ +#define THREEWIRE_WRITE_MDELAY 10 + +/** @} */ + +extern int threewire_read ( struct nvs_device *nvs, unsigned int address, + void *data, size_t len ); +extern int threewire_write ( struct nvs_device *nvs, unsigned int address, + const void *data, size_t len ); +extern int threewire_detect_address_len ( struct spi_device *device ); + +/** + * @defgroup tdevs Three-wire device types + * @{ + */ + +static inline __attribute__ (( always_inline )) void +init_at93cx6 ( struct spi_device *device, unsigned int organisation ) { + device->nvs.word_len_log2 = ( ( organisation == 8 ) ? 0 : 1 ); + device->nvs.block_size = 1; + device->command_len = 3, + device->nvs.read = threewire_read; + device->nvs.write = threewire_write; +} + +/** + * Initialise Atmel AT93C46 serial EEPROM + * + * @v device SPI device + * @v organisation Word organisation (8 or 16) + */ +static inline __attribute__ (( always_inline )) void +init_at93c46 ( struct spi_device *device, unsigned int organisation ) { + device->nvs.size = ( 1024 / organisation ); + device->address_len = ( ( organisation == 8 ) ? 7 : 6 ); + init_at93cx6 ( device, organisation ); +} + +/** + * Initialise Atmel AT93C56 serial EEPROM + * + * @v device SPI device + * @v organisation Word organisation (8 or 16) + */ +static inline __attribute__ (( always_inline )) void +init_at93c56 ( struct spi_device *device, unsigned int organisation ) { + device->nvs.size = ( 2048 / organisation ); + device->address_len = ( ( organisation == 8 ) ? 9 : 8 ); + init_at93cx6 ( device, organisation ); +} + +/** + * Initialise Atmel AT93C66 serial EEPROM + * + * @v device SPI device + * @v organisation Word organisation (8 or 16) + */ +static inline __attribute__ (( always_inline )) void +init_at93c66 ( struct spi_device *device, unsigned int organisation ) { + device->nvs.size = ( 4096 / organisation ); + device->address_len = ( ( organisation == 8 ) ? 9 : 8 ); + init_at93cx6 ( device, organisation ); +} + +/** @} */ + +#endif /* _GPXE_THREEWIRE_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/tls.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tls.h new file mode 100644 index 0000000..e2da046 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/tls.h @@ -0,0 +1,187 @@ +#ifndef _GPXE_TLS_H +#define _GPXE_TLS_H + +/** + * @file + * + * Transport Layer Security Protocol + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <gpxe/refcnt.h> +#include <gpxe/filter.h> +#include <gpxe/process.h> +#include <gpxe/crypto.h> +#include <gpxe/md5.h> +#include <gpxe/sha1.h> +#include <gpxe/x509.h> + +/** A TLS header */ +struct tls_header { + /** Content type + * + * This is a TLS_TYPE_XXX constant + */ + uint8_t type; + /** Protocol version + * + * This is a TLS_VERSION_XXX constant + */ + uint16_t version; + /** Length of payload */ + uint16_t length; +} __attribute__ (( packed )); + +/** TLS version 1.0 */ +#define TLS_VERSION_TLS_1_0 0x0301 + +/** TLS version 1.1 */ +#define TLS_VERSION_TLS_1_1 0x0302 + +/** Change cipher content type */ +#define TLS_TYPE_CHANGE_CIPHER 20 + +/** Alert content type */ +#define TLS_TYPE_ALERT 21 + +/** Handshake content type */ +#define TLS_TYPE_HANDSHAKE 22 + +/** Application data content type */ +#define TLS_TYPE_DATA 23 + +/* Handshake message types */ +#define TLS_HELLO_REQUEST 0 +#define TLS_CLIENT_HELLO 1 +#define TLS_SERVER_HELLO 2 +#define TLS_CERTIFICATE 11 +#define TLS_SERVER_KEY_EXCHANGE 12 +#define TLS_CERTIFICATE_REQUEST 13 +#define TLS_SERVER_HELLO_DONE 14 +#define TLS_CERTIFICATE_VERIFY 15 +#define TLS_CLIENT_KEY_EXCHANGE 16 +#define TLS_FINISHED 20 + +/* TLS alert levels */ +#define TLS_ALERT_WARNING 1 +#define TLS_ALERT_FATAL 2 + +/* TLS cipher specifications */ +#define TLS_RSA_WITH_NULL_MD5 0x0001 +#define TLS_RSA_WITH_NULL_SHA 0x0002 +#define TLS_RSA_WITH_AES_128_CBC_SHA 0x002f +#define TLS_RSA_WITH_AES_256_CBC_SHA 0x0035 + +/** TLS RX state machine state */ +enum tls_rx_state { + TLS_RX_HEADER = 0, + TLS_RX_DATA, +}; + +/** TLS TX state machine state */ +enum tls_tx_state { + TLS_TX_NONE = 0, + TLS_TX_CLIENT_HELLO, + TLS_TX_CLIENT_KEY_EXCHANGE, + TLS_TX_CHANGE_CIPHER, + TLS_TX_FINISHED, + TLS_TX_DATA +}; + +/** A TLS cipher specification */ +struct tls_cipherspec { + /** Public-key encryption algorithm */ + struct pubkey_algorithm *pubkey; + /** Bulk encryption cipher algorithm */ + struct cipher_algorithm *cipher; + /** MAC digest algorithm */ + struct digest_algorithm *digest; + /** Key length */ + size_t key_len; + /** Dynamically-allocated storage */ + void *dynamic; + /** Public key encryption context */ + void *pubkey_ctx; + /** Bulk encryption cipher context */ + void *cipher_ctx; + /** Next bulk encryption cipher context (TX only) */ + void *cipher_next_ctx; + /** MAC secret */ + void *mac_secret; +}; + +/** TLS pre-master secret */ +struct tls_pre_master_secret { + /** TLS version */ + uint16_t version; + /** Random data */ + uint8_t random[46]; +} __attribute__ (( packed )); + +/** TLS client random data */ +struct tls_client_random { + /** GMT Unix time */ + uint32_t gmt_unix_time; + /** Random data */ + uint8_t random[28]; +} __attribute__ (( packed )); + +/** A TLS session */ +struct tls_session { + /** Reference counter */ + struct refcnt refcnt; + + /** Plaintext stream */ + struct xfer_filter_half plainstream; + /** Ciphertext stream */ + struct xfer_filter_half cipherstream; + + /** Current TX cipher specification */ + struct tls_cipherspec tx_cipherspec; + /** Next TX cipher specification */ + struct tls_cipherspec tx_cipherspec_pending; + /** Current RX cipher specification */ + struct tls_cipherspec rx_cipherspec; + /** Next RX cipher specification */ + struct tls_cipherspec rx_cipherspec_pending; + /** Premaster secret */ + struct tls_pre_master_secret pre_master_secret; + /** Master secret */ + uint8_t master_secret[48]; + /** Server random bytes */ + uint8_t server_random[32]; + /** Client random bytes */ + struct tls_client_random client_random; + /** MD5 context for handshake verification */ + uint8_t handshake_md5_ctx[MD5_CTX_SIZE]; + /** SHA1 context for handshake verification */ + uint8_t handshake_sha1_ctx[SHA1_CTX_SIZE]; + + /** Hack: server RSA public key */ + struct x509_rsa_public_key rsa; + + /** TX sequence number */ + uint64_t tx_seq; + /** TX state */ + enum tls_tx_state tx_state; + /** TX process */ + struct process process; + + /** RX sequence number */ + uint64_t rx_seq; + /** RX state */ + enum tls_rx_state rx_state; + /** Offset within current RX state */ + size_t rx_rcvd; + /** Current received record header */ + struct tls_header rx_header; + /** Current received raw data buffer */ + void *rx_data; +}; + +extern int add_tls ( struct xfer_interface *xfer, + struct xfer_interface **next ); + +#endif /* _GPXE_TLS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/uaccess.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/uaccess.h new file mode 100644 index 0000000..5a8f292 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/uaccess.h @@ -0,0 +1,344 @@ +#ifndef _GPXE_UACCESS_H +#define _GPXE_UACCESS_H + +/** + * @file + * + * Access to external ("user") memory + * + * gPXE often needs to transfer data between internal and external + * buffers. On i386, the external buffers may require access via a + * different segment, and the buffer address cannot be encoded into a + * simple void * pointer. The @c userptr_t type encapsulates the + * information needed to identify an external buffer, and the + * copy_to_user() and copy_from_user() functions provide methods for + * transferring data between internal and external buffers. + * + * Note that userptr_t is an opaque type; in particular, performing + * arithmetic upon a userptr_t is not allowed. + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <string.h> +#include <gpxe/api.h> +#include <config/ioapi.h> + +/** + * A pointer to a user buffer + * + */ +typedef unsigned long userptr_t; + +/** Equivalent of NULL for user pointers */ +#define UNULL ( ( userptr_t ) 0 ) + +/** + * @defgroup uaccess_trivial Trivial user access API implementations + * + * User access API implementations that can be used by environments in + * which virtual addresses allow access to all of memory. + * + * @{ + * + */ + +/** + * Convert virtual address to user pointer + * + * @v addr Virtual address + * @ret userptr User pointer + */ +static inline __always_inline userptr_t +trivial_virt_to_user ( volatile const void *addr ) { + return ( ( userptr_t ) addr ); +} + +/** + * Convert user pointer to virtual address + * + * @v userptr User pointer + * @v offset Offset from user pointer + * @ret addr Virtual address + * + * This operation is not available under all memory models. + */ +static inline __always_inline void * +trivial_user_to_virt ( userptr_t userptr, off_t offset ) { + return ( ( void * ) userptr + offset ); +} + +/** + * Add offset to user pointer + * + * @v userptr User pointer + * @v offset Offset + * @ret userptr New pointer value + */ +static inline __always_inline userptr_t +trivial_userptr_add ( userptr_t userptr, off_t offset ) { + return ( userptr + offset ); +} + +/** + * Copy data between user buffers + * + * @v dest Destination + * @v dest_off Destination offset + * @v src Source + * @v src_off Source offset + * @v len Length + */ +static inline __always_inline void +trivial_memcpy_user ( userptr_t dest, off_t dest_off, + userptr_t src, off_t src_off, size_t len ) { + memcpy ( ( ( void * ) dest + dest_off ), + ( ( void * ) src + src_off ), len ); +} + +/** + * Copy data between user buffers, allowing for overlap + * + * @v dest Destination + * @v dest_off Destination offset + * @v src Source + * @v src_off Source offset + * @v len Length + */ +static inline __always_inline void +trivial_memmove_user ( userptr_t dest, off_t dest_off, + userptr_t src, off_t src_off, size_t len ) { + memmove ( ( ( void * ) dest + dest_off ), + ( ( void * ) src + src_off ), len ); +} + +/** + * Fill user buffer with a constant byte + * + * @v buffer User buffer + * @v offset Offset within buffer + * @v c Constant byte with which to fill + * @v len Length + */ +static inline __always_inline void +trivial_memset_user ( userptr_t buffer, off_t offset, int c, size_t len ) { + memset ( ( ( void * ) buffer + offset ), c, len ); +} + +/** + * Find length of NUL-terminated string in user buffer + * + * @v buffer User buffer + * @v offset Offset within buffer + * @ret len Length of string (excluding NUL) + */ +static inline __always_inline size_t +trivial_strlen_user ( userptr_t buffer, off_t offset ) { + return strlen ( ( void * ) buffer + offset ); +} + +/** + * Find character in user buffer + * + * @v buffer User buffer + * @v offset Starting offset within buffer + * @v c Character to search for + * @v len Length of user buffer + * @ret offset Offset of character, or <0 if not found + */ +static inline __always_inline off_t +trivial_memchr_user ( userptr_t buffer, off_t offset, int c, size_t len ) { + void *found; + + found = memchr ( ( ( void * ) buffer + offset ), c, len ); + return ( found ? ( found - ( void * ) buffer ) : -1 ); +} + +/** @} */ + +/** + * Calculate static inline user access API function name + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @ret _subsys_func Subsystem API function + */ +#define UACCESS_INLINE( _subsys, _api_func ) \ + SINGLE_API_INLINE ( UACCESS_PREFIX_ ## _subsys, _api_func ) + +/** + * Provide an user access API implementation + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @v _func Implementing function + */ +#define PROVIDE_UACCESS( _subsys, _api_func, _func ) \ + PROVIDE_SINGLE_API ( UACCESS_PREFIX_ ## _subsys, _api_func, _func ) + +/** + * Provide a static inline user access API implementation + * + * @v _prefix Subsystem prefix + * @v _api_func API function + */ +#define PROVIDE_UACCESS_INLINE( _subsys, _api_func ) \ + PROVIDE_SINGLE_API_INLINE ( UACCESS_PREFIX_ ## _subsys, _api_func ) + +/* Include all architecture-independent user access API headers */ +#include <gpxe/efi/efi_uaccess.h> + +/* Include all architecture-dependent user access API headers */ +#include <bits/uaccess.h> + +/** + * Convert physical address to user pointer + * + * @v phys_addr Physical address + * @ret userptr User pointer + */ +userptr_t phys_to_user ( unsigned long phys_addr ); + +/** + * Convert user pointer to physical address + * + * @v userptr User pointer + * @v offset Offset from user pointer + * @ret phys_addr Physical address + */ +unsigned long user_to_phys ( userptr_t userptr, off_t offset ); + +/** + * Convert virtual address to user pointer + * + * @v addr Virtual address + * @ret userptr User pointer + */ +userptr_t virt_to_user ( volatile const void *addr ); + +/** + * Convert user pointer to virtual address + * + * @v userptr User pointer + * @v offset Offset from user pointer + * @ret addr Virtual address + * + * This operation is not available under all memory models. + */ +void * user_to_virt ( userptr_t userptr, off_t offset ); + +/** + * Add offset to user pointer + * + * @v userptr User pointer + * @v offset Offset + * @ret userptr New pointer value + */ +userptr_t userptr_add ( userptr_t userptr, off_t offset ); + +/** + * Convert virtual address to a physical address + * + * @v addr Virtual address + * @ret phys_addr Physical address + */ +static inline __always_inline unsigned long +virt_to_phys ( volatile const void *addr ) { + return user_to_phys ( virt_to_user ( addr ), 0 ); +} + +/** + * Convert physical address to a virtual address + * + * @v addr Virtual address + * @ret phys_addr Physical address + * + * This operation is not available under all memory models. + */ +static inline __always_inline void * phys_to_virt ( unsigned long phys_addr ) { + return user_to_virt ( phys_to_user ( phys_addr ), 0 ); +} + +/** + * Copy data between user buffers + * + * @v dest Destination + * @v dest_off Destination offset + * @v src Source + * @v src_off Source offset + * @v len Length + */ +void memcpy_user ( userptr_t dest, off_t dest_off, + userptr_t src, off_t src_off, size_t len ); + +/** + * Copy data to user buffer + * + * @v dest Destination + * @v dest_off Destination offset + * @v src Source + * @v len Length + */ +static inline __always_inline void +copy_to_user ( userptr_t dest, off_t dest_off, const void *src, size_t len ) { + memcpy_user ( dest, dest_off, virt_to_user ( src ), 0, len ); +} + +/** + * Copy data from user buffer + * + * @v dest Destination + * @v src Source + * @v src_off Source offset + * @v len Length + */ +static inline __always_inline void +copy_from_user ( void *dest, userptr_t src, off_t src_off, size_t len ) { + memcpy_user ( virt_to_user ( dest ), 0, src, src_off, len ); +} + +/** + * Copy data between user buffers, allowing for overlap + * + * @v dest Destination + * @v dest_off Destination offset + * @v src Source + * @v src_off Source offset + * @v len Length + */ +void memmove_user ( userptr_t dest, off_t dest_off, + userptr_t src, off_t src_off, size_t len ); + +/** + * Fill user buffer with a constant byte + * + * @v userptr User buffer + * @v offset Offset within buffer + * @v c Constant byte with which to fill + * @v len Length + */ +void memset_user ( userptr_t userptr, off_t offset, int c, size_t len ); + +/** + * Find length of NUL-terminated string in user buffer + * + * @v userptr User buffer + * @v offset Offset within buffer + * @ret len Length of string (excluding NUL) + */ +size_t strlen_user ( userptr_t userptr, off_t offset ); + +/** + * Find character in user buffer + * + * @v userptr User buffer + * @v offset Starting offset within buffer + * @v c Character to search for + * @v len Length of user buffer + * @ret offset Offset of character, or <0 if not found + */ +off_t memchr_user ( userptr_t userptr, off_t offset, int c, size_t len ); + +#endif /* _GPXE_UACCESS_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/udp.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/udp.h new file mode 100644 index 0000000..670c5e5 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/udp.h @@ -0,0 +1,48 @@ +#ifndef _GPXE_UDP_H +#define _GPXE_UDP_H + +/** @file + * + * UDP protocol + * + * This file defines the gPXE UDP API. + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stddef.h> +#include <gpxe/iobuf.h> +#include <gpxe/tcpip.h> +#include <gpxe/if_ether.h> + +struct xfer_interface; + +/** + * UDP constants + */ + +#define UDP_MAX_HLEN 72 +#define UDP_MAX_TXIOB ETH_MAX_MTU +#define UDP_MIN_TXIOB ETH_ZLEN + +/** + * A UDP header + */ +struct udp_header { + /** Source port */ + uint16_t src; + /** Destination port */ + uint16_t dest; + /** Length */ + uint16_t len; + /** Checksum */ + uint16_t chksum; +}; + +extern int udp_open_promisc ( struct xfer_interface *xfer ); +extern int udp_open ( struct xfer_interface *xfer, struct sockaddr *peer, + struct sockaddr *local ); + +#endif /* _GPXE_UDP_H */ + diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/umalloc.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/umalloc.h new file mode 100644 index 0000000..b0e5564 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/umalloc.h @@ -0,0 +1,68 @@ +#ifndef _GPXE_UMALLOC_H +#define _GPXE_UMALLOC_H + +/** + * @file + * + * User memory allocation + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <gpxe/api.h> +#include <config/umalloc.h> +#include <gpxe/uaccess.h> + +/** + * Provide a user memory allocation API implementation + * + * @v _prefix Subsystem prefix + * @v _api_func API function + * @v _func Implementing function + */ +#define PROVIDE_UMALLOC( _subsys, _api_func, _func ) \ + PROVIDE_SINGLE_API ( UMALLOC_PREFIX_ ## _subsys, _api_func, _func ) + +/* Include all architecture-independent I/O API headers */ +#include <gpxe/efi/efi_umalloc.h> + +/* Include all architecture-dependent I/O API headers */ +#include <bits/umalloc.h> + +/** + * Reallocate external memory + * + * @v userptr Memory previously allocated by umalloc(), or UNULL + * @v new_size Requested size + * @ret userptr Allocated memory, or UNULL + * + * Calling realloc() with a new size of zero is a valid way to free a + * memory block. + */ +userptr_t urealloc ( userptr_t userptr, size_t new_size ); + +/** + * Allocate external memory + * + * @v size Requested size + * @ret userptr Memory, or UNULL + * + * Memory is guaranteed to be aligned to a page boundary. + */ +static inline __always_inline userptr_t umalloc ( size_t size ) { + return urealloc ( UNULL, size ); +} + +/** + * Free external memory + * + * @v userptr Memory allocated by umalloc(), or UNULL + * + * If @c ptr is UNULL, no action is taken. + */ +static inline __always_inline void ufree ( userptr_t userptr ) { + urealloc ( userptr, 0 ); +} + +#endif /* _GPXE_UMALLOC_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/uri.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/uri.h new file mode 100644 index 0000000..03c88d2 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/uri.h @@ -0,0 +1,144 @@ +#ifndef _GPXE_URI_H +#define _GPXE_URI_H + +/** @file + * + * Uniform Resource Identifiers + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stddef.h> +#include <stdlib.h> +#include <gpxe/refcnt.h> + +/** A Uniform Resource Identifier + * + * Terminology for this data structure is as per uri(7), except that + * "path" is defined to include the leading '/' for an absolute path. + * + * Note that all fields within a URI are optional and may be NULL. + * + * Some examples are probably helpful: + * + * http://www.etherboot.org/wiki : + * + * scheme = "http", host = "www.etherboot.org", path = "/wiki" + * + * /var/lib/tftpboot : + * + * path = "/var/lib/tftpboot" + * + * mailto:bob@nowhere.com : + * + * scheme = "mailto", opaque = "bob@nowhere.com" + * + * ftp://joe:secret@insecure.org:8081/hidden/path/to?what=is#this + * + * scheme = "ftp", user = "joe", password = "secret", + * host = "insecure.org", port = "8081", path = "/hidden/path/to", + * query = "what=is", fragment = "this" + */ +struct uri { + /** Reference count */ + struct refcnt refcnt; + /** Scheme */ + const char *scheme; + /** Opaque part */ + const char *opaque; + /** User name */ + const char *user; + /** Password */ + const char *password; + /** Host name */ + const char *host; + /** Port number */ + const char *port; + /** Path */ + const char *path; + /** Query */ + const char *query; + /** Fragment */ + const char *fragment; +}; + +/** + * URI is an absolute URI + * + * @v uri URI + * @ret is_absolute URI is absolute + * + * An absolute URI begins with a scheme, e.g. "http:" or "mailto:". + * Note that this is a separate concept from a URI with an absolute + * path. + */ +static inline int uri_is_absolute ( struct uri *uri ) { + return ( uri->scheme != NULL ); +} + +/** + * URI has an absolute path + * + * @v uri URI + * @ret has_absolute_path URI has an absolute path + * + * An absolute path begins with a '/'. Note that this is a separate + * concept from an absolute URI. Note also that a URI may not have a + * path at all. + */ +static inline int uri_has_absolute_path ( struct uri *uri ) { + return ( uri->path && ( uri->path[0] == '/' ) ); +} + +/** + * URI has a relative path + * + * @v uri URI + * @ret has_relative_path URI has a relative path + * + * A relative path begins with something other than a '/'. Note that + * this is a separate concept from a relative URI. Note also that a + * URI may not have a path at all. + */ +static inline int uri_has_relative_path ( struct uri *uri ) { + return ( uri->path && ( uri->path[0] != '/' ) ); +} + +/** + * Increment URI reference count + * + * @v uri URI, or NULL + * @ret uri URI as passed in + */ +static inline __attribute__ (( always_inline )) struct uri * +uri_get ( struct uri *uri ) { + ref_get ( &uri->refcnt ); + return uri; +} + +/** + * Decrement URI reference count + * + * @v uri URI, or NULL + */ +static inline __attribute__ (( always_inline )) void +uri_put ( struct uri *uri ) { + ref_put ( &uri->refcnt ); +} + +extern struct uri *cwuri; + +extern struct uri * parse_uri ( const char *uri_string ); +extern unsigned int uri_port ( struct uri *uri, unsigned int default_port ); +extern int unparse_uri ( char *buf, size_t size, struct uri *uri ); +extern struct uri * uri_dup ( struct uri *uri ); +extern char * resolve_path ( const char *base_path, + const char *relative_path ); +extern struct uri * resolve_uri ( struct uri *base_uri, + struct uri *relative_uri ); +extern void churi ( struct uri *uri ); +extern size_t uri_encode ( const char *raw_string, char *buf, size_t len ); +extern size_t uri_decode ( const char *encoded_string, char *buf, size_t len ); + +#endif /* _GPXE_URI_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/uuid.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/uuid.h new file mode 100644 index 0000000..019cd05 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/uuid.h @@ -0,0 +1,33 @@ +#ifndef _GPXE_UUID_H +#define _GPXE_UUID_H + +/** @file + * + * Universally unique IDs + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +/** A universally unique ID */ +union uuid { + /** Canonical form (00000000-0000-0000-0000-000000000000) */ + struct { + /** 8 hex digits, big-endian */ + uint32_t a; + /** 2 hex digits, big-endian */ + uint16_t b; + /** 2 hex digits, big-endian */ + uint16_t c; + /** 2 hex digits, big-endian */ + uint16_t d; + /** 12 hex digits, big-endian */ + uint8_t e[6]; + } canonical; + uint8_t raw[16]; +}; + +extern char * uuid_ntoa ( union uuid *uuid ); + +#endif /* _GPXE_UUID_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/x509.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/x509.h new file mode 100644 index 0000000..1b9d9aa --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/x509.h @@ -0,0 +1,41 @@ +#ifndef _GPXE_X509_H +#define _GPXE_X509_H + +/** @file + * + * X.509 certificates + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> + +struct asn1_cursor; + +/** An X.509 RSA public key */ +struct x509_rsa_public_key { + /** Modulus */ + uint8_t *modulus; + /** Modulus length */ + size_t modulus_len; + /** Exponent */ + uint8_t *exponent; + /** Exponent length */ + size_t exponent_len; +}; + +/** + * Free X.509 RSA public key + * + * @v rsa_pubkey RSA public key + */ +static inline void +x509_free_rsa_public_key ( struct x509_rsa_public_key *rsa_pubkey ) { + free ( rsa_pubkey->modulus ); +} + +extern int x509_rsa_public_key ( const struct asn1_cursor *certificate, + struct x509_rsa_public_key *rsa_pubkey ); + +#endif /* _GPXE_X509_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/gpxe/xfer.h b/debian/grub-extras/disabled/gpxe/src/include/gpxe/xfer.h new file mode 100644 index 0000000..edd3703 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/gpxe/xfer.h @@ -0,0 +1,277 @@ +#ifndef _GPXE_XFER_H +#define _GPXE_XFER_H + +/** @file + * + * Data transfer interfaces + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stddef.h> +#include <stdarg.h> +#include <gpxe/interface.h> +#include <gpxe/iobuf.h> + +struct xfer_interface; +struct xfer_metadata; + +/** Data transfer interface operations */ +struct xfer_interface_operations { + /** Close interface + * + * @v xfer Data transfer interface + * @v rc Reason for close + */ + void ( * close ) ( struct xfer_interface *xfer, int rc ); + /** Redirect to new location + * + * @v xfer Data transfer interface + * @v type New location type + * @v args Remaining arguments depend upon location type + * @ret rc Return status code + */ + int ( * vredirect ) ( struct xfer_interface *xfer, int type, + va_list args ); + /** Check flow control window + * + * @v xfer Data transfer interface + * @ret len Length of window + * + * Flow control is regarded as advisory but not mandatory. + * Users who have control over their own rate of data + * generation should perform a flow control check before + * generating new data. Users who have no control (such as + * NIC drivers or filter layers) are not obliged to check. + * + * Data transfer interfaces must be prepared to accept + * datagrams even if they are advertising a window of zero + * bytes. + */ + size_t ( * window ) ( struct xfer_interface *xfer ); + /** Allocate I/O buffer + * + * @v xfer Data transfer interface + * @v len I/O buffer payload length + * @ret iobuf I/O buffer + */ + struct io_buffer * ( * alloc_iob ) ( struct xfer_interface *xfer, + size_t len ); + /** Deliver datagram as I/O buffer with metadata + * + * @v xfer Data transfer interface + * @v iobuf Datagram I/O buffer + * @v meta Data transfer metadata + * @ret rc Return status code + * + * A data transfer interface that wishes to support only raw + * data delivery should set this method to + * xfer_deliver_as_raw(). + */ + int ( * deliver_iob ) ( struct xfer_interface *xfer, + struct io_buffer *iobuf, + struct xfer_metadata *meta ); + /** Deliver datagram as raw data + * + * @v xfer Data transfer interface + * @v data Data buffer + * @v len Length of data buffer + * @ret rc Return status code + * + * A data transfer interface that wishes to support only I/O + * buffer delivery should set this method to + * xfer_deliver_as_iob(). + */ + int ( * deliver_raw ) ( struct xfer_interface *xfer, + const void *data, size_t len ); +}; + +/** A data transfer interface */ +struct xfer_interface { + /** Generic object communication interface */ + struct interface intf; + /** Operations for received messages */ + struct xfer_interface_operations *op; +}; + +/** Basis positions for seek() events */ +enum seek_whence { + SEEK_CUR = 0, + SEEK_SET, +}; + +/** Data transfer metadata */ +struct xfer_metadata { + /** Position of data within stream */ + off_t offset; + /** Basis for data position + * + * Must be one of @c SEEK_CUR or @c SEEK_SET. + */ + int whence; + /** Source socket address, or NULL */ + struct sockaddr *src; + /** Destination socket address, or NULL */ + struct sockaddr *dest; + /** Network device, or NULL */ + struct net_device *netdev; +}; + +/** + * Describe seek basis + * + * @v whence Basis for new position + */ +static inline __attribute__ (( always_inline )) const char * +whence_text ( int whence ) { + switch ( whence ) { + case SEEK_CUR: return "CUR"; + case SEEK_SET: return "SET"; + default: return "INVALID"; + } +} + +extern struct xfer_interface null_xfer; +extern struct xfer_interface_operations null_xfer_ops; + +extern void xfer_close ( struct xfer_interface *xfer, int rc ); +extern int xfer_vredirect ( struct xfer_interface *xfer, int type, + va_list args ); +extern int xfer_redirect ( struct xfer_interface *xfer, int type, ... ); +extern size_t xfer_window ( struct xfer_interface *xfer ); +extern struct io_buffer * xfer_alloc_iob ( struct xfer_interface *xfer, + size_t len ); +extern int xfer_deliver_iob ( struct xfer_interface *xfer, + struct io_buffer *iobuf ); +extern int xfer_deliver_iob_meta ( struct xfer_interface *xfer, + struct io_buffer *iobuf, + struct xfer_metadata *meta ); +extern int xfer_deliver_raw ( struct xfer_interface *xfer, + const void *data, size_t len ); +extern int xfer_vprintf ( struct xfer_interface *xfer, + const char *format, va_list args ); +extern int __attribute__ (( format ( printf, 2, 3 ) )) +xfer_printf ( struct xfer_interface *xfer, const char *format, ... ); +extern int xfer_seek ( struct xfer_interface *xfer, off_t offset, int whence ); + +extern void ignore_xfer_close ( struct xfer_interface *xfer, int rc ); +extern int ignore_xfer_vredirect ( struct xfer_interface *xfer, + int type, va_list args ); +extern size_t unlimited_xfer_window ( struct xfer_interface *xfer ); +extern size_t no_xfer_window ( struct xfer_interface *xfer ); +extern struct io_buffer * default_xfer_alloc_iob ( struct xfer_interface *xfer, + size_t len ); +extern int xfer_deliver_as_raw ( struct xfer_interface *xfer, + struct io_buffer *iobuf, + struct xfer_metadata *meta ); +extern int xfer_deliver_as_iob ( struct xfer_interface *xfer, + const void *data, size_t len ); +extern int ignore_xfer_deliver_raw ( struct xfer_interface *xfer, + const void *data __unused, size_t len ); + +/** + * Initialise a data transfer interface + * + * @v xfer Data transfer interface + * @v op Data transfer interface operations + * @v refcnt Containing object reference counter, or NULL + */ +static inline void xfer_init ( struct xfer_interface *xfer, + struct xfer_interface_operations *op, + struct refcnt *refcnt ) { + xfer->intf.dest = &null_xfer.intf; + xfer->intf.refcnt = refcnt; + xfer->op = op; +} + +/** + * Initialise a static data transfer interface + * + * @v operations Data transfer interface operations + */ +#define XFER_INIT( operations ) { \ + .intf = { \ + .dest = &null_xfer.intf, \ + .refcnt = NULL, \ + }, \ + .op = operations, \ + } + +/** + * Get data transfer interface from generic object communication interface + * + * @v intf Generic object communication interface + * @ret xfer Data transfer interface + */ +static inline __attribute__ (( always_inline )) struct xfer_interface * +intf_to_xfer ( struct interface *intf ) { + return container_of ( intf, struct xfer_interface, intf ); +} + +/** + * Get reference to destination data transfer interface + * + * @v xfer Data transfer interface + * @ret dest Destination interface + */ +static inline __attribute__ (( always_inline )) struct xfer_interface * +xfer_get_dest ( struct xfer_interface *xfer ) { + return intf_to_xfer ( intf_get ( xfer->intf.dest ) ); +} + +/** + * Drop reference to data transfer interface + * + * @v xfer Data transfer interface + */ +static inline __attribute__ (( always_inline )) void +xfer_put ( struct xfer_interface *xfer ) { + intf_put ( &xfer->intf ); +} + +/** + * Plug a data transfer interface into a new destination interface + * + * @v xfer Data transfer interface + * @v dest New destination interface + */ +static inline __attribute__ (( always_inline )) void +xfer_plug ( struct xfer_interface *xfer, struct xfer_interface *dest ) { + plug ( &xfer->intf, &dest->intf ); +} + +/** + * Plug two data transfer interfaces together + * + * @v a Data transfer interface A + * @v b Data transfer interface B + */ +static inline __attribute__ (( always_inline )) void +xfer_plug_plug ( struct xfer_interface *a, struct xfer_interface *b ) { + plug_plug ( &a->intf, &b->intf ); +} + +/** + * Unplug a data transfer interface + * + * @v xfer Data transfer interface + */ +static inline __attribute__ (( always_inline )) void +xfer_unplug ( struct xfer_interface *xfer ) { + plug ( &xfer->intf, &null_xfer.intf ); +} + +/** + * Stop using a data transfer interface + * + * @v xfer Data transfer interface + * + * After calling this method, no further messages will be received via + * the interface. + */ +static inline void xfer_nullify ( struct xfer_interface *xfer ) { + xfer->op = &null_xfer_ops; +}; + +#endif /* _GPXE_XFER_H */ diff --git a/debian/grub-extras/disabled/gpxe/src/include/nic.h b/debian/grub-extras/disabled/gpxe/src/include/nic.h new file mode 100644 index 0000000..7097068 --- /dev/null +++ b/debian/grub-extras/disabled/gpxe/src/include/nic.h @@ -0,0 +1,273 @@ + /* + * 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, or (at + * your option) any later version. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#ifndef NIC_H +#define NIC_H + +#include <stdint.h> +#include <string.h> +#include <stdio.h> +#include <byteswap.h> +#include <gpxe/pci.h> +#include <gpxe/isapnp.h> +#include <gpxe/isa.h> +#include <gpxe/eisa.h> +#include <gpxe/mca.h> +#include <gpxe/io.h> + +typedef enum { + DISABLE = 0, + ENABLE, + FORCE +} irq_action_t; + +typedef enum duplex { + HALF_DUPLEX = 1, + FULL_DUPLEX +} duplex_t; + +/* + * Structure returned from eth_probe and passed to other driver + * functions. + */ +struct nic { + struct nic_operations *nic_op; + int flags; /* driver specific flags */ + unsigned char *node_addr; + unsigned char *packet; + unsigned int packetlen; + unsigned int ioaddr; + unsigned char irqno; + unsigned int mbps; + duplex_t duplex; + void *priv_data; /* driver private data */ +}; + +struct nic_operations { + int ( *connect ) ( struct nic * ); + int ( *poll ) ( struct nic *, int retrieve ); + void ( *transmit ) ( struct nic *, const char *, + unsigned int, unsigned int, const char * ); + void ( *irq ) ( struct nic *, irq_action_t ); +}; + +extern struct nic nic; + +static inline int eth_poll ( int retrieve ) { + return nic.nic_op->poll ( &nic, retrieve ); +} + +static inline void eth_transmit ( const char *dest, unsigned int type, + unsigned int size, const void *packet ) { + nic.nic_op->transmit ( &nic, dest, type, size, packet ); +} + +/* + * Function prototypes + * + */ +extern int dummy_connect ( struct nic *nic ); +extern void dummy_irq ( struct nic *nic, irq_action_t irq_action ); +extern int legacy_probe ( void *hwdev, + void ( * set_drvdata ) ( void *hwdev, void *priv ), + struct device *dev, + int ( * probe ) ( struct nic *nic, void *hwdev ), + void ( * disable ) ( struct nic *nic, void *hwdev )); +void legacy_remove ( void *hwdev, + void * ( * get_drvdata ) ( void *hwdev ), + void ( * disable ) ( struct nic *nic, void *hwdev ) ); + +#define PCI_DRIVER(_name,_ids,_class) \ + static inline int \ + _name ## _pci_legacy_probe ( struct pci_device *pci, \ + const struct pci_device_id *id ); \ + static inline void \ + _name ## _pci_legacy_remove ( struct pci_device *pci ); \ + struct pci_driver _name __pci_driver = { \ + .ids = _ids, \ + .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \ + .probe = _name ## _pci_legacy_probe, \ + .remove = _name ## _pci_legacy_remove, \ + }; \ + REQUIRE_OBJECT ( pci ); + +static inline void legacy_pci_set_drvdata ( void *hwdev, void *priv ) { + pci_set_drvdata ( hwdev, priv ); +} +static inline void * legacy_pci_get_drvdata ( void *hwdev ) { + return pci_get_drvdata ( hwdev ); +} + +#define ISAPNP_DRIVER(_name,_ids) \ + static inline int \ + _name ## _isapnp_legacy_probe ( struct isapnp_device *isapnp, \ + const struct isapnp_device_id *id ); \ + static inline void \ + _name ## _isapnp_legacy_remove ( struct isapnp_device *isapnp ); \ + struct isapnp_driver _name __isapnp_driver = { \ + .ids = _ids, \ + .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \ + .probe = _name ## _isapnp_legacy_probe, \ + .remove = _name ## _isapnp_legacy_remove, \ + }; \ + REQUIRE_OBJECT ( isapnp ); + +static inline void legacy_isapnp_set_drvdata ( void *hwdev, void *priv ) { + isapnp_set_drvdata ( hwdev, priv ); +} +static inline void * legacy_isapnp_get_drvdata ( void *hwdev ) { + return isapnp_get_drvdata ( hwdev ); +} + +#define EISA_DRIVER(_name,_ids) \ + static inline int \ + _name ## _eisa_legacy_probe ( struct eisa_device *eisa, \ + const struct eisa_device_id *id ); \ + static inline void \ + _name ## _eisa_legacy_remove ( struct eisa_device *eisa ); \ + struct eisa_driver _name __eisa_driver = { \ + .ids = _ids, \ + .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \ + .probe = _name ## _eisa_legacy_probe, \ + .remove = _name ## _eisa_legacy_remove, \ + }; \ + REQUIRE_OBJECT ( eisa ); + +static inline void legacy_eisa_set_drvdata ( void *hwdev, void *priv ) { + eisa_set_drvdata ( hwdev, priv ); +} +static inline void * legacy_eisa_get_drvdata ( void *hwdev ) { + return eisa_get_drvdata ( hwdev ); +} + +#define MCA_DRIVER(_name,_ids) \ + static inline int \ + _name ## _mca_legacy_probe ( struct mca_device *mca, \ + const struct mca_device_id *id ); \ + static inline void \ + _name ## _mca_legacy_remove ( struct mca_device *mca ); \ + struct mca_driver _name __mca_driver = { \ + .ids = _ids, \ + .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \ + .probe = _name ## _mca_legacy_probe, \ + .remove = _name ## _mca_legacy_remove, \ + }; \ + REQUIRE_OBJECT ( mca ); + +static inline void legacy_mca_set_drvdata ( void *hwdev, void *priv ) { + mca_set_drvdata ( hwdev, priv ); +} +static inline void * legacy_mca_get_drvdata ( void *hwdev ) { + return mca_get_drvdata ( hwdev ); +} + +#define ISA_DRIVER(_name,_probe_addrs,_probe_addr,_vendor_id,_prod_id) \ + static inline int \ + _name ## _isa_legacy_probe ( struct isa_device *isa ); \ + static inline int \ + _name ## _isa_legacy_probe_at_addr ( struct isa_device *isa ) { \ + if ( ! _probe_addr ( isa->ioaddr ) ) \ + return -ENODEV; \ + return _name ## _isa_legacy_probe ( isa ); \ + } \ + static inline void \ + _name ## _isa_legacy_remove ( struct isa_device *isa ); \ + static const char _name ## _text[]; \ + struct isa_driver _name __isa_driver = { \ + .name = _name ## _text, \ + .probe_addrs = _probe_addrs, \ + .addr_count = ( sizeof ( _probe_addrs ) / \ + sizeof ( _probe_addrs[0] ) ), \ + .vendor_id = _vendor_id, \ + .prod_id = _prod_id, \ + .probe = _name ## _isa_legacy_probe_at_addr, \ + .remove = _name ## _isa_legacy_remove, \ + }; \ + REQUIRE_OBJECT ( isa ); + +static inline void legacy_isa_set_drvdata ( void *hwdev, void *priv ) { + isa_set_drvdata ( hwdev, priv ); +} +static inline void * legacy_isa_get_drvdata ( void *hwdev ) { + return isa_get_drvdata ( hwdev ); +} + +#undef DRIVER +#define DRIVER(_name_text,_unused2,_unused3,_name,_probe,_disable) \ + static const char _name ## _text[] = _name_text; \ + static inline int \ + _name ## _probe ( struct nic *nic, void *hwdev ) { \ + return _probe ( nic, hwdev ); \ + } \ + static inline void \ + _name ## _disable ( struct nic *nic, void *hwdev ) { \ + void ( * _unsafe_disable ) () = _disable; \ + _unsafe_disable ( nic, hwdev ); \ + } \ + static inline int \ + _name ## _pci_legacy_probe ( struct pci_device *pci, \ + const struct pci_device_id *id __unused ) { \ + return legacy_probe ( pci, legacy_pci_set_drvdata, \ + (void *) &pci->dev, _name ## _probe, \ + _name ## _disable ); \ + } \ + static inline void \ + _name ## _pci_legacy_remove ( struct pci_device *pci ) { \ + return legacy_remove ( pci, legacy_pci_get_drvdata, \ + _name ## _disable ); \ + } \ + static inline int \ + _name ## _isapnp_legacy_probe ( struct isapnp_device *isapnp, \ + const struct isapnp_device_id *id __unused ) { \ + return legacy_probe ( isapnp, legacy_isapnp_set_drvdata, \ + &isapnp->dev, _name ## _probe, \ + _name ## _disable ); \ + } \ + static inline void \ + _name ## _isapnp_legacy_remove ( struct isapnp_device *isapnp ) { \ + return legacy_remove ( isapnp, legacy_isapnp_get_drvdata, \ + _name ## _disable ); \ + } \ + static inline int \ + _name ## _eisa_legacy_probe ( struct eisa_device *eisa, \ + const struct eisa_device_id *id __unused ) { \ + return legacy_probe ( eisa, legacy_eisa_set_drvdata, \ + &eisa->dev, _name ## _probe, \ + _name ## _disable ); \ + } \ + static inline void \ + _name ## _eisa_legacy_remove ( struct eisa_device *eisa ) { \ + return legacy_remove ( eisa, legacy_eisa_get_drvdata, \ + _name ## _disable ); \ + } \ + static inline int \ + _name ## _mca_legacy_probe ( struct mca_device *mca, \ + const struct mca_device_id *id __unused ) { \ + return legacy_probe ( mca, legacy_mca_set_drvdata, \ + &mca->dev, _name ## _probe, \ + _name ## _disable ); \ + } \ + static inline void \ + _name ## _mca_legacy_remove ( struct mca_device *mca ) { \ + return legacy_remove ( mca, legacy_mca_get_drvdata, \ + _name ## _disable ); \ + } \ + static inline int \ + _name ## _isa_legacy_probe ( struct isa_device *isa ) { \ + return legacy_probe ( isa, legacy_isa_set_drvdata, \ + &isa->dev, _name ## _probe, \ + _name ## _disable ); \ + } \ + static inline void \ + _name ## _isa_legacy_remove ( struct isa_device *isa ) { \ + return legacy_remove ( isa, legacy_isa_get_drvdata, \ + _name ## _disable ); \ + } + +#endif /* NIC_H */ |