peerblk.c File Reference

Peer Content Caching and Retrieval (PeerDist) protocol block downloads. More...

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <ipxe/http.h>
#include <ipxe/iobuf.h>
#include <ipxe/xfer.h>
#include <ipxe/uri.h>
#include <ipxe/timer.h>
#include <ipxe/profile.h>
#include <ipxe/fault.h>
#include <ipxe/pccrr.h>
#include <ipxe/peerblk.h>

Go to the source code of this file.

Macros
#define	PEERBLK_DECRYPT_CHUNKSIZE   2048
	PeerDist decryption chunksize. More...
#define	PEERBLK_RAW_MAX   2
	PeerDist maximum number of concurrent raw block downloads. More...
#define	PEERBLK_RAW_OPEN_TIMEOUT   ( 10 * TICKS_PER_SEC )
	PeerDist raw block download attempt initial progress timeout. More...
#define	PEERBLK_RAW_RX_TIMEOUT   ( 15 * TICKS_PER_SEC )
	PeerDist raw block download attempt ongoing progress timeout. More...
#define	PEERBLK_RETRIEVAL_OPEN_TIMEOUT   ( 3 * TICKS_PER_SEC )
	PeerDist retrieval protocol block download attempt initial progress timeout. More...
#define	PEERBLK_RETRIEVAL_RX_TIMEOUT   ( 5 * TICKS_PER_SEC )
	PeerDist retrieval protocol block download attempt ongoing progress timeout. More...
#define	PEERBLK_MAX_ATTEMPT_CYCLES   4
	PeerDist maximum number of full download attempt cycles. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static void	peerblk_dequeue (struct peerdist_block *peerblk)
	Remove block from download queue. More...
static unsigned long	peerblk_timestamp (void)
	Get profiling timestamp. More...
static void	peerblk_free (struct refcnt *refcnt)
	Free PeerDist block download. More...
static void	peerblk_reset (struct peerdist_block *peerblk, int rc)
	Reset PeerDist block download attempt. More...
static void	peerblk_close (struct peerdist_block *peerblk, int rc)
	Close PeerDist block download. More...
static size_t	peerblk_offset (struct peerdist_block *peerblk, size_t pos)
	Calculate offset within overall download. More...
static int	peerblk_deliver (struct peerdist_block *peerblk, struct io_buffer *iobuf, struct xfer_metadata *meta, size_t pos)
	Deliver download attempt data block. More...
static void	peerblk_done (struct peerdist_block *peerblk, int rc)
	Finish PeerDist block download attempt. More...
static int	peerblk_raw_open (struct peerdist_block *peerblk)
	Open PeerDist raw block download attempt. More...
static int	peerblk_raw_rx (struct peerdist_block *peerblk, struct io_buffer *iobuf, struct xfer_metadata *meta)
	Receive PeerDist raw data. More...
static void	peerblk_raw_close (struct peerdist_block *peerblk, int rc)
	Close PeerDist raw block download attempt. More...
static void	peerblk_step (struct peerdist_block_queue *queue)
	PeerDist block download queue process. More...
static void	peerblk_enqueue (struct peerdist_block *peerblk, struct peerdist_block_queue *queue)
	Add block to download queue. More...
static struct uri *	peerblk_retrieval_uri (const char *location)
	Construct PeerDist retrieval protocol URI. More...
static int	peerblk_retrieval_open (struct peerdist_block *peerblk, const char *location)
	Open PeerDist retrieval protocol block download attempt. More...
static int	peerblk_retrieval_rx (struct peerdist_block *peerblk, struct io_buffer *iobuf, struct xfer_metadata *meta)
	Receive PeerDist retrieval protocol data. More...
static int	peerblk_parse_header (struct peerdist_block *peerblk)
	Parse retrieval protocol message header. More...
static int	peerblk_parse_block (struct peerdist_block *peerblk, size_t *buf_len)
	Parse retrieval protocol message segment and block details. More...
static int	peerblk_parse_useless (struct peerdist_block *peerblk, size_t buf_len, size_t *vrf_len)
	Parse retrieval protocol message useless details. More...
static int	peerblk_parse_iv (struct peerdist_block *peerblk, size_t buf_len, size_t vrf_len)
	Parse retrieval protocol message initialisation vector details. More...
static int	peerblk_decrypt_read (struct peerdist_block *peerblk, void *data, size_t len)
	Read from decryption buffers. More...
static int	peerblk_decrypt_write (struct peerdist_block *peerblk, const void *data, size_t len)
	Write to decryption buffers and update offsets and lengths. More...
static void	peerblk_decrypt (struct peerdist_block *peerblk)
	Decrypt one chunk of PeerDist retrieval protocol data. More...
static void	peerblk_retrieval_close (struct peerdist_block *peerblk, int rc)
	Close PeerDist retrieval protocol block download attempt. More...
static void	peerblk_expired (struct retry_timer *timer, int over __unused)
	Handle PeerDist retry timer expiry. More...
static void	peerblk_discovered (struct peerdisc_client *discovery)
	Handle PeerDist peer discovery. More...
int	peerblk_open (struct interface *xfer, struct uri *uri, struct peerdist_info_block *block)
	Open PeerDist block download. More...

Variables
static struct profiler peerblk_download_profiler	__profiler
	PeerDist block download profiler. More...
static struct process_descriptor	peerblk_queue_desc
	PeerDist block download queue process descriptor. More...
static struct peerdist_block_queue	peerblk_raw_queue
	Raw block download queue. More...
static struct interface_operation	peerblk_xfer_operations []
	PeerDist block download data transfer interface operations. More...
static struct interface_descriptor	peerblk_xfer_desc
	PeerDist block download data transfer interface descriptor. More...
static struct interface_operation	peerblk_raw_operations []
	PeerDist block download raw data interface operations. More...
static struct interface_descriptor	peerblk_raw_desc
	PeerDist block download raw data interface descriptor. More...
static struct interface_operation	peerblk_retrieval_operations []
	PeerDist block download retrieval protocol interface operations. More...
static struct interface_descriptor	peerblk_retrieval_desc
	PeerDist block download retrieval protocol interface descriptor. More...
static struct process_descriptor	peerblk_process_desc
	PeerDist block download decryption process descriptor. More...
static struct peerdisc_client_operations	peerblk_discovery_operations
	PeerDist block download discovery operations. More...

Detailed Description

Peer Content Caching and Retrieval (PeerDist) protocol block downloads.

Definition in file peerblk.c.

Macro Definition Documentation

PEERBLK_DECRYPT_CHUNKSIZE

#define PEERBLK_DECRYPT_CHUNKSIZE   2048

PeerDist decryption chunksize.

This is a policy decision.

Definition at line 49 of file peerblk.c.

PEERBLK_RAW_MAX

#define PEERBLK_RAW_MAX   2

PeerDist maximum number of concurrent raw block downloads.

Raw block downloads are expensive if the origin server uses HTTPS, since each concurrent download will require local TLS resources (including potentially large received encrypted data buffers).

Raw block downloads may also be prohibitively slow to initiate when the origin server is using HTTPS and client certificates. Origin servers for PeerDist downloads are likely to be running IIS, which has a bug that breaks session resumption and requires each connection to go through the full client certificate verification.

Limit the total number of concurrent raw block downloads to ameliorate these problems.

This is a policy decision.

Definition at line 68 of file peerblk.c.

PEERBLK_RAW_OPEN_TIMEOUT

#define PEERBLK_RAW_OPEN_TIMEOUT   ( 10 * TICKS_PER_SEC )

PeerDist raw block download attempt initial progress timeout.

This is a policy decision.

Definition at line 74 of file peerblk.c.

PEERBLK_RAW_RX_TIMEOUT

#define PEERBLK_RAW_RX_TIMEOUT   ( 15 * TICKS_PER_SEC )

PeerDist raw block download attempt ongoing progress timeout.

This is a policy decision.

Definition at line 80 of file peerblk.c.

PEERBLK_RETRIEVAL_OPEN_TIMEOUT

#define PEERBLK_RETRIEVAL_OPEN_TIMEOUT   ( 3 * TICKS_PER_SEC )

PeerDist retrieval protocol block download attempt initial progress timeout.

This is a policy decision.

Definition at line 86 of file peerblk.c.

PEERBLK_RETRIEVAL_RX_TIMEOUT

#define PEERBLK_RETRIEVAL_RX_TIMEOUT   ( 5 * TICKS_PER_SEC )

PeerDist retrieval protocol block download attempt ongoing progress timeout.

This is a policy decision.

Definition at line 92 of file peerblk.c.

PEERBLK_MAX_ATTEMPT_CYCLES

#define PEERBLK_MAX_ATTEMPT_CYCLES   4

PeerDist maximum number of full download attempt cycles.

This is the maximum number of times that we will try a full cycle of download attempts (i.e. a retrieval protocol download attempt from each discovered peer plus a raw download attempt from the origin server).

This is a policy decision.

Definition at line 103 of file peerblk.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

peerblk_dequeue()

static void peerblk_dequeue ( struct peerdist_block *  peerblk )

static

Remove block from download queue.

Parameters

peerblk

PeerDist block download

Definition at line 536 of file peerblk.c.

                                                               {
        struct peerdist_block_queue *queue = peerblk->queue;

        /* Sanity checks */
        assert ( queue != NULL );

        /* Remove block from queue */
        peerblk->queue = NULL;
        if ( list_empty ( &peerblk->queued ) ) {

                /* Open download: decrement count and reschedule queue */
                queue->count--;
                process_add ( &queue->process );

        } else {

                /* Queued download: remove from queue */
                list_del ( &peerblk->queued );
                INIT_LIST_HEAD ( &peerblk->queued );
        }
}

References assert(), INIT_LIST_HEAD, list_del, list_empty, NULL, process_add(), queue, peerdist_block::queue, and peerdist_block::queued.

Referenced by peerblk_reset().

peerblk_timestamp()

static unsigned long peerblk_timestamp ( void  )

inlinestatic

Get profiling timestamp.

Return values

timestamp

Timestamp

Definition at line 137 of file peerblk.c.

                           {

        if ( PROFILING ) {
                return currticks();
        } else {
                return 0;
        }
}

References currticks(), and PROFILING.

Referenced by peerblk_close(), peerblk_discovered(), peerblk_done(), peerblk_expired(), and peerblk_open().

peerblk_free()

static void peerblk_free ( struct refcnt *  refcnt )

static

Free PeerDist block download.

Parameters

refcnt

Reference count

Definition at line 151 of file peerblk.c.

                                                   {
        struct peerdist_block *peerblk =
                container_of ( refcnt, struct peerdist_block, refcnt );

        uri_put ( peerblk->uri );
        free ( peerblk->cipherctx );
        free ( peerblk );
}

References peerdist_block::cipherctx, container_of, free, peerdist_block::uri, and uri_put().

Referenced by peerblk_open().

peerblk_reset()

static void peerblk_reset ( struct peerdist_block *  peerblk, int  rc  )

static

Reset PeerDist block download attempt.

Parameters

peerblk	PeerDist block download
rc	Reason for reset

Definition at line 166 of file peerblk.c.

                                                                     {

        /* Stop decryption process */
        process_del ( &peerblk->process );

        /* Stop timer */
        stop_timer ( &peerblk->timer );

        /* Abort any current download attempt */
        intf_restart ( &peerblk->raw, rc );
        intf_restart ( &peerblk->retrieval, rc );

        /* Remove from download queue, if applicable */
        if ( peerblk->queue )
                peerblk_dequeue ( peerblk );

        /* Empty received data buffer */
        xferbuf_free ( &peerblk->buffer );
        peerblk->pos = 0;

        /* Reset digest and free cipher context */
        digest_init ( peerblk->digest, peerblk->digestctx );
        free ( peerblk->cipherctx );
        peerblk->cipherctx = NULL;
        peerblk->cipher = NULL;

        /* Reset trim thresholds */
        peerblk->start = ( peerblk->trim.start - peerblk->range.start );
        peerblk->end = ( peerblk->trim.end - peerblk->range.start );
        assert ( peerblk->start <= peerblk->end );
}

References assert(), peerdist_block::buffer, peerdist_block::cipher, peerdist_block::cipherctx, peerdist_block::digest, digest_init(), peerdist_block::digestctx, peerdist_block::end, peerdist_range::end, free, intf_restart(), NULL, peerblk_dequeue(), peerdist_block::pos, peerdist_block::process, process_del(), peerdist_block::queue, peerdist_block::range, peerdist_block::raw, rc, peerdist_block::retrieval, peerdist_block::start, peerdist_range::start, stop_timer(), peerdist_block::timer, peerdist_block::trim, and xferbuf_free().

Referenced by peerblk_close(), peerblk_done(), and peerblk_expired().

peerblk_close()

static void peerblk_close ( struct peerdist_block *  peerblk, int  rc  )

static

Close PeerDist block download.

Parameters

peerblk	PeerDist block download
rc	Reason for close

Definition at line 204 of file peerblk.c.

                                                                     {
        unsigned long now = peerblk_timestamp();

        /* Profile overall block download */
        profile_custom ( &peerblk_download_profiler,
                         ( now - peerblk->started ) );

        /* Reset download attempt */
        peerblk_reset ( peerblk, rc );

        /* Close discovery */
        peerdisc_close ( &peerblk->discovery );

        /* Shut down all interfaces */
        intf_shutdown ( &peerblk->retrieval, rc );
        intf_shutdown ( &peerblk->raw, rc );
        intf_shutdown ( &peerblk->xfer, rc );
}

References peerdist_block::discovery, intf_shutdown(), peerblk_reset(), peerblk_timestamp(), peerdisc_close(), profile_custom(), peerdist_block::raw, rc, peerdist_block::retrieval, peerdist_block::started, and peerdist_block::xfer.

Referenced by peerblk_done(), peerblk_expired(), peerblk_open(), and peerblk_step().

peerblk_offset()

static size_t peerblk_offset ( struct peerdist_block *  peerblk, size_t  pos  )

inlinestatic

Calculate offset within overall download.

Parameters

peerblk	PeerDist block download
pos	Position within incoming data stream

Return values

offset

Offset within overall download

Definition at line 231 of file peerblk.c.

                                                              {

        return ( ( pos - peerblk->start ) + peerblk->offset );
}

References peerdist_block::offset, peerdist_block::pos, and peerdist_block::start.

Referenced by peerblk_deliver(), and peerblk_parse_block().

peerblk_deliver()

static int peerblk_deliver ( struct peerdist_block *  peerblk, struct io_buffer *  iobuf, struct xfer_metadata *  meta, size_t  pos  )

static

Deliver download attempt data block.

Parameters

peerblk	PeerDist block download
iobuf	I/O buffer
meta	Original data transfer metadata
pos	Position within incoming data stream

Return values

rc	Return status code

Definition at line 245 of file peerblk.c.

                                                                      {
        struct xfer_metadata xfer_meta;
        size_t len = iob_len ( iobuf );
        size_t start = pos;
        size_t end = ( pos + len );
        int rc;

        /* Discard zero-length packets and packets which lie entirely
         * outside the trimmed range.
         */
        if ( ( start >= peerblk->end ) || ( end <= peerblk->start ) ||
             ( len == 0 ) ) {
                free_iob ( iobuf );
                return 0;
        }

        /* Truncate data to within trimmed range */
        if ( start < peerblk->start ) {
                iob_pull ( iobuf, ( peerblk->start - start ) );
                start = peerblk->start;
        }
        if ( end > peerblk->end ) {
                iob_unput ( iobuf, ( end - peerblk->end ) );
                end = peerblk->end;
        }

        /* Construct metadata */
        memcpy ( &xfer_meta, meta, sizeof ( xfer_meta ) );
        xfer_meta.flags |= XFER_FL_ABS_OFFSET;
        xfer_meta.offset = peerblk_offset ( peerblk, start );

        /* Deliver data */
        if ( ( rc = xfer_deliver ( &peerblk->xfer, iob_disown ( iobuf ),
                                   &xfer_meta ) ) != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d could not deliver data: %s\n",
                       peerblk, peerblk->segment, peerblk->block,
                       strerror ( rc ) );
                return rc;
        }

        return 0;
}

References peerdist_block::block, DBGC, end, peerdist_block::end, xfer_metadata::flags, free_iob(), iob_disown, iob_len(), iob_pull, iob_unput, len, memcpy(), meta(), xfer_metadata::offset, peerblk_offset(), rc, peerdist_block::segment, start, peerdist_block::start, strerror(), peerdist_block::xfer, xfer_deliver(), and XFER_FL_ABS_OFFSET.

Referenced by peerblk_raw_rx(), and peerblk_retrieval_rx().

peerblk_done()

static void peerblk_done ( struct peerdist_block *  peerblk, int  rc  )

static

Finish PeerDist block download attempt.

Parameters

peerblk	PeerDist block download
rc	Reason for close

Definition at line 296 of file peerblk.c.

                                                                    {
        struct digest_algorithm *digest = peerblk->digest;
        struct peerdisc_segment *segment = peerblk->discovery.segment;
        struct peerdisc_peer *head;
        struct peerdisc_peer *peer;
        uint8_t hash[digest->digestsize];
        unsigned long now = peerblk_timestamp();

        /* Check for errors on completion */
        if ( rc != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d attempt failed: %s\n",
                       peerblk, peerblk->segment, peerblk->block,
                       strerror ( rc ) );
                goto err;
        }

        /* Check digest */
        digest_final ( digest, peerblk->digestctx, hash );
        if ( memcmp ( hash, peerblk->hash, peerblk->digestsize ) != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d digest mismatch:\n",
                       peerblk, peerblk->segment, peerblk->block );
                DBGC_HDA ( peerblk, 0, hash, peerblk->digestsize );
                DBGC_HDA ( peerblk, 0, peerblk->hash, peerblk->digestsize );
                rc = -EIO;
                goto err;
        }

        /* Profile successful attempt */
        profile_custom ( &peerblk_attempt_success_profiler,
                         ( now - peerblk->attempted ) );

        /* Report peer statistics */
        head = list_entry ( &segment->peers, struct peerdisc_peer, list );
        peer = ( ( peerblk->peer == head ) ? NULL : peerblk->peer );
        peerdisc_stat ( &peerblk->xfer, peer, &segment->peers );

        /* Close download */
        peerblk_close ( peerblk, 0 );
        return;

 err:
        /* Record failure reason and schedule a retry attempt */
        profile_custom ( &peerblk_attempt_failure_profiler,
                         ( now - peerblk->attempted ) );
        peerblk_reset ( peerblk, rc );
        peerblk->rc = rc;
        start_timer_nodelay ( &peerblk->timer );
}

References peerdist_block::attempted, peerdist_block::block, DBGC, DBGC_HDA, peerdist_block::digest, digest_final(), peerdist_block::digestctx, digest_algorithm::digestsize, peerdist_block::digestsize, peerdist_block::discovery, EIO, hash, peerdist_block::hash, head, peerdisc_peer::list, list_entry, memcmp(), NULL, peer, peerdist_block::peer, peerblk_close(), peerblk_reset(), peerblk_timestamp(), peerdisc_stat(), profile_custom(), peerdist_block::rc, rc, peerdisc_client::segment, peerdist_block::segment, segment, start_timer_nodelay(), strerror(), peerdist_block::timer, and peerdist_block::xfer.

Referenced by peerblk_decrypt(), peerblk_raw_close(), peerblk_raw_rx(), peerblk_retrieval_close(), and peerblk_retrieval_rx().

peerblk_raw_open()

static int peerblk_raw_open ( struct peerdist_block *  peerblk )

static

Open PeerDist raw block download attempt.

Parameters

peerblk

PeerDist block download

Return values

rc	Return status code

Definition at line 358 of file peerblk.c.

                                                               {
        struct http_request_range range;
        int rc;

        DBGC2 ( peerblk, "PEERBLK %p %d.%d attempting raw range request\n",
                peerblk, peerblk->segment, peerblk->block );

        /* Construct HTTP range */
        memset ( &range, 0, sizeof ( range ) );
        range.start = peerblk->range.start;
        range.len = ( peerblk->range.end - peerblk->range.start );

        /* Initiate range request to retrieve block */
        if ( ( rc = http_open ( &peerblk->raw, &http_get, peerblk->uri,
                                &range, NULL ) ) != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d could not create range "
                       "request: %s\n", peerblk, peerblk->segment,
                       peerblk->block, strerror ( rc ) );
                return rc;
        }

        /* Annul HTTP connection (for testing) if applicable.  Do not
         * report as an immediate error, in order to test our ability
         * to recover from a totally unresponsive HTTP server.
         */
        if ( inject_fault ( PEERBLK_ANNUL_RATE ) )
                intf_restart ( &peerblk->raw, 0 );

        /* Start download attempt timer */
        peerblk->rc = -ETIMEDOUT;
        start_timer_fixed ( &peerblk->timer, PEERBLK_RAW_OPEN_TIMEOUT );

        return 0;
}

References peerdist_block::block, DBGC, DBGC2, peerdist_range::end, ETIMEDOUT, http_get, http_open(), intf_restart(), memset(), NULL, PEERBLK_ANNUL_RATE, PEERBLK_RAW_OPEN_TIMEOUT, range, peerdist_block::range, peerdist_block::raw, peerdist_block::rc, rc, peerdist_block::segment, pci_range::start, peerdist_range::start, start_timer_fixed(), strerror(), peerdist_block::timer, and peerdist_block::uri.

peerblk_raw_rx()

static int peerblk_raw_rx ( struct peerdist_block *  peerblk, struct io_buffer *  iobuf, struct xfer_metadata *  meta  )

static

Receive PeerDist raw data.

Parameters

peerblk	PeerDist block download
iobuf	I/O buffer
meta	Data transfer metadata

Return values

rc	Return status code

Definition at line 401 of file peerblk.c.

                                                         {
        size_t len = iob_len ( iobuf );
        size_t pos = peerblk->pos;
        size_t mid = ( ( peerblk->range.end - peerblk->range.start ) / 2 );
        int rc;

        /* Corrupt received data (for testing) if applicable */
        inject_corruption ( PEERBLK_CORRUPT_RATE, iobuf->data, len );

        /* Fail if data is delivered out of order, since the streaming
         * digest requires strict ordering.
         */
        if ( ( rc = xfer_check_order ( meta, &peerblk->pos, len ) ) != 0 )
                goto err;

        /* Add data to digest */
        digest_update ( peerblk->digest, peerblk->digestctx, iobuf->data, len );

        /* Deliver data */
        if ( ( rc = peerblk_deliver ( peerblk, iob_disown ( iobuf ), meta,
                                      pos ) ) != 0 )
                goto err;

        /* Extend download attempt timer */
        start_timer_fixed ( &peerblk->timer, PEERBLK_RAW_RX_TIMEOUT );

        /* Stall download attempt (for testing) if applicable */
        if ( ( pos < mid ) && ( ( pos + len ) >= mid ) &&
             ( ( rc = inject_fault ( PEERBLK_STALL_RATE ) ) != 0 ) ) {
                intf_restart ( &peerblk->raw, rc );
        }

        return 0;

 err:
        free_iob ( iobuf );
        peerblk_done ( peerblk, rc );
        return rc;
}

References io_buffer::data, peerdist_block::digest, digest_update(), peerdist_block::digestctx, peerdist_range::end, free_iob(), intf_restart(), iob_disown, iob_len(), len, meta(), mid, PEERBLK_CORRUPT_RATE, peerblk_deliver(), peerblk_done(), PEERBLK_RAW_RX_TIMEOUT, PEERBLK_STALL_RATE, peerdist_block::pos, peerdist_block::range, peerdist_block::raw, rc, peerdist_range::start, start_timer_fixed(), peerdist_block::timer, and xfer_check_order().

peerblk_raw_close()

static void peerblk_raw_close ( struct peerdist_block *  peerblk, int  rc  )

static

Close PeerDist raw block download attempt.

Parameters

peerblk	PeerDist block download
rc	Reason for close

Definition at line 449 of file peerblk.c.

                                                                         {

        /* Restart interface */
        intf_restart ( &peerblk->raw, rc );

        /* Fail immediately if we have an error */
        if ( rc != 0 )
                goto done;

        /* Abort download attempt (for testing) if applicable */
        if ( ( rc = inject_fault ( PEERBLK_ABORT_RATE ) ) != 0 )
                goto done;

 done:
        /* Complete download attempt */
        peerblk_done ( peerblk, rc );
}

References done, intf_restart(), PEERBLK_ABORT_RATE, peerblk_done(), peerdist_block::raw, and rc.

peerblk_step()

static void peerblk_step ( struct peerdist_block_queue *  queue )

static

PeerDist block download queue process.

Parameters

queue

Block download queue

Definition at line 479 of file peerblk.c.

                                                                {
        struct peerdist_block *peerblk;
        int rc;

        /* Do nothing yet if we have too many open block downloads */
        if ( queue->count >= queue->max )
                return;

        /* Do nothing unless there are queued block downloads */
        peerblk = list_first_entry ( &queue->list, struct peerdist_block,
                                     queued );
        if ( ! peerblk )
                return;

        /* Reschedule queue process */
        process_add ( &queue->process );

        /* Remove block from queue */
        list_del ( &peerblk->queued );
        INIT_LIST_HEAD ( &peerblk->queued );

        /* Attempt download */
        if ( ( rc = queue->open ( peerblk ) ) != 0 ) {
                peerblk_close ( peerblk, rc );
                return;
        }

        /* Increment open block download count */
        queue->count++;
}

References INIT_LIST_HEAD, list_del, list_first_entry, peerblk_close(), process_add(), queue, peerdist_block::queued, and rc.

peerblk_enqueue()

static void peerblk_enqueue ( struct peerdist_block *  peerblk, struct peerdist_block_queue *  queue  )

static

Add block to download queue.

Parameters

peerblk	PeerDist block download
queue	Block download queue

Definition at line 516 of file peerblk.c.

                                                                   {

        /* Sanity checks */
        assert ( peerblk->queue == NULL );
        assert ( list_empty ( &peerblk->queued ) );

        /* Add block to queue */
        peerblk->queue = queue;
        list_add_tail ( &peerblk->queued, &queue->list );

        /* Schedule queue process */
        process_add ( &queue->process );
}

References assert(), list_add_tail, list_empty, NULL, process_add(), queue, peerdist_block::queue, and peerdist_block::queued.

Referenced by peerblk_expired().

peerblk_retrieval_uri()

static struct uri* peerblk_retrieval_uri ( const char *  location )

static

Construct PeerDist retrieval protocol URI.

Parameters

location

Peer location

Return values

uri	Retrieval URI, or NULL on error

Definition at line 583 of file peerblk.c.

                                                                   {
        char uri_string[ 7 /* "http://" */ + strlen ( location ) +
                         sizeof ( PEERDIST_MAGIC_PATH /* includes NUL */ ) ];

        /* Construct URI string */
        snprintf ( uri_string, sizeof ( uri_string ),
                   ( "http://%s" PEERDIST_MAGIC_PATH ), location );

        /* Parse URI string */
        return parse_uri ( uri_string );
}

References parse_uri(), PEERDIST_MAGIC_PATH, snprintf(), and strlen().

Referenced by peerblk_retrieval_open().

peerblk_retrieval_open()

static int peerblk_retrieval_open ( struct peerdist_block *  peerblk, const char *  location  )

static

Open PeerDist retrieval protocol block download attempt.

Parameters

peerblk	PeerDist block download
location	Peer location

Return values

rc	Return status code

Definition at line 602 of file peerblk.c.

                                                           {
        size_t digestsize = peerblk->digestsize;
        peerdist_msg_getblks_t ( digestsize, 1, 0 ) req;
        peerblk_msg_blk_t ( digestsize, 0, 0, 0 ) *rsp;
        struct http_request_content content;
        struct uri *uri;
        int rc;

        DBGC2 ( peerblk, "PEERBLK %p %d.%d attempting retrieval from %s\n",
                peerblk, peerblk->segment, peerblk->block, location );

        /* Construct block fetch request */
        memset ( &req, 0, sizeof ( req ) );
        req.getblks.hdr.version.raw = htonl ( PEERDIST_MSG_GETBLKS_VERSION );
        req.getblks.hdr.type = htonl ( PEERDIST_MSG_GETBLKS_TYPE );
        req.getblks.hdr.len = htonl ( sizeof ( req ) );
        req.getblks.hdr.algorithm = htonl ( PEERDIST_MSG_AES_128_CBC );
        req.segment.segment.digestsize = htonl ( digestsize );
        memcpy ( req.segment.id, peerblk->id, digestsize );
        req.ranges.ranges.count = htonl ( 1 );
        req.ranges.range[0].first = htonl ( peerblk->block );
        req.ranges.range[0].count = htonl ( 1 );

        /* Construct POST request content */
        memset ( &content, 0, sizeof ( content ) );
        content.data = &req;
        content.len = sizeof ( req );

        /* Construct URI */
        if ( ( uri = peerblk_retrieval_uri ( location ) ) == NULL ) {
                rc = -ENOMEM;
                goto err_uri;
        }

        /* Update trim thresholds */
        peerblk->start += offsetof ( typeof ( *rsp ), msg.vrf );
        peerblk->end += offsetof ( typeof ( *rsp ), msg.vrf );

        /* Initiate HTTP POST to retrieve block */
        if ( ( rc = http_open ( &peerblk->retrieval, &http_post, uri,
                                NULL, &content ) ) != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d could not create retrieval "
                       "request: %s\n", peerblk, peerblk->segment,
                       peerblk->block, strerror ( rc ) );
                goto err_open;
        }

        /* Annul HTTP connection (for testing) if applicable.  Do not
         * report as an immediate error, in order to test our ability
         * to recover from a totally unresponsive HTTP server.
         */
        if ( inject_fault ( PEERBLK_ANNUL_RATE ) )
                intf_restart ( &peerblk->retrieval, 0 );

        /* Start download attempt timer */
        peerblk->rc = -ETIMEDOUT;
        start_timer_fixed ( &peerblk->timer, PEERBLK_RETRIEVAL_OPEN_TIMEOUT );

 err_open:
        uri_put ( uri );
 err_uri:
        return rc;
}

References peerdist_block::block, http_request_content::data, DBGC, DBGC2, digestsize, peerdist_block::digestsize, peerdist_block::end, ENOMEM, ETIMEDOUT, htonl, http_open(), http_post, peerdist_block::id, intf_restart(), http_request_content::len, memcpy(), memset(), msg(), NULL, offsetof, PEERBLK_ANNUL_RATE, peerblk_msg_blk_t, PEERBLK_RETRIEVAL_OPEN_TIMEOUT, peerblk_retrieval_uri(), PEERDIST_MSG_AES_128_CBC, peerdist_msg_getblks_t, PEERDIST_MSG_GETBLKS_TYPE, PEERDIST_MSG_GETBLKS_VERSION, peerdist_block::rc, rc, peerdist_block::retrieval, rsp, peerdist_block::segment, peerdist_block::start, start_timer_fixed(), strerror(), peerdist_block::timer, typeof(), and uri_put().

Referenced by peerblk_expired().

peerblk_retrieval_rx()

static int peerblk_retrieval_rx ( struct peerdist_block *  peerblk, struct io_buffer *  iobuf, struct xfer_metadata *  meta  )

static

Receive PeerDist retrieval protocol data.

Parameters

peerblk	PeerDist block download
iobuf	I/O buffer
meta	Data transfer metadata

Return values

rc	Return status code

Definition at line 675 of file peerblk.c.

                                                               {
        size_t len = iob_len ( iobuf );
        size_t start;
        size_t end;
        size_t before;
        size_t after;
        size_t cut;
        int rc;

        /* Some genius at Microsoft thought it would be a great idea
         * to place the AES-CBC initialisation vector *after* the
         * encrypted data, thereby making it logically impossible to
         * decrypt each packet as it arrives.
         *
         * To work around this mindless stupidity, we deliver the
         * ciphertext as-is and later use xfer_buffer() to obtain
         * access to the underlying data transfer buffer in order to
         * perform the decryption.
         *
         * There will be some data both before and after the bytes
         * corresponding to the trimmed plaintext: a MSG_BLK
         * header/footer, some block padding for the AES-CBC cipher,
         * and a possibly large quantity of unwanted ciphertext which
         * is excluded from the trimmed content range.  We store this
         * data in a local data transfer buffer.  If the amount of
         * data to be stored is too large, we will fail allocation and
         * so eventually fall back to using a range request (which
         * does not require this kind of temporary storage
         * allocation).
         */

        /* Corrupt received data (for testing) if applicable */
        inject_corruption ( PEERBLK_CORRUPT_RATE, iobuf->data, len );

        /* Calculate start and end positions of this buffer */
        start = peerblk->pos;
        if ( meta->flags & XFER_FL_ABS_OFFSET )
                start = 0;
        start += meta->offset;
        end = ( start + len );

        /* Buffer any data before the trimmed content */
        if ( ( start < peerblk->start ) && ( len > 0 ) ) {

                /* Calculate length of data before the trimmed content */
                before = ( peerblk->start - start );
                if ( before > len )
                        before = len;

                /* Buffer data before the trimmed content */
                if ( ( rc = xferbuf_write ( &peerblk->buffer, start,
                                            iobuf->data, before ) ) != 0 ) {
                        DBGC ( peerblk, "PEERBLK %p %d.%d could not buffer "
                               "data: %s\n", peerblk, peerblk->segment,
                               peerblk->block, strerror ( rc ) );
                        goto err;
                }
        }

        /* Buffer any data after the trimmed content */
        if ( ( end > peerblk->end ) && ( len > 0 ) ) {

                /* Calculate length of data after the trimmed content */
                after = ( end - peerblk->end );
                if ( after > len )
                        after = len;

                /* Buffer data after the trimmed content */
                cut = ( peerblk->end - peerblk->start );
                if ( ( rc = xferbuf_write ( &peerblk->buffer,
                                            ( end - after - cut ),
                                            ( iobuf->data + len - after ),
                                            after ) ) != 0 ) {
                        DBGC ( peerblk, "PEERBLK %p %d.%d could not buffer "
                               "data: %s\n", peerblk, peerblk->segment,
                               peerblk->block, strerror ( rc ) );
                        goto err;
                }
        }

        /* Deliver any remaining data */
        if ( ( rc = peerblk_deliver ( peerblk, iob_disown ( iobuf ), meta,
                                      start ) ) != 0 )
                goto err;

        /* Update position */
        peerblk->pos = end;

        /* Extend download attempt timer */
        start_timer_fixed ( &peerblk->timer, PEERBLK_RETRIEVAL_RX_TIMEOUT );

        /* Stall download attempt (for testing) if applicable */
        if ( ( start < peerblk->end ) && ( end >= peerblk->end ) &&
             ( ( rc = inject_fault ( PEERBLK_STALL_RATE ) ) != 0 ) ) {
                intf_restart ( &peerblk->retrieval, rc );
        }

        return 0;

 err:
        free_iob ( iobuf );
        peerblk_done ( peerblk, rc );
        return rc;
}

References after, before, peerdist_block::block, peerdist_block::buffer, io_buffer::data, DBGC, end, peerdist_block::end, free_iob(), intf_restart(), iob_disown, iob_len(), len, meta(), PEERBLK_CORRUPT_RATE, peerblk_deliver(), peerblk_done(), PEERBLK_RETRIEVAL_RX_TIMEOUT, PEERBLK_STALL_RATE, peerdist_block::pos, rc, peerdist_block::retrieval, peerdist_block::segment, start, peerdist_block::start, start_timer_fixed(), strerror(), peerdist_block::timer, XFER_FL_ABS_OFFSET, and xferbuf_write().

peerblk_parse_header()

static int peerblk_parse_header ( struct peerdist_block *  peerblk )

static

Parse retrieval protocol message header.

Parameters

peerblk

PeerDist block download

Return values

rc	Return status code

Definition at line 788 of file peerblk.c.

                                                                   {
        struct {
                struct peerdist_msg_transport_header hdr;
                struct peerdist_msg_header msg;
        } __attribute__ (( packed )) *msg = peerblk->buffer.data;
        struct cipher_algorithm *cipher;
        size_t len = peerblk->buffer.len;
        size_t keylen = 0;
        int rc;

        /* Check message length */
        if ( len < sizeof ( *msg ) ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d message too short for header "
                       "(%zd bytes)\n", peerblk, peerblk->segment,
                       peerblk->block, len );
                return -ERANGE;
        }

        /* Check message type */
        if ( msg->msg.type != htonl ( PEERDIST_MSG_BLK_TYPE ) ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d unexpected message type "
                       "%#08x\n", peerblk, peerblk->segment, peerblk->block,
                       ntohl ( msg->msg.type ) );
                return -EPROTO;
        }

        /* Determine cipher algorithm and key length */
        cipher = &aes_cbc_algorithm;
        switch ( msg->msg.algorithm ) {
        case htonl ( PEERDIST_MSG_PLAINTEXT ) :
                cipher = NULL;
                break;
        case htonl ( PEERDIST_MSG_AES_128_CBC ) :
                keylen = ( 128 / 8 );
                break;
        case htonl ( PEERDIST_MSG_AES_192_CBC ) :
                keylen = ( 192 / 8 );
                break;
        case htonl ( PEERDIST_MSG_AES_256_CBC ) :
                keylen = ( 256 / 8 );
                break;
        default:
                DBGC ( peerblk, "PEERBLK %p %d.%d unrecognised algorithm "
                       "%#08x\n", peerblk, peerblk->segment, peerblk->block,
                       ntohl ( msg->msg.algorithm ) );
                return -ENOTSUP;
        }
        DBGC2 ( peerblk, "PEERBLK %p %d.%d using %s with %zd-bit key\n",
                peerblk, peerblk->segment, peerblk->block,
                ( cipher ? cipher->name : "plaintext" ), ( 8 * keylen ) );

        /* Sanity check key length against maximum secret length */
        if ( keylen > peerblk->digestsize ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d %zd-byte secret too short "
                       "for %zd-bit key\n", peerblk, peerblk->segment,
                       peerblk->block, peerblk->digestsize, ( 8 * keylen ) );
                return -EPROTO;
        }

        /* Allocate cipher context, if applicable.  Freeing the cipher
         * context (on error or otherwise) is handled by peerblk_reset().
         */
        peerblk->cipher = cipher;
        assert ( peerblk->cipherctx == NULL );
        if ( cipher ) {
                peerblk->cipherctx = malloc ( cipher->ctxsize );
                if ( ! peerblk->cipherctx )
                        return -ENOMEM;
        }

        /* Initialise cipher, if applicable */
        if ( cipher &&
             ( rc = cipher_setkey ( cipher, peerblk->cipherctx, peerblk->secret,
                                    keylen ) ) != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d could not set key: %s\n",
                       peerblk, peerblk->segment, peerblk->block,
                       strerror ( rc ) );
                return rc;
        }

        return 0;
}

References __attribute__, aes_cbc_algorithm, assert(), peerdist_block::block, peerdist_block::buffer, peerdist_block::cipher, cipher_setkey(), peerdist_block::cipherctx, cipher_algorithm::ctxsize, xfer_buffer::data, DBGC, DBGC2, peerdist_block::digestsize, ENOMEM, ENOTSUP, EPROTO, ERANGE, hdr, htonl, len, xfer_buffer::len, malloc(), msg(), cipher_algorithm::name, ntohl, NULL, PEERDIST_MSG_AES_128_CBC, PEERDIST_MSG_AES_192_CBC, PEERDIST_MSG_AES_256_CBC, PEERDIST_MSG_BLK_TYPE, PEERDIST_MSG_PLAINTEXT, rc, peerdist_block::secret, peerdist_block::segment, and strerror().

Referenced by peerblk_retrieval_close().

peerblk_parse_block()

static int peerblk_parse_block ( struct peerdist_block *  peerblk, size_t *  buf_len  )

static

Parse retrieval protocol message segment and block details.

Parameters

peerblk	PeerDist block download
buf_len	Length of buffered data to fill in

Return values

rc	Return status code

Definition at line 878 of file peerblk.c.

                                                   {
        size_t digestsize = peerblk->digestsize;
        peerblk_msg_blk_t ( digestsize, 0, 0, 0 ) *msg = peerblk->buffer.data;
        size_t len = peerblk->buffer.len;
        size_t data_len;
        size_t total;

        /* Check message length */
        if ( len < offsetof ( typeof ( *msg ), msg.block.data ) ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d message too short for "
                       "zero-length data (%zd bytes)\n", peerblk,
                       peerblk->segment, peerblk->block, len );
                return -ERANGE;
        }

        /* Check digest size */
        if ( ntohl ( msg->msg.segment.segment.digestsize ) != digestsize ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d incorrect digest size %d\n",
                       peerblk, peerblk->segment, peerblk->block,
                       ntohl ( msg->msg.segment.segment.digestsize ) );
                return -EPROTO;
        }

        /* Check segment ID */
        if ( memcmp ( msg->msg.segment.id, peerblk->id, digestsize ) != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d segment ID mismatch\n",
                       peerblk, peerblk->segment, peerblk->block );
                return -EPROTO;
        }

        /* Check block ID */
        if ( ntohl ( msg->msg.index ) != peerblk->block ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d block ID mismatch (got %d)\n",
                       peerblk, peerblk->segment, peerblk->block,
                       ntohl ( msg->msg.index ) );
                return -EPROTO;
        }

        /* Check for missing blocks */
        data_len = be32_to_cpu ( msg->msg.block.block.len );
        if ( ! data_len ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d block not found\n",
                       peerblk, peerblk->segment, peerblk->block );
                return -ENOENT;
        }

        /* Check for underlength blocks */
        if ( data_len < ( peerblk->range.end - peerblk->range.start ) ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d underlength block (%zd "
                       "bytes)\n", peerblk, peerblk->segment, peerblk->block,
                       data_len );
                return -ERANGE;
        }

        /* Calculate buffered data length (i.e. excluding data which
         * was delivered to the final data transfer buffer).
         */
        *buf_len = ( data_len - ( peerblk->end - peerblk->start ) );

        /* Describe data before the trimmed content */
        peerblk->decrypt[PEERBLK_BEFORE].xferbuf = &peerblk->buffer;
        peerblk->decrypt[PEERBLK_BEFORE].offset =
                offsetof ( typeof ( *msg ), msg.block.data );
        peerblk->decrypt[PEERBLK_BEFORE].len =
                ( peerblk->start -
                  offsetof ( typeof ( *msg ), msg.block.data ) );
        total = peerblk->decrypt[PEERBLK_BEFORE].len;

        /* Describe data within the trimmed content */
        peerblk->decrypt[PEERBLK_DURING].offset =
                peerblk_offset ( peerblk, peerblk->start );
        peerblk->decrypt[PEERBLK_DURING].len =
                ( peerblk->end - peerblk->start );
        total += peerblk->decrypt[PEERBLK_DURING].len;

        /* Describe data after the trimmed content */
        peerblk->decrypt[PEERBLK_AFTER].xferbuf = &peerblk->buffer;
        peerblk->decrypt[PEERBLK_AFTER].offset = peerblk->start;
        peerblk->decrypt[PEERBLK_AFTER].len =
                ( offsetof ( typeof ( *msg ), msg.block.data )
                  + *buf_len - peerblk->start );
        total += peerblk->decrypt[PEERBLK_AFTER].len;

        /* Sanity check */
        assert ( total == be32_to_cpu ( msg->msg.block.block.len ) );

        /* Initialise cipher and digest lengths */
        peerblk->cipher_remaining = total;
        peerblk->digest_remaining =
                ( peerblk->range.end - peerblk->range.start );
        assert ( peerblk->cipher_remaining >= peerblk->digest_remaining );

        return 0;
}

References assert(), be32_to_cpu, peerdist_block::block, peerdist_block::buffer, peerdist_block::cipher_remaining, xfer_buffer::data, data_len, DBGC, peerdist_block::decrypt, peerdist_block::digest_remaining, digestsize, peerdist_block::digestsize, peerdist_block::end, peerdist_range::end, ENOENT, EPROTO, ERANGE, peerdist_block::id, len, xfer_buffer::len, peerdist_block_decrypt::len, memcmp(), msg(), ntohl, peerdist_block_decrypt::offset, offsetof, PEERBLK_AFTER, PEERBLK_BEFORE, PEERBLK_DURING, peerblk_msg_blk_t, peerblk_offset(), peerdist_block::range, peerdist_block::segment, peerdist_block::start, peerdist_range::start, typeof(), and peerdist_block_decrypt::xferbuf.

Referenced by peerblk_retrieval_close().

peerblk_parse_useless()

static int peerblk_parse_useless ( struct peerdist_block *  peerblk, size_t  buf_len, size_t *  vrf_len  )

static

Parse retrieval protocol message useless details.

Parameters

peerblk	PeerDist block download
buf_len	Length of buffered data
vrf_len	Length of uselessness to fill in

Return values

rc	Return status code

Definition at line 982 of file peerblk.c.

                                                                     {
        size_t digestsize = peerblk->digestsize;
        peerblk_msg_blk_t ( digestsize, buf_len, 0, 0 ) *msg =
                peerblk->buffer.data;
        size_t len = peerblk->buffer.len;

        /* Check message length */
        if ( len < offsetof ( typeof ( *msg ), msg.vrf.data ) ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d message too short for "
                       "zero-length uselessness (%zd bytes)\n", peerblk,
                       peerblk->segment, peerblk->block, len );
                return -ERANGE;
        }

        /* Extract length of uselessness */
        *vrf_len = be32_to_cpu ( msg->msg.vrf.vrf.len );

        return 0;
}

References be32_to_cpu, peerdist_block::block, peerdist_block::buffer, xfer_buffer::data, DBGC, digestsize, peerdist_block::digestsize, ERANGE, len, xfer_buffer::len, msg(), offsetof, peerblk_msg_blk_t, peerdist_block::segment, and typeof().

Referenced by peerblk_retrieval_close().

peerblk_parse_iv()

static int peerblk_parse_iv ( struct peerdist_block *  peerblk, size_t  buf_len, size_t  vrf_len  )

static

Parse retrieval protocol message initialisation vector details.

Parameters

peerblk	PeerDist block download
buf_len	Length of buffered data
vrf_len	Length of uselessness

Return values

rc	Return status code

Definition at line 1011 of file peerblk.c.

                                               {
        size_t digestsize = peerblk->digestsize;
        size_t blksize = peerblk->cipher->blocksize;
        peerblk_msg_blk_t ( digestsize, buf_len, vrf_len, blksize ) *msg =
                peerblk->buffer.data;
        size_t len = peerblk->buffer.len;

        /* Check message length */
        if ( len < sizeof ( *msg ) ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d message too short for "
                       "initialisation vector (%zd bytes)\n", peerblk,
                       peerblk->segment, peerblk->block, len );
                return -ERANGE;
        }

        /* Check initialisation vector size */
        if ( ntohl ( msg->msg.iv.iv.blksize ) != blksize ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d incorrect IV size %d\n",
                       peerblk, peerblk->segment, peerblk->block,
                       ntohl ( msg->msg.iv.iv.blksize ) );
                return -EPROTO;
        }

        /* Set initialisation vector */
        cipher_setiv ( peerblk->cipher, peerblk->cipherctx, msg->msg.iv.data,
                       blksize );

        return 0;
}

References blksize, peerdist_block::block, cipher_algorithm::blocksize, peerdist_block::buffer, peerdist_block::cipher, cipher_setiv(), peerdist_block::cipherctx, xfer_buffer::data, DBGC, digestsize, peerdist_block::digestsize, EPROTO, ERANGE, len, xfer_buffer::len, msg(), ntohl, peerblk_msg_blk_t, and peerdist_block::segment.

Referenced by peerblk_retrieval_close().

peerblk_decrypt_read()

static int peerblk_decrypt_read ( struct peerdist_block *  peerblk, void *  data, size_t  len  )

static

Read from decryption buffers.

Parameters

peerblk	PeerDist block download
data	Data buffer
len	Length to read

Return values

rc	Return status code

Definition at line 1050 of file peerblk.c.

                                                           {
        struct peerdist_block_decrypt *decrypt = peerblk->decrypt;
        size_t frag_len;
        int rc;

        /* Read from each decryption buffer in turn */
        for ( ; len ; decrypt++, data += frag_len, len -= frag_len ) {

                /* Calculate length to use from this buffer */
                frag_len = decrypt->len;
                if ( frag_len > len )
                        frag_len = len;
                if ( ! frag_len )
                        continue;

                /* Read from this buffer */
                if ( ( rc = xferbuf_read ( decrypt->xferbuf, decrypt->offset,
                                           data, frag_len ) ) != 0 )
                        return rc;
        }

        return 0;
}

References data, peerdist_block::decrypt, len, peerdist_block_decrypt::len, peerdist_block_decrypt::offset, rc, peerdist_block_decrypt::xferbuf, and xferbuf_read().

Referenced by peerblk_decrypt().

peerblk_decrypt_write()

static int peerblk_decrypt_write ( struct peerdist_block *  peerblk, const void *  data, size_t  len  )

static

Write to decryption buffers and update offsets and lengths.

Parameters

peerblk	PeerDist block download
data	Data buffer
len	Length to read

Return values

rc	Return status code

Definition at line 1083 of file peerblk.c.

                                                                  {
        struct peerdist_block_decrypt *decrypt = peerblk->decrypt;
        size_t frag_len;
        int rc;

        /* Write to each decryption buffer in turn */
        for ( ; len ; decrypt++, data += frag_len, len -= frag_len ) {

                /* Calculate length to use from this buffer */
                frag_len = decrypt->len;
                if ( frag_len > len )
                        frag_len = len;
                if ( ! frag_len )
                        continue;

                /* Write to this buffer */
                if ( ( rc = xferbuf_write ( decrypt->xferbuf, decrypt->offset,
                                            data, frag_len ) ) != 0 )
                        return rc;

                /* Update offset and length */
                decrypt->offset += frag_len;
                decrypt->len -= frag_len;
        }

        return 0;
}

References data, peerdist_block::decrypt, len, peerdist_block_decrypt::len, peerdist_block_decrypt::offset, rc, peerdist_block_decrypt::xferbuf, and xferbuf_write().

Referenced by peerblk_decrypt().

peerblk_decrypt()

static void peerblk_decrypt ( struct peerdist_block *  peerblk )

static

Decrypt one chunk of PeerDist retrieval protocol data.

Parameters

peerblk

PeerDist block download

Definition at line 1117 of file peerblk.c.

                                                               {
        struct cipher_algorithm *cipher = peerblk->cipher;
        struct digest_algorithm *digest = peerblk->digest;
        struct xfer_buffer *xferbuf;
        size_t cipher_len;
        size_t digest_len;
        void *data;
        int rc;

        /* Sanity check */
        assert ( ( PEERBLK_DECRYPT_CHUNKSIZE % cipher->blocksize ) == 0 );

        /* Get the underlying data transfer buffer */
        xferbuf = xfer_buffer ( &peerblk->xfer );
        if ( ! xferbuf ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d has no underlying data "
                       "transfer buffer\n", peerblk, peerblk->segment,
                       peerblk->block );
                rc = -ENOTSUP;
                goto err_xfer_buffer;
        }
        peerblk->decrypt[PEERBLK_DURING].xferbuf = xferbuf;

        /* Calculate cipher and digest lengths */
        cipher_len = PEERBLK_DECRYPT_CHUNKSIZE;
        if ( cipher_len > peerblk->cipher_remaining )
                cipher_len = peerblk->cipher_remaining;
        digest_len = cipher_len;
        if ( digest_len > peerblk->digest_remaining )
                digest_len = peerblk->digest_remaining;
        assert ( ( cipher_len & ( cipher->blocksize - 1 ) ) == 0 );

        /* Allocate temporary data buffer */
        data = malloc ( cipher_len );
        if ( ! data ) {
                rc = -ENOMEM;
                goto err_alloc_data;
        }

        /* Read ciphertext */
        if ( ( rc = peerblk_decrypt_read ( peerblk, data, cipher_len ) ) != 0 ){
                DBGC ( peerblk, "PEERBLK %p %d.%d could not read ciphertext: "
                       "%s\n", peerblk, peerblk->segment, peerblk->block,
                       strerror ( rc ) );
                goto err_read;
        }

        /* Decrypt data */
        cipher_decrypt ( cipher, peerblk->cipherctx, data, data, cipher_len );

        /* Add data to digest */
        digest_update ( digest, peerblk->digestctx, data, digest_len );

        /* Write plaintext */
        if ( ( rc = peerblk_decrypt_write ( peerblk, data, cipher_len ) ) != 0){
                DBGC ( peerblk, "PEERBLK %p %d.%d could not write plaintext: "
                       "%s\n", peerblk, peerblk->segment, peerblk->block,
                       strerror ( rc ) );
                goto err_write;
        }

        /* Consume input */
        peerblk->cipher_remaining -= cipher_len;
        peerblk->digest_remaining -= digest_len;

        /* Free temporary data buffer */
        free ( data );

        /* Continue processing until all input is consumed */
        if ( peerblk->cipher_remaining )
                return;

        /* Complete download attempt */
        peerblk_done ( peerblk, 0 );
        return;

 err_write:
 err_read:
        free ( data );
 err_alloc_data:
 err_xfer_buffer:
        peerblk_done ( peerblk, rc );
}

References assert(), peerdist_block::block, cipher_algorithm::blocksize, peerdist_block::cipher, cipher_decrypt, peerdist_block::cipher_remaining, peerdist_block::cipherctx, data, DBGC, peerdist_block::decrypt, peerdist_block::digest, peerdist_block::digest_remaining, digest_update(), peerdist_block::digestctx, ENOMEM, ENOTSUP, free, malloc(), PEERBLK_DECRYPT_CHUNKSIZE, peerblk_decrypt_read(), peerblk_decrypt_write(), peerblk_done(), PEERBLK_DURING, rc, peerdist_block::segment, strerror(), peerdist_block::xfer, xfer_buffer(), and peerdist_block_decrypt::xferbuf.

peerblk_retrieval_close()

static void peerblk_retrieval_close ( struct peerdist_block *  peerblk, int  rc  )

static

Close PeerDist retrieval protocol block download attempt.

Parameters

peerblk	PeerDist block download
rc	Reason for close

Definition at line 1207 of file peerblk.c.

                                                                               {
        size_t buf_len;
        size_t vrf_len;

        /* Restart interface */
        intf_restart ( &peerblk->retrieval, rc );

        /* Fail immediately if we have an error */
        if ( rc != 0 )
                goto done;

        /* Abort download attempt (for testing) if applicable */
        if ( ( rc = inject_fault ( PEERBLK_ABORT_RATE ) ) != 0 )
                goto done;

        /* Parse message header */
        if ( ( rc = peerblk_parse_header ( peerblk ) ) != 0 )
                goto done;

        /* Parse message segment and block details */
        if ( ( rc = peerblk_parse_block ( peerblk, &buf_len ) ) != 0 )
                goto done;

        /* If the block was plaintext, then there is nothing more to do */
        if ( ! peerblk->cipher )
                goto done;

        /* Parse message useless details */
        if ( ( rc = peerblk_parse_useless ( peerblk, buf_len, &vrf_len ) ) != 0)
                goto done;

        /* Parse message initialisation vector details */
        if ( ( rc = peerblk_parse_iv ( peerblk, buf_len, vrf_len ) ) != 0 )
                goto done;

        /* Fail if decryption length is not aligned to the cipher block size */
        if ( peerblk->cipher_remaining & ( peerblk->cipher->blocksize - 1 ) ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d unaligned data length %zd\n",
                       peerblk, peerblk->segment, peerblk->block,
                       peerblk->cipher_remaining );
                rc = -EPROTO;
                goto done;
        }

        /* Stop the download attempt timer: there is no point in
         * timing out while decrypting.
         */
        stop_timer ( &peerblk->timer );

        /* Start decryption process */
        process_add ( &peerblk->process );
        return;

 done:
        /* Complete download attempt */
        peerblk_done ( peerblk, rc );
}

References peerdist_block::block, cipher_algorithm::blocksize, peerdist_block::cipher, peerdist_block::cipher_remaining, DBGC, done, EPROTO, intf_restart(), PEERBLK_ABORT_RATE, peerblk_done(), peerblk_parse_block(), peerblk_parse_header(), peerblk_parse_iv(), peerblk_parse_useless(), peerdist_block::process, process_add(), rc, peerdist_block::retrieval, peerdist_block::segment, stop_timer(), and peerdist_block::timer.

peerblk_expired()

static void peerblk_expired ( struct retry_timer *  timer, int over  __unused  )

static

Handle PeerDist retry timer expiry.

Parameters

timer	Retry timer
over	Failure indicator

Definition at line 1278 of file peerblk.c.

                                                                             {
        struct peerdist_block *peerblk =
                container_of ( timer, struct peerdist_block, timer );
        struct peerdisc_segment *segment = peerblk->discovery.segment;
        struct peerdisc_peer *head;
        unsigned long now = peerblk_timestamp();
        const char *location;
        int rc;

        /* Profile discovery timeout, if applicable */
        if ( ( peerblk->peer == NULL ) && ( timer->timeout != 0 ) ) {
                profile_custom ( &peerblk_discovery_timeout_profiler,
                                 ( now - peerblk->started ) );
                DBGC ( peerblk, "PEERBLK %p %d.%d discovery timed out after "
                       "%ld ticks\n", peerblk, peerblk->segment,
                       peerblk->block, timer->timeout );
        }

        /* Profile download timeout, if applicable */
        if ( ( peerblk->peer != NULL ) && ( timer->timeout != 0 ) ) {
                profile_custom ( &peerblk_attempt_timeout_profiler,
                                 ( now - peerblk->attempted ) );
                DBGC ( peerblk, "PEERBLK %p %d.%d timed out after %ld ticks\n",
                       peerblk, peerblk->segment, peerblk->block,
                       timer->timeout );
        }

        /* Abort any current download attempt */
        peerblk_reset ( peerblk, -ETIMEDOUT );

        /* Record attempt start time */
        peerblk->attempted = now;

        /* If we have exceeded our maximum number of attempt cycles
         * (each cycle comprising a retrieval protocol download from
         * each peer in the list followed by a raw download from the
         * origin server), then abort the overall download.
         */
        head = list_entry ( &segment->peers, struct peerdisc_peer, list );
        if ( ( peerblk->peer == head ) &&
             ( ++peerblk->cycles >= PEERBLK_MAX_ATTEMPT_CYCLES ) ) {
                rc = peerblk->rc;
                assert ( rc != 0 );
                goto err;
        }

        /* If we have not yet made any download attempts, then move to
         * the start of the peer list.
         */
        if ( peerblk->peer == NULL )
                peerblk->peer = head;

        /* Attempt retrieval protocol download from next usable peer */
        list_for_each_entry_continue ( peerblk->peer, &segment->peers, list ) {

                /* Attempt retrieval protocol download from this peer */
                location = peerblk->peer->location;
                if ( ( rc = peerblk_retrieval_open ( peerblk,
                                                     location ) ) != 0 ) {
                        /* Non-fatal: continue to try next peer */
                        continue;
                }

                /* Peer download started */
                return;
        }

        /* Add to raw download queue */
        peerblk_enqueue ( peerblk, &peerblk_raw_queue );

        return;

 err:
        peerblk_close ( peerblk, rc );
}

References assert(), peerdist_block::attempted, peerdist_block::block, container_of, peerdist_block::cycles, DBGC, peerdist_block::discovery, ETIMEDOUT, head, peerdisc_peer::list, list_entry, list_for_each_entry_continue, peerdisc_peer::location, NULL, peerdist_block::peer, peerblk_close(), peerblk_enqueue(), PEERBLK_MAX_ATTEMPT_CYCLES, peerblk_raw_queue, peerblk_reset(), peerblk_retrieval_open(), peerblk_timestamp(), profile_custom(), peerdist_block::rc, rc, peerdisc_client::segment, peerdist_block::segment, segment, and peerdist_block::started.

Referenced by peerblk_open().

peerblk_discovered()

static void peerblk_discovered ( struct peerdisc_client *  discovery )

static

Handle PeerDist peer discovery.

Parameters

discovery

PeerDist discovery client

Definition at line 1359 of file peerblk.c.

                                                                     {
        struct peerdist_block *peerblk =
                container_of ( discovery, struct peerdist_block, discovery );
        unsigned long now = peerblk_timestamp();

        /* Do nothing unless we are still waiting for the initial
         * discovery timeout.
         */
        if ( ( peerblk->peer != NULL ) || ( peerblk->timer.timeout == 0 ) )
                return;

        /* Schedule an immediate retry */
        start_timer_nodelay ( &peerblk->timer );

        /* Profile discovery success */
        profile_custom ( &peerblk_discovery_success_profiler,
                         ( now - peerblk->started ) );
}

References container_of, peerdist_block::discovery, NULL, peerdist_block::peer, peerblk_timestamp(), profile_custom(), start_timer_nodelay(), peerdist_block::started, retry_timer::timeout, and peerdist_block::timer.

peerblk_open()

int peerblk_open	(	struct interface *	xfer,
		struct uri *	uri,
		struct peerdist_info_block *	block
	)

Open PeerDist block download.

Parameters

xfer	Data transfer interface
uri	Original URI
info	Content information block

Return values

rc	Return status code

Definition at line 1432 of file peerblk.c.

                                                       {
        const struct peerdist_info_segment *segment = block->segment;
        const struct peerdist_info *info = segment->info;
        struct digest_algorithm *digest = info->digest;
        struct peerdist_block *peerblk;
        unsigned long timeout;
        size_t digestsize;
        int rc;

        /* Allocate and initialise structure */
        peerblk = zalloc ( sizeof ( *peerblk ) + digest->ctxsize );
        if ( ! peerblk ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        ref_init ( &peerblk->refcnt, peerblk_free );
        intf_init ( &peerblk->xfer, &peerblk_xfer_desc, &peerblk->refcnt );
        intf_init ( &peerblk->raw, &peerblk_raw_desc, &peerblk->refcnt );
        intf_init ( &peerblk->retrieval, &peerblk_retrieval_desc,
                    &peerblk->refcnt );
        peerblk->uri = uri_get ( uri );
        memcpy ( &peerblk->range, &block->range, sizeof ( peerblk->range ) );
        memcpy ( &peerblk->trim, &block->trim, sizeof ( peerblk->trim ) );
        peerblk->offset = ( block->trim.start - info->trim.start );
        peerblk->digest = info->digest;
        peerblk->digestsize = digestsize = info->digestsize;
        peerblk->digestctx = ( ( ( void * ) peerblk ) + sizeof ( *peerblk ) );
        peerblk->segment = segment->index;
        memcpy ( peerblk->id, segment->id, sizeof ( peerblk->id ) );
        memcpy ( peerblk->secret, segment->secret, sizeof ( peerblk->secret ) );
        peerblk->block = block->index;
        memcpy ( peerblk->hash, block->hash, sizeof ( peerblk->hash ) );
        xferbuf_malloc_init ( &peerblk->buffer );
        process_init_stopped ( &peerblk->process, &peerblk_process_desc,
                               &peerblk->refcnt );
        peerdisc_init ( &peerblk->discovery, &peerblk_discovery_operations );
        INIT_LIST_HEAD ( &peerblk->queued );
        timer_init ( &peerblk->timer, peerblk_expired, &peerblk->refcnt );
        DBGC2 ( peerblk, "PEERBLK %p %d.%d id %02x%02x%02x%02x%02x..."
                "%02x%02x%02x [%08zx,%08zx)", peerblk, peerblk->segment,
                peerblk->block, peerblk->id[0], peerblk->id[1], peerblk->id[2],
                peerblk->id[3], peerblk->id[4], peerblk->id[ digestsize - 3 ],
                peerblk->id[ digestsize - 2 ], peerblk->id[ digestsize - 1 ],
                peerblk->range.start, peerblk->range.end );
        if ( ( peerblk->trim.start != peerblk->range.start ) ||
             ( peerblk->trim.end != peerblk->range.end ) ) {
                DBGC2 ( peerblk, " covers [%08zx,%08zx)",
                        peerblk->trim.start, peerblk->trim.end );
        }
        DBGC2 ( peerblk, "\n" );

        /* Open discovery */
        if ( ( rc = peerdisc_open ( &peerblk->discovery, peerblk->id,
                                    peerblk->digestsize ) ) != 0 )
                goto err_open_discovery;

        /* Schedule a retry attempt either immediately (if we already
         * have some peers) or after the discovery timeout.
         */
        timeout = ( list_empty ( &peerblk->discovery.segment->peers ) ?
                    ( peerdisc_timeout_secs * TICKS_PER_SEC ) : 0 );
        start_timer_fixed ( &peerblk->timer, timeout );

        /* Record start time */
        peerblk->started = peerblk_timestamp();

        /* Attach to parent interface, mortalise self, and return */
        intf_plug_plug ( xfer, &peerblk->xfer );
        ref_put ( &peerblk->refcnt );
        return 0;

 err_open_discovery:
        peerblk_close ( peerblk, rc );
 err_alloc:
        return rc;
}

References block, peerdist_block::block, peerdist_block::buffer, digest_algorithm::ctxsize, DBGC2, peerdist_block::digest, peerdist_block::digestctx, digestsize, peerdist_block::digestsize, peerdist_block::discovery, peerdist_range::end, ENOMEM, peerdist_block::hash, peerdist_block::id, info, INIT_LIST_HEAD, intf_init(), intf_plug_plug(), list_empty, memcpy(), peerdist_block::offset, peerblk_close(), peerblk_discovery_operations, peerblk_expired(), peerblk_free(), peerblk_process_desc, peerblk_raw_desc, peerblk_retrieval_desc, peerblk_timestamp(), peerblk_xfer_desc, peerdisc_init(), peerdisc_open(), peerdisc_timeout_secs, peerdisc_segment::peers, peerdist_block::process, process_init_stopped(), peerdist_block::queued, peerdist_block::range, peerdist_block::raw, rc, ref_init, ref_put, peerdist_block::refcnt, peerdist_block::retrieval, peerdist_block::secret, peerdisc_client::segment, peerdist_block::segment, segment, peerdist_range::start, start_timer_fixed(), peerdist_block::started, TICKS_PER_SEC, timeout(), peerdist_block::timer, peerdist_block::trim, peerdist_block::uri, uri_get(), peerdist_block::xfer, xferbuf_malloc_init(), and zalloc().

Referenced by peermux_step().

Variable Documentation

__profiler

struct profiler peerblk_discovery_timeout_profiler __profiler

static

Initial value:

=
        { .name = "peerblk.download" }

PeerDist block download profiler.

PeerDist block download discovery timeout profiler.

PeerDist block download discovery success profiler.

PeerDist block download attempt timeout profiler.

PeerDist block download attempt failure profiler.

PeerDist block download attempt success profiler.

Definition at line 106 of file peerblk.c.

peerblk_queue_desc

struct process_descriptor peerblk_queue_desc

static

Initial value:

=
        PROC_DESC_ONCE ( struct peerdist_block_queue, process, peerblk_step )

PeerDist block download queue process descriptor.

Definition at line 559 of file peerblk.c.

peerblk_raw_queue

struct peerdist_block_queue peerblk_raw_queue

static

Initial value:

= {
        .process = PROC_INIT ( peerblk_raw_queue.process, &peerblk_queue_desc ),
        .list = LIST_HEAD_INIT ( peerblk_raw_queue.list ),
        .max = PEERBLK_RAW_MAX,
        .open = peerblk_raw_open,
}

Raw block download queue.

Definition at line 563 of file peerblk.c.

Referenced by peerblk_expired().

peerblk_xfer_operations

struct interface_operation peerblk_xfer_operations[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct peerdist_block *, peerblk_close ),
}

PeerDist block download data transfer interface operations.

Definition at line 1386 of file peerblk.c.

peerblk_xfer_desc

struct interface_descriptor peerblk_xfer_desc

static

Initial value:

=
        INTF_DESC ( struct peerdist_block, xfer, peerblk_xfer_operations )

PeerDist block download data transfer interface descriptor.

Definition at line 1391 of file peerblk.c.

Referenced by peerblk_open().

peerblk_raw_operations

struct interface_operation peerblk_raw_operations[]

static

Initial value:

= {
        INTF_OP ( xfer_deliver, struct peerdist_block *, peerblk_raw_rx ),
        INTF_OP ( intf_close, struct peerdist_block *, peerblk_raw_close ),
}

PeerDist block download raw data interface operations.

Definition at line 1395 of file peerblk.c.

peerblk_raw_desc

struct interface_descriptor peerblk_raw_desc

static

Initial value:

=
        INTF_DESC ( struct peerdist_block, raw, peerblk_raw_operations )

PeerDist block download raw data interface descriptor.

Definition at line 1401 of file peerblk.c.

Referenced by peerblk_open().

peerblk_retrieval_operations

struct interface_operation peerblk_retrieval_operations[]

static

Initial value:

= {
        INTF_OP ( xfer_deliver, struct peerdist_block *, peerblk_retrieval_rx ),
        INTF_OP ( intf_close, struct peerdist_block *, peerblk_retrieval_close),
}

PeerDist block download retrieval protocol interface operations.

Definition at line 1405 of file peerblk.c.

peerblk_retrieval_desc

struct interface_descriptor peerblk_retrieval_desc

static

Initial value:

=
        INTF_DESC ( struct peerdist_block, retrieval,
                    peerblk_retrieval_operations )

PeerDist block download retrieval protocol interface descriptor.

Definition at line 1411 of file peerblk.c.

Referenced by peerblk_open().

peerblk_process_desc

struct process_descriptor peerblk_process_desc

static

Initial value:

=
        PROC_DESC ( struct peerdist_block, process, peerblk_decrypt )

PeerDist block download decryption process descriptor.

Definition at line 1416 of file peerblk.c.

Referenced by peerblk_open().

peerblk_discovery_operations

struct peerdisc_client_operations peerblk_discovery_operations

static

Initial value:

= {
        .discovered = peerblk_discovered,
}

PeerDist block download discovery operations.

Definition at line 1420 of file peerblk.c.

Referenced by peerblk_open().