pccrc.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 <errno.h>
#include <assert.h>
#include <ipxe/sha256.h>
#include <ipxe/sha512.h>
#include <ipxe/hmac.h>
#include <ipxe/base16.h>
#include <ipxe/pccrc.h>
 
/** @file
 *
 * Peer Content Caching and Retrieval: Content Identification [MS-PCCRC]
 *
 */
 
/******************************************************************************
 *
 * Utility functions
 *
 ******************************************************************************
 */
 
/**
 * Transcribe hash value (for debugging)
 *
 * @v info              Content information
 * @v hash              Hash value
 * @ret string          Hash value string
 */
static inline const char *
peerdist_info_hash_ntoa ( const struct peerdist_info *info, const void *hash ) {
        static char buf[ ( 2 * PEERDIST_DIGEST_MAX_SIZE ) + 1 /* NUL */ ];
        size_t digestsize = info->digestsize;
 
        /* Sanity check */
        assert ( info != NULL );
        assert ( digestsize != 0 );
        assert ( base16_encoded_len ( digestsize ) < sizeof ( buf ) );
 
        /* Transcribe hash value */
        base16_encode ( hash, digestsize, buf, sizeof ( buf ) );
        return buf;
}
 
/**
 * Get raw data
 *
 * @v info              Content information
 * @v data              Data buffer
 * @v offset            Starting offset
 * @v len               Length
 * @ret rc              Return status code
 */
static int peerdist_info_get ( const struct peerdist_info *info, void *data,
                               size_t offset, size_t len ) {
 
        /* Sanity check */
        if ( ( offset > info->raw.len ) ||
             ( len > ( info->raw.len - offset ) ) ) {
                DBGC ( info, "PCCRC %p data underrun at [%zx,%zx) of %zx\n",
                       info, offset, ( offset + len ), info->raw.len );
                return -ERANGE;
        }
 
        /* Copy data */
        memcpy ( data, ( info->raw.data + offset ), len );
 
        return 0;
}
 
/**
 * Populate segment hashes
 *
 * @v segment           Content information segment to fill in
 * @v hash              Segment hash of data
 * @v secret            Segment secret
 */
static void peerdist_info_segment_hash ( struct peerdist_info_segment *segment,
                                         const void *hash, const void *secret ){
        const struct peerdist_info *info = segment->info;
        struct digest_algorithm *digest = info->digest;
        uint8_t ctx[ hmac_ctxsize ( digest ) ];
        size_t digestsize = info->digestsize;
        static const uint16_t magic[] = PEERDIST_SEGMENT_ID_MAGIC;
 
        /* Sanity check */
        assert ( digestsize <= sizeof ( segment->hash ) );
        assert ( digestsize <= sizeof ( segment->secret ) );
        assert ( digestsize <= sizeof ( segment->id ) );
 
        /* Get segment hash of data */
        memcpy ( segment->hash, hash, digestsize );
 
        /* Get segment secret */
        memcpy ( segment->secret, secret, digestsize );
 
        /* Calculate segment identifier */
        hmac_init ( digest, ctx, segment->secret, digestsize );
        hmac_update ( digest, ctx, segment->hash, digestsize );
        hmac_update ( digest, ctx, magic, sizeof ( magic ) );
        hmac_final ( digest, ctx, segment->id );
}
 
/******************************************************************************
 *
 * Content Information version 1
 *
 ******************************************************************************
 */
 
/**
 * Get number of blocks within a block description
 *
 * @v info              Content information
 * @v offset            Block description offset
 * @ret blocks          Number of blocks, or negative error
 */
static int peerdist_info_v1_blocks ( const struct peerdist_info *info,
                                     size_t offset ) {
        struct peerdist_info_v1_block raw;
        unsigned int blocks;
        int rc;
 
        /* Get block description header */
        if ( ( rc = peerdist_info_get ( info, &raw, offset,
                                        sizeof ( raw ) ) ) != 0 )
                return rc;
 
        /* Calculate number of blocks */
        blocks = le32_to_cpu ( raw.blocks );
 
        return blocks;
}
 
/**
 * Locate block description
 *
 * @v info              Content information
 * @v index             Segment index
 * @ret offset          Block description offset, or negative error
 */
static ssize_t peerdist_info_v1_block_offset ( const struct peerdist_info *info,
                                               unsigned int index ) {
        size_t digestsize = info->digestsize;
        unsigned int i;
        size_t offset;
        int blocks;
        int rc;
 
        /* Sanity check */
        assert ( index < info->segments );
 
        /* Calculate offset of first block description */
        offset = ( sizeof ( struct peerdist_info_v1 ) +
                   ( info->segments *
                     sizeof ( peerdist_info_v1_segment_t ( digestsize ) ) ) );
 
        /* Iterate over block descriptions until we find this segment */
        for ( i = 0 ; i < index ; i++ ) {
 
                /* Get number of blocks */
                blocks = peerdist_info_v1_blocks ( info, offset );
                if ( blocks < 0 ) {
                        rc = blocks;
                        DBGC ( info, "PCCRC %p segment %d could not get number "
                               "of blocks: %s\n", info, i, strerror ( rc ) );
                        return rc;
                }
 
                /* Move to next block description */
                offset += sizeof ( peerdist_info_v1_block_t ( digestsize,
                                                              blocks ) );
        }
 
        return offset;
}
 
/**
 * Populate content information
 *
 * @v info              Content information to fill in
 * @ret rc              Return status code
 */
static int peerdist_info_v1 ( struct peerdist_info *info ) {
        struct peerdist_info_v1 raw;
        struct peerdist_info_segment first;
        struct peerdist_info_segment last;
        size_t first_skip;
        size_t last_skip;
        size_t last_read;
        int rc;
 
        /* Get raw header */
        if ( ( rc = peerdist_info_get ( info, &raw, 0, sizeof ( raw ) ) ) != 0){
                DBGC ( info, "PCCRC %p could not get V1 content information: "
                       "%s\n", info, strerror ( rc ) );
                return rc;
        }
        assert ( raw.version.raw == cpu_to_le16 ( PEERDIST_INFO_V1 ) );
 
        /* Determine hash algorithm */
        switch ( raw.hash ) {
        case cpu_to_le32 ( PEERDIST_INFO_V1_HASH_SHA256 ) :
                info->digest = &sha256_algorithm;
                break;
        case cpu_to_le32 ( PEERDIST_INFO_V1_HASH_SHA384 ) :
                info->digest = &sha384_algorithm;
                break;
        case cpu_to_le32 ( PEERDIST_INFO_V1_HASH_SHA512 ) :
                info->digest = &sha512_algorithm;
                break;
        default:
                DBGC ( info, "PCCRC %p unsupported hash algorithm %#08x\n",
                       info, le32_to_cpu ( raw.hash ) );
                return -ENOTSUP;
        }
        info->digestsize = info->digest->digestsize;
        assert ( info->digest != NULL );
        DBGC2 ( info, "PCCRC %p using %s[%zd]\n",
                info, info->digest->name, ( info->digestsize * 8 ) );
 
        /* Calculate number of segments */
        info->segments = le32_to_cpu ( raw.segments );
 
        /* Get first segment */
        if ( ( rc = peerdist_info_segment ( info, &first, 0 ) ) != 0 )
                return rc;
 
        /* Calculate range start offset */
        info->range.start = first.range.start;
 
        /* Calculate trimmed range start offset */
        first_skip = le32_to_cpu ( raw.first );
        info->trim.start = ( first.range.start + first_skip );
 
        /* Get last segment */
        if ( ( rc = peerdist_info_segment ( info, &last,
                                            ( info->segments - 1 ) ) ) != 0 )
                return rc;
 
        /* Calculate range end offset */
        info->range.end = last.range.end;
 
        /* Calculate trimmed range end offset */
        if ( raw.last ) {
                /* Explicit length to include from last segment is given */
                last_read = le32_to_cpu ( raw.last );
                last_skip = ( last.index ? 0 : first_skip );
                info->trim.end = ( last.range.start + last_skip + last_read );
        } else {
                /* No explicit length given: range extends to end of segment */
                info->trim.end = last.range.end;
        }
 
        return 0;
}
 
/**
 * Populate content information segment
 *
 * @v segment           Content information segment to fill in
 * @ret rc              Return status code
 */
static int peerdist_info_v1_segment ( struct peerdist_info_segment *segment ) {
        const struct peerdist_info *info = segment->info;
        size_t digestsize = info->digestsize;
        peerdist_info_v1_segment_t ( digestsize ) raw;
        ssize_t raw_offset;
        int blocks;
        int rc;
 
        /* Sanity checks */
        assert ( segment->index < info->segments );
 
        /* Get raw description */
        raw_offset = ( sizeof ( struct peerdist_info_v1 ) +
                       ( segment->index * sizeof ( raw ) ) );
        if ( ( rc = peerdist_info_get ( info, &raw, raw_offset,
                                        sizeof ( raw ) ) ) != 0 ) {
                DBGC ( info, "PCCRC %p segment %d could not get segment "
                       "description: %s\n", info, segment->index,
                       strerror ( rc ) );
                return rc;
        }
 
        /* Calculate start offset of this segment */
        segment->range.start = le64_to_cpu ( raw.segment.offset );
 
        /* Calculate end offset of this segment */
        segment->range.end = ( segment->range.start +
                               le32_to_cpu ( raw.segment.len ) );
 
        /* Calculate block size of this segment */
        segment->blksize = le32_to_cpu ( raw.segment.blksize );
 
        /* Locate block description for this segment */
        raw_offset = peerdist_info_v1_block_offset ( info, segment->index );
        if ( raw_offset < 0 ) {
                rc = raw_offset;
                return rc;
        }
 
        /* Get number of blocks */
        blocks = peerdist_info_v1_blocks ( info, raw_offset );
        if ( blocks < 0 ) {
                rc = blocks;
                DBGC ( info, "PCCRC %p segment %d could not get number of "
                       "blocks: %s\n", info, segment->index, strerror ( rc ) );
                return rc;
        }
        segment->blocks = blocks;
 
        /* Calculate segment hashes */
        peerdist_info_segment_hash ( segment, raw.hash, raw.secret );
 
        return 0;
}
 
/**
 * Populate content information block
 *
 * @v block             Content information block to fill in
 * @ret rc              Return status code
 */
static int peerdist_info_v1_block ( struct peerdist_info_block *block ) {
        const struct peerdist_info_segment *segment = block->segment;
        const struct peerdist_info *info = segment->info;
        size_t digestsize = info->digestsize;
        peerdist_info_v1_block_t ( digestsize, segment->blocks ) raw;
        ssize_t raw_offset;
        int rc;
 
        /* Sanity checks */
        assert ( block->index < segment->blocks );
 
        /* Calculate start offset of this block */
        block->range.start = ( segment->range.start +
                               ( block->index * segment->blksize ) );
 
        /* Calculate end offset of this block */
        block->range.end = ( block->range.start + segment->blksize );
        if ( block->range.end > segment->range.end )
                block->range.end = segment->range.end;
 
        /* Locate block description */
        raw_offset = peerdist_info_v1_block_offset ( info, segment->index );
        if ( raw_offset < 0 ) {
                rc = raw_offset;
                return rc;
        }
 
        /* Get block hash */
        raw_offset += offsetof ( typeof ( raw ), hash[block->index] );
        if ( ( rc = peerdist_info_get ( info, block->hash, raw_offset,
                                        digestsize ) ) != 0 ) {
                DBGC ( info, "PCCRC %p segment %d block %d could not get "
                       "hash: %s\n", info, segment->index, block->index,
                       strerror ( rc ) );
                return rc;
        }
 
        return 0;
}
 
/** Content information version 1 operations */
static struct peerdist_info_operations peerdist_info_v1_operations = {
        .info = peerdist_info_v1,
        .segment = peerdist_info_v1_segment,
        .block = peerdist_info_v1_block,
};
 
/******************************************************************************
 *
 * Content Information version 2
 *
 ******************************************************************************
 */
 
/** A segment cursor */
struct peerdist_info_v2_cursor {
        /** Raw data offset */
        size_t offset;
        /** Number of segments remaining within this chunk */
        unsigned int remaining;
        /** Accumulated segment length */
        size_t len;
};
 
/**
 * Initialise segment cursor
 *
 * @v cursor            Segment cursor
 */
static inline void
peerdist_info_v2_cursor_init ( struct peerdist_info_v2_cursor *cursor ) {
 
        /* Initialise cursor */
        cursor->offset = ( sizeof ( struct peerdist_info_v2 ) +
                           sizeof ( struct peerdist_info_v2_chunk ) );
        cursor->remaining = 0;
        cursor->len = 0;
}
 
/**
 * Update segment cursor to next segment description
 *
 * @v info              Content information
 * @v offset            Current offset
 * @v remaining         Number of segments remaining within this chunk
 * @ret rc              Return status code
 */
static int
peerdist_info_v2_cursor_next ( const struct peerdist_info *info,
                               struct peerdist_info_v2_cursor *cursor ) {
        size_t digestsize = info->digestsize;
        peerdist_info_v2_segment_t ( digestsize ) raw;
        struct peerdist_info_v2_chunk chunk;
        int rc;
 
        /* Get chunk description if applicable */
        if ( ! cursor->remaining ) {
 
                /* Get chunk description */
                if ( ( rc = peerdist_info_get ( info, &chunk,
                                                ( cursor->offset -
                                                  sizeof ( chunk ) ),
                                                sizeof ( chunk ) ) ) != 0 )
                        return rc;
 
                /* Update number of segments remaining */
                cursor->remaining = ( be32_to_cpu ( chunk.len ) /
                                      sizeof ( raw ) );
        }
 
        /* Get segment description header */
        if ( ( rc = peerdist_info_get ( info, &raw.segment, cursor->offset,
                                        sizeof ( raw.segment ) ) ) != 0 )
                return rc;
 
        /* Update cursor */
        cursor->offset += sizeof ( raw );
        cursor->remaining--;
        if ( ! cursor->remaining )
                cursor->offset += sizeof ( chunk );
        cursor->len += be32_to_cpu ( raw.segment.len );
 
        return 0;
}
 
/**
 * Get number of segments and total length
 *
 * @v info              Content information
 * @v len               Length to fill in
 * @ret rc              Number of segments, or negative error
 */
static int peerdist_info_v2_segments ( const struct peerdist_info *info,
                                       size_t *len ) {
        struct peerdist_info_v2_cursor cursor;
        unsigned int segments;
        int rc;
 
        /* Iterate over all segments */
        for ( peerdist_info_v2_cursor_init ( &cursor ), segments = 0 ;
              cursor.offset < info->raw.len ; segments++ ) {
 
                /* Update segment cursor */
                if ( ( rc = peerdist_info_v2_cursor_next ( info,
                                                           &cursor ) ) != 0 ) {
                        DBGC ( info, "PCCRC %p segment %d could not update "
                               "segment cursor: %s\n",
                               info, segments, strerror ( rc ) );
                        return rc;
                }
        }
 
        /* Record accumulated length */
        *len = cursor.len;
 
        return segments;
}
 
/**
 * Populate content information
 *
 * @v info              Content information to fill in
 * @ret rc              Return status code
 */
static int peerdist_info_v2 ( struct peerdist_info *info ) {
        struct peerdist_info_v2 raw;
        size_t len = 0;
        int segments;
        int rc;
 
        /* Get raw header */
        if ( ( rc = peerdist_info_get ( info, &raw, 0, sizeof ( raw ) ) ) != 0){
                DBGC ( info, "PCCRC %p could not get V2 content information: "
                       "%s\n", info, strerror ( rc ) );
                return rc;
        }
        assert ( raw.version.raw == cpu_to_le16 ( PEERDIST_INFO_V2 ) );
 
        /* Determine hash algorithm */
        switch ( raw.hash ) {
        case PEERDIST_INFO_V2_HASH_SHA512_TRUNC :
                info->digest = &sha512_algorithm;
                info->digestsize = ( 256 / 8 );
                break;
        default:
                DBGC ( info, "PCCRC %p unsupported hash algorithm %#02x\n",
                       info, raw.hash );
                return -ENOTSUP;
        }
        assert ( info->digest != NULL );
        DBGC2 ( info, "PCCRC %p using %s[%zd]\n",
                info, info->digest->name, ( info->digestsize * 8 ) );
 
        /* Calculate number of segments and total length */
        segments = peerdist_info_v2_segments ( info, &len );
        if ( segments < 0 ) {
                rc = segments;
                DBGC ( info, "PCCRC %p could not get segment count and length: "
                       "%s\n", info, strerror ( rc ) );
                return rc;
        }
        info->segments = segments;
 
        /* Calculate range start offset */
        info->range.start = be64_to_cpu ( raw.offset );
 
        /* Calculate trimmed range start offset */
        info->trim.start = ( info->range.start + be32_to_cpu ( raw.first ) );
 
        /* Calculate range end offset */
        info->range.end = ( info->range.start + len );
 
        /* Calculate trimmed range end offset */
        info->trim.end = ( raw.len ? be64_to_cpu ( raw.len ) :
                           info->range.end );
 
        return 0;
}
 
/**
 * Populate content information segment
 *
 * @v segment           Content information segment to fill in
 * @ret rc              Return status code
 */
static int peerdist_info_v2_segment ( struct peerdist_info_segment *segment ) {
        const struct peerdist_info *info = segment->info;
        size_t digestsize = info->digestsize;
        peerdist_info_v2_segment_t ( digestsize ) raw;
        struct peerdist_info_v2_cursor cursor;
        unsigned int index;
        size_t len;
        int rc;
 
        /* Sanity checks */
        assert ( segment->index < info->segments );
 
        /* Iterate over all segments before the target segment */
        for ( peerdist_info_v2_cursor_init ( &cursor ), index = 0 ;
              index < segment->index ; index++ ) {
 
                /* Update segment cursor */
                if ( ( rc = peerdist_info_v2_cursor_next ( info,
                                                           &cursor ) ) != 0 ) {
                        DBGC ( info, "PCCRC %p segment %d could not update "
                               "segment cursor: %s\n",
                               info, index, strerror ( rc ) );
                        return rc;
                }
        }
 
        /* Get raw description */
        if ( ( rc = peerdist_info_get ( info, &raw, cursor.offset,
                                        sizeof ( raw ) ) ) != 0 ) {
                DBGC ( info, "PCCRC %p segment %d could not get segment "
                       "description: %s\n",
                       info, segment->index, strerror ( rc ) );
                return rc;
        }
 
        /* Calculate start offset of this segment */
        segment->range.start = ( info->range.start + cursor.len );
 
        /* Calculate end offset of this segment */
        len = be32_to_cpu ( raw.segment.len );
        segment->range.end = ( segment->range.start + len );
 
        /* Model as a segment containing a single block */
        segment->blocks = 1;
        segment->blksize = len;
 
        /* Calculate segment hashes */
        peerdist_info_segment_hash ( segment, raw.hash, raw.secret );
 
        return 0;
}
 
/**
 * Populate content information block
 *
 * @v block             Content information block to fill in
 * @ret rc              Return status code
 */
static int peerdist_info_v2_block ( struct peerdist_info_block *block ) {
        const struct peerdist_info_segment *segment = block->segment;
        const struct peerdist_info *info = segment->info;
        size_t digestsize = info->digestsize;
 
        /* Sanity checks */
        assert ( block->index < segment->blocks );
 
        /* Model as a block covering the whole segment */
        memcpy ( &block->range, &segment->range, sizeof ( block->range ) );
        memcpy ( block->hash, segment->hash, digestsize );
 
        return 0;
}
 
/** Content information version 2 operations */
static struct peerdist_info_operations peerdist_info_v2_operations = {
        .block = peerdist_info_v2_block,
        .segment = peerdist_info_v2_segment,
        .info = peerdist_info_v2,
};
 
/******************************************************************************
 *
 * Content Information
 *
 ******************************************************************************
 */
 
/**
 * Populate content information
 *
 * @v data              Raw data
 * @v len               Length of raw data
 * @v info              Content information to fill in
 * @ret rc              Return status code
 */
int peerdist_info ( const void *data, size_t len,
                    struct peerdist_info *info ) {
        union peerdist_info_version version;
        int rc;
 
        /* Initialise structure */
        memset ( info, 0, sizeof ( *info ) );
        info->raw.data = data;
        info->raw.len = len;
 
        /* Get version */
        if ( ( rc = peerdist_info_get ( info, &version, 0,
                                        sizeof ( version ) ) ) != 0 ) {
                DBGC ( info, "PCCRC %p could not get version: %s\n",
                       info, strerror ( rc ) );
                return rc;
        }
        DBGC2 ( info, "PCCRC %p version %d.%d\n",
                info, version.major, version.minor );
 
        /* Determine version */
        switch ( version.raw ) {
        case cpu_to_le16 ( PEERDIST_INFO_V1 ) :
                info->op = &peerdist_info_v1_operations;
                break;
        case cpu_to_le16 ( PEERDIST_INFO_V2 ) :
                info->op = &peerdist_info_v2_operations;
                break;
        default:
                DBGC ( info, "PCCRC %p unsupported version %d.%d\n",
                       info, version.major, version.minor );
                return -ENOTSUP;
        }
        assert ( info->op != NULL );
        assert ( info->op->info != NULL );
 
        /* Populate content information */
        if ( ( rc = info->op->info ( info ) ) != 0 )
                return rc;
 
        DBGC2 ( info, "PCCRC %p range [%08zx,%08zx) covers [%08zx,%08zx) with "
                "%d segments\n", info, info->range.start, info->range.end,
                info->trim.start, info->trim.end, info->segments );
        return 0;
}
 
/**
 * Populate content information segment
 *
 * @v info              Content information
 * @v segment           Content information segment to fill in
 * @v index             Segment index
 * @ret rc              Return status code
 */
int peerdist_info_segment ( const struct peerdist_info *info,
                            struct peerdist_info_segment *segment,
                            unsigned int index ) {
        int rc;
 
        /* Sanity checks */
        assert ( info != NULL );
        assert ( info->op != NULL );
        assert ( info->op->segment != NULL );
        if ( index >= info->segments ) {
                DBGC ( info, "PCCRC %p segment %d of [0,%d) out of range\n",
                       info, index, info->segments );
                return -ERANGE;
        }
 
        /* Initialise structure */
        memset ( segment, 0, sizeof ( *segment ) );
        segment->info = info;
        segment->index = index;
 
        /* Populate content information segment */
        if ( ( rc = info->op->segment ( segment ) ) != 0 )
                return rc;
 
        DBGC2 ( info, "PCCRC %p segment %d range [%08zx,%08zx) with %d "
                "blocks\n", info, segment->index, segment->range.start,
                segment->range.end, segment->blocks );
        DBGC2 ( info, "PCCRC %p segment %d digest %s\n", info, segment->index,
                peerdist_info_hash_ntoa ( info, segment->hash ) );
        DBGC2 ( info, "PCCRC %p segment %d secret %s\n", info, segment->index,
                peerdist_info_hash_ntoa ( info, segment->secret ) );
        DBGC2 ( info, "PCCRC %p segment %d identf %s\n", info, segment->index,
                peerdist_info_hash_ntoa ( info, segment->id ) );
        return 0;
}
 
/**
 * Populate content information block
 *
 * @v segment           Content information segment
 * @v block             Content information block to fill in
 * @v index             Block index
 * @ret rc              Return status code
 */
int peerdist_info_block ( const struct peerdist_info_segment *segment,
                          struct peerdist_info_block *block,
                          unsigned int index ) {
        const struct peerdist_info *info = segment->info;
        size_t start;
        size_t end;
        int rc;
 
        /* Sanity checks */
        assert ( segment != NULL );
        assert ( info != NULL );
        assert ( info->op != NULL );
        assert ( info->op->block != NULL );
        if ( index >= segment->blocks ) {
                DBGC ( info, "PCCRC %p segment %d block %d of [0,%d) out of "
                       "range\n", info, segment->index, index, segment->blocks);
                return -ERANGE;
        }
 
        /* Initialise structure */
        memset ( block, 0, sizeof ( *block ) );
        block->segment = segment;
        block->index = index;
 
        /* Populate content information block */
        if ( ( rc = info->op->block ( block ) ) != 0 )
                return rc;
 
        /* Calculate trimmed range */
        start = block->range.start;
        if ( start < info->trim.start )
                start = info->trim.start;
        end = block->range.end;
        if ( end > info->trim.end )
                end = info->trim.end;
        if ( end < start )
                end = start;
        block->trim.start = start;
        block->trim.end = end;
 
        DBGC2 ( info, "PCCRC %p segment %d block %d hash %s\n",
                info, segment->index, block->index,
                peerdist_info_hash_ntoa ( info, block->hash ) );
        DBGC2 ( info, "PCCRC %p segment %d block %d range [%08zx,%08zx) covers "
                "[%08zx,%08zx)\n", info, segment->index, block->index,
                block->range.start, block->range.end, block->trim.start,
                block->trim.end );
        return 0;
}