peerblk.c

Go to the documentation of this file.

/*
 * 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 <stdio.h>
#include <string.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>
 
/** @file
 *
 * Peer Content Caching and Retrieval (PeerDist) protocol block downloads
 *
 */
 
/** PeerDist decryption chunksize
 *
 * This is a policy decision.
 */
#define PEERBLK_DECRYPT_CHUNKSIZE 2048
 
/** 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.
 */
#define PEERBLK_RAW_MAX 2
 
/** PeerDist raw block download attempt initial progress timeout
 *
 * This is a policy decision.
 */
#define PEERBLK_RAW_OPEN_TIMEOUT ( 10 * TICKS_PER_SEC )
 
/** PeerDist raw block download attempt ongoing progress timeout
 *
 * This is a policy decision.
 */
#define PEERBLK_RAW_RX_TIMEOUT ( 15 * TICKS_PER_SEC )
 
/** PeerDist retrieval protocol block download attempt initial progress timeout
 *
 * This is a policy decision.
 */
#define PEERBLK_RETRIEVAL_OPEN_TIMEOUT ( 3 * TICKS_PER_SEC )
 
/** PeerDist retrieval protocol block download attempt ongoing progress timeout
 *
 * This is a policy decision.
 */
#define PEERBLK_RETRIEVAL_RX_TIMEOUT ( 5 * TICKS_PER_SEC )
 
/** 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.
 */
#define PEERBLK_MAX_ATTEMPT_CYCLES 4
 
/** PeerDist block download profiler */
static struct profiler peerblk_download_profiler __profiler =
        { .name = "peerblk.download" };
 
/** PeerDist block download attempt success profiler */
static struct profiler peerblk_attempt_success_profiler __profiler =
        { .name = "peerblk.attempt.success" };
 
/** PeerDist block download attempt failure profiler */
static struct profiler peerblk_attempt_failure_profiler __profiler =
        { .name = "peerblk.attempt.failure" };
 
/** PeerDist block download attempt timeout profiler */
static struct profiler peerblk_attempt_timeout_profiler __profiler =
        { .name = "peerblk.attempt.timeout" };
 
/** PeerDist block download discovery success profiler */
static struct profiler peerblk_discovery_success_profiler __profiler =
        { .name = "peerblk.discovery.success" };
 
/** PeerDist block download discovery timeout profiler */
static struct profiler peerblk_discovery_timeout_profiler __profiler =
        { .name = "peerblk.discovery.timeout" };
 
static void peerblk_dequeue ( struct peerdist_block *peerblk );
 
/**
 * Get profiling timestamp
 *
 * @ret timestamp       Timestamp
 */
static inline __attribute__ (( always_inline )) unsigned long
peerblk_timestamp ( void ) {
 
        if ( PROFILING ) {
                return currticks();
        } else {
                return 0;
        }
}
 
/**
 * Free PeerDist block download
 *
 * @v refcnt            Reference count
 */
static void peerblk_free ( struct refcnt *refcnt ) {
        struct peerdist_block *peerblk =
                container_of ( refcnt, struct peerdist_block, refcnt );
 
        uri_put ( peerblk->uri );
        free ( peerblk->cipherctx );
        free ( peerblk );
}
 
/**
 * Reset PeerDist block download attempt
 *
 * @v peerblk           PeerDist block download
 * @v rc                Reason for reset
 */
static void peerblk_reset ( struct peerdist_block *peerblk, int rc ) {
 
        /* 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 );
}
 
/**
 * Close PeerDist block download
 *
 * @v peerblk           PeerDist block download
 * @v rc                Reason for close
 */
static void peerblk_close ( struct peerdist_block *peerblk, int rc ) {
        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 );
}
 
/**
 * Calculate offset within overall download
 *
 * @v peerblk           PeerDist block download
 * @v pos               Position within incoming data stream
 * @ret offset          Offset within overall download
 */
static inline __attribute__ (( always_inline )) size_t
peerblk_offset ( struct peerdist_block *peerblk, size_t pos ) {
 
        return ( ( pos - peerblk->start ) + peerblk->offset );
}
 
/**
 * Deliver download attempt data block
 *
 * @v peerblk           PeerDist block download
 * @v iobuf             I/O buffer
 * @v meta              Original data transfer metadata
 * @v pos               Position within incoming data stream
 * @ret rc              Return status code
 */
static int peerblk_deliver ( struct peerdist_block *peerblk,
                             struct io_buffer *iobuf,
                             struct xfer_metadata *meta, size_t pos ) {
        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;
}
 
/**
 * Finish PeerDist block download attempt
 *
 * @v peerblk           PeerDist block download
 * @v rc                Reason for close
 */
static void peerblk_done ( struct peerdist_block *peerblk, int rc ) {
        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 );
}
 
/******************************************************************************
 *
 * Raw block download attempts (using an HTTP range request)
 *
 ******************************************************************************
 */
 
/**
 * Open PeerDist raw block download attempt
 *
 * @v peerblk           PeerDist block download
 * @ret rc              Return status code
 */
static int peerblk_raw_open ( struct peerdist_block *peerblk ) {
        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;
}
 
/**
 * Receive PeerDist raw data
 *
 * @v peerblk           PeerDist block download
 * @v iobuf             I/O buffer
 * @v meta              Data transfer metadata
 * @ret rc              Return status code
 */
static int peerblk_raw_rx ( struct peerdist_block *peerblk,
                            struct io_buffer *iobuf,
                            struct xfer_metadata *meta ) {
        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;
}
 
/**
 * Close PeerDist raw block download attempt
 *
 * @v peerblk           PeerDist block download
 * @v rc                Reason for close
 */
static void peerblk_raw_close ( struct peerdist_block *peerblk, int rc ) {
 
        /* 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 );
}
 
/******************************************************************************
 *
 * Block download queue
 *
 ******************************************************************************
 */
 
/**
 * PeerDist block download queue process
 *
 * @v queue             Block download queue
 */
static void peerblk_step ( struct peerdist_block_queue *queue ) {
        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++;
}
 
/**
 * Add block to download queue
 *
 * @v peerblk           PeerDist block download
 * @v queue             Block download queue
 */
static void peerblk_enqueue ( struct peerdist_block *peerblk,
                              struct peerdist_block_queue *queue ) {
 
        /* 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 );
}
 
/**
 * Remove block from download queue
 *
 * @v peerblk           PeerDist block download
 */
static void peerblk_dequeue ( struct peerdist_block *peerblk ) {
        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 );
        }
}
 
/** PeerDist block download queue process descriptor */
static struct process_descriptor peerblk_queue_desc =
        PROC_DESC_ONCE ( struct peerdist_block_queue, process, peerblk_step );
 
/** Raw block download queue */
static struct peerdist_block_queue peerblk_raw_queue = {
        .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,
};
 
/******************************************************************************
 *
 * Retrieval protocol block download attempts
 *
 ******************************************************************************
 */
 
/**
 * Open PeerDist retrieval protocol block download attempt
 *
 * @v peerblk           PeerDist block download
 * @v retrieval         Retrieval protocol
 * @v location          Peer location
 * @ret rc              Return status code
 */
static int peerblk_retrieval_open ( struct peerdist_block *peerblk,
                                    struct peerdist_retrieval *retrieval,
                                    const char *location ) {
        size_t digestsize = peerblk->digestsize;
        peerblk_msg_blk_t ( digestsize, 0, 0, 0 ) *rsp;
        int rc;
 
        DBGC2 ( peerblk, "PEERBLK %p %d.%d attempting %s retrieval from %s\n",
                peerblk, peerblk->segment, peerblk->block, retrieval->name,
                location );
 
        /* Open connection */
        if ( ( rc = retrieval->open ( &peerblk->retrieval, location,
                                      digestsize, peerblk->id,
                                      peerblk->block ) ) != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d could not create %s "
                       "retrieval request: %s\n", peerblk, peerblk->segment,
                       peerblk->block, retrieval->name, strerror ( rc ) );
                return rc;
        }
 
        /* Update trim thresholds for retrieval protocol format */
        peerblk->start += offsetof ( typeof ( *rsp ), msg.vrf );
        peerblk->end += offsetof ( typeof ( *rsp ), msg.vrf );
 
        /* Annul 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 );
 
        return 0;
}
 
/**
 * Receive PeerDist retrieval protocol data
 *
 * @v peerblk           PeerDist block download
 * @v iobuf             I/O buffer
 * @v meta              Data transfer metadata
 * @ret rc              Return status code
 */
static int peerblk_retrieval_rx ( struct peerdist_block *peerblk,
                                  struct io_buffer *iobuf,
                                  struct xfer_metadata *meta ) {
        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;
}
 
/**
 * Parse retrieval protocol message header
 *
 * @v peerblk           PeerDist block download
 * @ret rc              Return status code
 */
static int peerblk_parse_header ( struct peerdist_block *peerblk ) {
        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;
}
 
/**
 * Parse retrieval protocol message segment and block details
 *
 * @v peerblk           PeerDist block download
 * @v buf_len           Length of buffered data to fill in
 * @ret rc              Return status code
 */
static int peerblk_parse_block ( struct peerdist_block *peerblk,
                                 size_t *buf_len ) {
        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;
}
 
/**
 * Parse retrieval protocol message useless details
 *
 * @v peerblk           PeerDist block download
 * @v buf_len           Length of buffered data
 * @v vrf_len           Length of uselessness to fill in
 * @ret rc              Return status code
 */
static int peerblk_parse_useless ( struct peerdist_block *peerblk,
                                   size_t buf_len, size_t *vrf_len ) {
        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;
}
 
/**
 * Parse retrieval protocol message initialisation vector details
 *
 * @v peerblk           PeerDist block download
 * @v buf_len           Length of buffered data
 * @v vrf_len           Length of uselessness
 * @ret rc              Return status code
 */
static int peerblk_parse_iv ( struct peerdist_block *peerblk, size_t buf_len,
                              size_t vrf_len ) {
        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;
        size_t ivlen;
        int rc;
 
        /* 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;
        }
        ivlen = ntohl ( msg->msg.iv.iv.blksize );
 
        /* Set initialisation vector */
        if ( ( rc = cipher_setiv ( peerblk->cipher, peerblk->cipherctx,
                                   msg->msg.iv.data, ivlen ) ) != 0 ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d could not set IV: %s\n",
                       peerblk, peerblk->segment, peerblk->block,
                       strerror ( rc ) );
                return rc;
        }
 
        return 0;
}
 
/**
 * Read from decryption buffers
 *
 * @v peerblk           PeerDist block download
 * @v data              Data buffer
 * @v len               Length to read
 * @ret rc              Return status code
 */
static int peerblk_decrypt_read ( struct peerdist_block *peerblk,
                                  void *data, size_t len ) {
        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;
}
 
/**
 * Write to decryption buffers and update offsets and lengths
 *
 * @v peerblk           PeerDist block download
 * @v data              Data buffer
 * @v len               Length to read
 * @ret rc              Return status code
 */
static int peerblk_decrypt_write ( struct peerdist_block *peerblk,
                                   const void *data, size_t len ) {
        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;
}
 
/**
 * Decrypt one chunk of PeerDist retrieval protocol data
 *
 * @v peerblk           PeerDist block download
 */
static void peerblk_decrypt ( struct peerdist_block *peerblk ) {
        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 checks */
        assert ( ( PEERBLK_DECRYPT_CHUNKSIZE % cipher->blocksize ) == 0 );
        if ( peerblk->cipher_remaining & ( cipher->blocksize - 1 ) ) {
                DBGC ( peerblk, "PEERBLK %p %d.%d has invalid length %zd\n",
                       peerblk, peerblk->segment, peerblk->block,
                       peerblk->cipher_remaining );
                rc = -EINVAL;
                goto err_blocksize;
        }
 
        /* 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:
 err_blocksize:
        peerblk_done ( peerblk, rc );
}
 
/**
 * Close PeerDist retrieval protocol block download attempt
 *
 * @v peerblk           PeerDist block download
 * @v rc                Reason for close
 */
static void peerblk_retrieval_close ( struct peerdist_block *peerblk, int rc ) {
        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 );
}
 
/******************************************************************************
 *
 * Retry policy
 *
 ******************************************************************************
 */
 
/**
 * Handle PeerDist retry timer expiry
 *
 * @v timer             Retry timer
 * @v over              Failure indicator
 */
static void peerblk_expired ( struct retry_timer *timer, int over __unused ) {
        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();
        struct peerdist_retrieval *retrieval;
        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 */
                retrieval = peerblk->peer->retrieval;
                location = peerblk->peer->location;
                if ( ( rc = peerblk_retrieval_open ( peerblk, retrieval,
                                                     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 );
}
 
/**
 * Handle PeerDist peer discovery
 *
 * @v discovery         PeerDist discovery client
 */
static void peerblk_discovered ( struct peerdisc_client *discovery ) {
        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 ) );
}
 
/******************************************************************************
 *
 * Opener
 *
 ******************************************************************************
 */
 
/** PeerDist block download data transfer interface operations */
static struct interface_operation peerblk_xfer_operations[] = {
        INTF_OP ( intf_close, struct peerdist_block *, peerblk_close ),
};
 
/** PeerDist block download data transfer interface descriptor */
static struct interface_descriptor peerblk_xfer_desc =
        INTF_DESC ( struct peerdist_block, xfer, peerblk_xfer_operations );
 
/** PeerDist block download raw data interface operations */
static struct interface_operation peerblk_raw_operations[] = {
        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 descriptor */
static struct interface_descriptor peerblk_raw_desc =
        INTF_DESC ( struct peerdist_block, raw, peerblk_raw_operations );
 
/** PeerDist block download retrieval protocol interface operations */
static struct interface_operation peerblk_retrieval_operations[] = {
        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 descriptor */
static struct interface_descriptor peerblk_retrieval_desc =
        INTF_DESC ( struct peerdist_block, retrieval,
                    peerblk_retrieval_operations );
 
/** PeerDist block download decryption process descriptor */
static struct process_descriptor peerblk_process_desc =
        PROC_DESC ( struct peerdist_block, process, peerblk_decrypt );
 
/** PeerDist block download discovery operations */
static struct peerdisc_client_operations peerblk_discovery_operations = {
        .discovered = peerblk_discovered,
};
 
/**
 * Open PeerDist block download
 *
 * @v xfer              Data transfer interface
 * @v uri               Original URI
 * @v info              Content information block
 * @ret rc              Return status code
 */
int peerblk_open ( struct interface *xfer, struct uri *uri,
                   struct peerdist_info_block *block ) {
        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;
}