/
githubmirror
/
ipxe
Обзор
Документация
Войти
/
githubmirror
/
ipxe
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
v2.0.0
src/net/peerdisc.c
666 строк
18 KB
Michael Brown
[build] Mark known reviewed files as permitted for UEFI Secure Boot
14 янв 2026, 19:10
14 янв 2026, 19:10
adcaaf9
Код
Авторство
О чём код?
/* * Copyright (C) 2015 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 (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., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301, USA. * * You can also choose to distribute this program under the terms of * the Unmodified Binary Distribution Licence (as given in the file * COPYING.UBDL), provided that you have satisfied its requirements. */ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL ); FILE_SECBOOT ( PERMITTED ); #include <stdlib.h> #include <string.h> #include <ctype.h> #include <errno.h> #include <assert.h> #include <ipxe/xfer.h> #include <ipxe/iobuf.h> #include <ipxe/open.h> #include <ipxe/tcpip.h> #include <ipxe/uuid.h> #include <ipxe/base16.h> #include <ipxe/netdevice.h> #include <ipxe/timer.h> #include <ipxe/fault.h> #include <ipxe/settings.h> #include <ipxe/pccrd.h> #include <ipxe/peerdisc.h> /** @file * * Peer Content Caching and Retrieval (PeerDist) protocol peer discovery * */ /** List of discovery segments */ static LIST_HEAD ( peerdisc_segments ); /** Number of repeated discovery attempts */ #define PEERDISC_REPEAT_COUNT 2 /** Time between repeated discovery attempts */ #define PEERDISC_REPEAT_TIMEOUT ( 1 * TICKS_PER_SEC ) /** Default discovery timeout (in seconds) */ #define PEERDISC_DEFAULT_TIMEOUT_SECS 2 /** Recommended discovery timeout (in seconds) * * We reduce the recommended discovery timeout whenever a segment * fails to discover any peers, and restore the default value whenever * a valid discovery reply is received. We continue to send discovery * requests even if the recommended timeout is reduced to zero. * * This strategy is intended to minimise discovery delays when no * peers are available on the network, while allowing downloads to * quickly switch back to using PeerDist acceleration if new peers * become available. */ unsigned int peerdisc_timeout_secs = PEERDISC_DEFAULT_TIMEOUT_SECS; /** Most recently discovered peer (for any block) */ static char *peerdisc_recent; /** Hosted cache server */ static char *peerhost; static struct peerdisc_segment * peerdisc_find ( const char *id ); static int peerdisc_discovered ( struct peerdisc_segment *segment, const char *location ); /****************************************************************************** * * Statistics reporting * ****************************************************************************** */ /** * Report peer discovery statistics * * @v intf Interface * @v peer Selected peer (or NULL) * @v peers List of available peers */ void peerdisc_stat ( struct interface *intf, struct peerdisc_peer *peer, struct list_head *peers ) { struct interface *dest; peerdisc_stat_TYPE ( void * ) *op = intf_get_dest_op ( intf, peerdisc_stat, &dest ); void *object = intf_object ( dest ); if ( op ) { op ( object, peer, peers ); } else { /* Default is to do nothing */ } intf_put ( dest ); } /****************************************************************************** * * Discovery sockets * ****************************************************************************** */ /** * Open all PeerDist discovery sockets * * @ret rc Return status code */ static int peerdisc_socket_open ( void ) { struct peerdisc_socket *socket; int rc; /* Open each socket */ for_each_table_entry ( socket, PEERDISC_SOCKETS ) { if ( ( rc = xfer_open_socket ( &socket->xfer, SOCK_DGRAM, &socket->address.sa, NULL ) ) != 0 ) { DBGC ( socket, "PEERDISC %s could not open socket: " "%s\n", socket->name, strerror ( rc ) ); goto err; } } return 0; err: for_each_table_entry_continue_reverse ( socket, PEERDISC_SOCKETS ) intf_restart ( &socket->xfer, rc ); return rc; } /** * Attempt to transmit PeerDist discovery requests on all sockets * * @v uuid Message UUID string * @v id Segment identifier string */ static void peerdisc_socket_tx ( const char *uuid, const char *id ) { struct peerdisc_socket *socket; struct net_device *netdev; struct xfer_metadata meta; union { struct sockaddr sa; struct sockaddr_tcpip st; } address; char *request; size_t len; int rc; /* Construct discovery request */ request = peerdist_discovery_request ( uuid, id ); if ( ! request ) goto err_request; len = strlen ( request ); /* Initialise data transfer metadata */ memset ( &meta, 0, sizeof ( meta ) ); meta.dest = &address.sa; /* Send message on each socket */ for_each_table_entry ( socket, PEERDISC_SOCKETS ) { /* Initialise socket address */ memcpy ( &address.sa, &socket->address.sa, sizeof ( address.sa ) ); /* Send message on each open network device */ for_each_netdev ( netdev ) { /* Skip unopened network devices */ if ( ! netdev_is_open ( netdev ) ) continue; address.st.st_scope_id = netdev->scope_id; /* Discard request (for test purposes) if applicable */ if ( inject_fault ( PEERDISC_DISCARD_RATE ) ) continue; /* Transmit request */ if ( ( rc = xfer_deliver_raw_meta ( &socket->xfer, request, len, &meta ) ) != 0 ) { DBGC ( socket, "PEERDISC %s could not transmit " "via %s: %s\n", socket->name, netdev->name, strerror ( rc ) ); /* Contine to try other net devices/sockets */ continue; } } } free ( request ); err_request: return; } /** * Handle received PeerDist discovery reply * * @v socket PeerDist discovery socket * @v iobuf I/O buffer * @v meta Data transfer metadata * @ret rc Return status code */ static int peerdisc_socket_rx ( struct peerdisc_socket *socket, struct io_buffer *iobuf, struct xfer_metadata *meta __unused ) { struct peerdist_discovery_reply reply; struct peerdisc_segment *segment; char *id; char *location; int rc; /* Discard reply (for test purposes) if applicable */ if ( ( rc = inject_fault ( PEERDISC_DISCARD_RATE ) ) != 0 ) goto err; /* Parse reply */ if ( ( rc = peerdist_discovery_reply ( iobuf->data, iob_len ( iobuf ), &reply ) ) != 0 ) { DBGC ( socket, "PEERDISC %s could not parse reply: %s\n", socket->name, strerror ( rc ) ); DBGC_HDA ( socket, 0, iobuf->data, iob_len ( iobuf ) ); goto err; } /* Any kind of discovery reply indicates that there are active * peers on a local network, so restore the recommended * discovery timeout to its default value for future requests. */ if ( peerdisc_timeout_secs != PEERDISC_DEFAULT_TIMEOUT_SECS ) { DBGC ( socket, "PEERDISC %s restoring timeout to %d seconds\n", socket->name, PEERDISC_DEFAULT_TIMEOUT_SECS ); } peerdisc_timeout_secs = PEERDISC_DEFAULT_TIMEOUT_SECS; /* Iterate over segment IDs */ for ( id = reply.ids ; *id ; id += ( strlen ( id ) + 1 /* NUL */ ) ) { /* Find corresponding segment */ segment = peerdisc_find ( id ); if ( ! segment ) { DBGC ( socket, "PEERDISC %s ignoring reply for %s\n", socket->name, id ); continue; } /* Report all discovered peer locations */ for ( location = reply.locations ; *location ; location += ( strlen ( location ) + 1 /* NUL */ ) ) { /* Report discovered peer location */ if ( ( rc = peerdisc_discovered ( segment, location ) ) != 0 ) goto err; } } err: free_iob ( iobuf ); return rc; } /** * Close all PeerDist discovery sockets * * @v rc Reason for close */ static void peerdisc_socket_close ( int rc ) { struct peerdisc_socket *socket; /* Close all sockets */ for_each_table_entry ( socket, PEERDISC_SOCKETS ) intf_restart ( &socket->xfer, rc ); } /** PeerDist discovery socket interface operations */ static struct interface_operation peerdisc_socket_operations[] = { INTF_OP ( xfer_deliver, struct peerdisc_socket *, peerdisc_socket_rx ), }; /** PeerDist discovery socket interface descriptor */ static struct interface_descriptor peerdisc_socket_desc = INTF_DESC ( struct peerdisc_socket, xfer, peerdisc_socket_operations ); /** PeerDist discovery IPv4 socket */ struct peerdisc_socket peerdisc_socket_ipv4 __peerdisc_socket = { .name = "IPv4", .address = { .sin = { .sin_family = AF_INET, .sin_port = htons ( PEERDIST_DISCOVERY_PORT ), .sin_addr.s_addr = htonl ( PEERDIST_DISCOVERY_IPV4 ), }, }, .xfer = INTF_INIT ( peerdisc_socket_desc ), }; /** PeerDist discovery IPv6 socket */ struct peerdisc_socket peerdisc_socket_ipv6 __peerdisc_socket = { .name = "IPv6", .address = { .sin6 = { .sin6_family = AF_INET6, .sin6_port = htons ( PEERDIST_DISCOVERY_PORT ), .sin6_addr.s6_addr = PEERDIST_DISCOVERY_IPV6, }, }, .xfer = INTF_INIT ( peerdisc_socket_desc ), }; /****************************************************************************** * * Discovery segments * ****************************************************************************** */ /** * Free PeerDist discovery segment * * @v refcnt Reference count */ static void peerdisc_free ( struct refcnt *refcnt ) { struct peerdisc_segment *segment = container_of ( refcnt, struct peerdisc_segment, refcnt ); struct peerdisc_peer *peer; struct peerdisc_peer *tmp; /* Free all discovered peers */ list_for_each_entry_safe ( peer, tmp, &segment->peers, list ) { list_del ( &peer->list ); free ( peer ); } /* Free segment */ free ( segment ); } /** * Find PeerDist discovery segment * * @v id Segment ID * @ret segment PeerDist discovery segment, or NULL if not found */ static struct peerdisc_segment * peerdisc_find ( const char *id ) { struct peerdisc_segment *segment; /* Look for a matching segment */ list_for_each_entry ( segment, &peerdisc_segments, list ) { if ( strcmp ( id, segment->id ) == 0 ) return segment; } return NULL; } /** * Add discovered PeerDist peer * * @v segment PeerDist discovery segment * @v location Peer location * @ret rc Return status code */ static int peerdisc_discovered ( struct peerdisc_segment *segment, const char *location ) { struct peerdisc_peer *peer; struct peerdisc_client *peerdisc; struct peerdisc_client *tmp; char *recent; /* Ignore duplicate peers */ list_for_each_entry ( peer, &segment->peers, list ) { if ( strcmp ( peer->location, location ) == 0 ) { DBGC2 ( segment, "PEERDISC %p duplicate %s\n", segment, location ); return 0; } } DBGC2 ( segment, "PEERDISC %p discovered %s\n", segment, location ); /* Allocate and initialise structure */ peer = zalloc ( sizeof ( *peer ) + strlen ( location ) + 1 /* NUL */ ); if ( ! peer ) return -ENOMEM; strcpy ( peer->location, location ); /* Add to end of list of peers */ list_add_tail ( &peer->list, &segment->peers ); /* Record as most recently discovered peer */ if ( location != peerdisc_recent ) { recent = strdup ( location ); if ( recent ) { free ( peerdisc_recent ); peerdisc_recent = recent; } } /* Notify all clients */ list_for_each_entry_safe ( peerdisc, tmp, &segment->clients, list ) peerdisc->op->discovered ( peerdisc ); return 0; } /** * Handle discovery timer expiry * * @v timer Discovery timer * @v over Failure indicator */ static void peerdisc_expired ( struct retry_timer *timer, int over __unused ) { struct peerdisc_segment *segment = container_of ( timer, struct peerdisc_segment, timer ); /* Attempt to transmit discovery requests */ peerdisc_socket_tx ( segment->uuid, segment->id ); /* Schedule next transmission, if applicable */ if ( timer->count < PEERDISC_REPEAT_COUNT ) start_timer_fixed ( &segment->timer, PEERDISC_REPEAT_TIMEOUT ); } /** * Create PeerDist discovery segment * * @v id Segment ID * @ret segment PeerDist discovery segment, or NULL on error */ static struct peerdisc_segment * peerdisc_create ( const char *id ) { struct peerdisc_segment *segment; union { union uuid uuid; uint32_t dword[ sizeof ( union uuid ) / sizeof ( uint32_t ) ]; } random_uuid; size_t uuid_len; size_t id_len; const char *uuid; char *uuid_copy; char *id_copy; unsigned int i; int rc; /* Generate a random message UUID. This does not require high * quality randomness. */ for ( i = 0 ; i < ( sizeof ( random_uuid.dword ) / sizeof ( random_uuid.dword[0] ) ) ; i++ ) random_uuid.dword[i] = random(); uuid = uuid_ntoa ( &random_uuid.uuid ); /* Calculate string lengths */ id_len = ( strlen ( id ) + 1 /* NUL */ ); uuid_len = ( strlen ( uuid ) + 1 /* NUL */ ); /* Allocate and initialise structure */ segment = zalloc ( sizeof ( *segment ) + id_len + uuid_len ); if ( ! segment ) goto err_alloc; id_copy = ( ( ( void * ) segment ) + sizeof ( *segment ) ); memcpy ( id_copy, id, id_len ); uuid_copy = ( ( ( void * ) id_copy ) + id_len ); memcpy ( uuid_copy, uuid, uuid_len ); ref_init ( &segment->refcnt, peerdisc_free ); segment->id = id_copy; segment->uuid = uuid_copy; INIT_LIST_HEAD ( &segment->peers ); INIT_LIST_HEAD ( &segment->clients ); timer_init ( &segment->timer, peerdisc_expired, &segment->refcnt ); /* Add hosted cache server or initiate discovery */ if ( peerhost ) { /* Add hosted cache server to list of peers */ if ( ( rc = peerdisc_discovered ( segment, peerhost ) ) != 0 ) goto err_peerhost; } else { /* Add most recently discovered peer to list of peers * * This is a performance optimisation: we assume that * the most recently discovered peer for any block has * a high probability of also having a copy of the * next block that we attempt to discover. */ if ( peerdisc_recent ) peerdisc_discovered ( segment, peerdisc_recent ); /* Start discovery timer */ start_timer_nodelay ( &segment->timer ); DBGC2 ( segment, "PEERDISC %p discovering %s\n", segment, segment->id ); } /* Add to list of segments, transfer reference to list, and return */ list_add_tail ( &segment->list, &peerdisc_segments ); return segment; err_peerhost: ref_put ( &segment->refcnt ); err_alloc: return NULL; } /** * Destroy PeerDist discovery segment * * @v segment PeerDist discovery segment */ static void peerdisc_destroy ( struct peerdisc_segment *segment ) { /* Sanity check */ assert ( list_empty ( &segment->clients ) ); /* Stop timer */ stop_timer ( &segment->timer ); /* Remove from list of segments and drop list's reference */ list_del ( &segment->list ); ref_put ( &segment->refcnt ); } /****************************************************************************** * * Discovery clients * ****************************************************************************** */ /** * Open PeerDist discovery client * * @v peerdisc PeerDist discovery client * @v id Segment ID * @v len Length of segment ID * @ret rc Return status code */ int peerdisc_open ( struct peerdisc_client *peerdisc, const void *id, size_t len ) { struct peerdisc_segment *segment; char id_string[ base16_encoded_len ( len ) + 1 /* NUL */ ]; char *id_chr; int rc; /* Construct ID string */ base16_encode ( id, len, id_string, sizeof ( id_string ) ); for ( id_chr = id_string ; *id_chr ; id_chr++ ) *id_chr = toupper ( *id_chr ); /* Sanity check */ assert ( peerdisc->segment == NULL ); /* Open socket if this is the first segment */ if ( list_empty ( &peerdisc_segments ) && ( ( rc = peerdisc_socket_open() ) != 0 ) ) return rc; /* Find or create segment */ if ( ! ( ( segment = peerdisc_find ( id_string ) ) || ( segment = peerdisc_create ( id_string ) ) ) ) return -ENOMEM; /* Add to list of clients */ ref_get ( &segment->refcnt ); peerdisc->segment = segment; list_add_tail ( &peerdisc->list, &segment->clients ); return 0; } /** * Close PeerDist discovery client * * @v peerdisc PeerDist discovery client */ void peerdisc_close ( struct peerdisc_client *peerdisc ) { struct peerdisc_segment *segment = peerdisc->segment; /* Ignore if discovery is already closed */ if ( ! segment ) return; /* If no peers were discovered, reduce the recommended * discovery timeout to minimise delays on future requests. */ if ( list_empty ( &segment->peers ) && peerdisc_timeout_secs ) { peerdisc_timeout_secs--; DBGC ( segment, "PEERDISC %p reducing timeout to %d " "seconds\n", peerdisc, peerdisc_timeout_secs ); } /* Remove from list of clients */ peerdisc->segment = NULL; list_del ( &peerdisc->list ); ref_put ( &segment->refcnt ); /* If this was the last clients, destroy the segment */ if ( list_empty ( &segment->clients ) ) peerdisc_destroy ( segment ); /* If there are no more segments, close the socket */ if ( list_empty ( &peerdisc_segments ) ) peerdisc_socket_close ( 0 ); } /****************************************************************************** * * Settings * ****************************************************************************** */ /** PeerDist hosted cache server setting */ const struct setting peerhost_setting __setting ( SETTING_MISC, peerhost ) = { .name = "peerhost", .description = "PeerDist hosted cache", .type = &setting_type_string, }; /** * Apply PeerDist discovery settings * * @ret rc Return status code */ static int apply_peerdisc_settings ( void ) { /* Free any existing hosted cache server */ free ( peerhost ); peerhost = NULL; /* Fetch hosted cache server */ fetch_string_setting_copy ( NULL, &peerhost_setting, &peerhost ); if ( peerhost ) { DBGC ( &peerhost, "PEERDISC using hosted cache %s\n", peerhost ); } return 0; } /** PeerDist discovery settings applicator */ struct settings_applicator peerdisc_applicator __settings_applicator = { .apply = apply_peerdisc_settings, };