[peerdist] Include trimmed range within content information block

Signed-off-by: Michael Brown <mcb30@ipxe.org>

src/include/ipxe/pccrc.h

 	 * Note that this range may exceed the overall content range.
 	 */
 	struct peerdist_range range;
+	/** Trimmed content range */
+	struct peerdist_range trim;
 	/** Block hash */
 	uint8_t hash[PEERDIST_DIGEST_MAX_SIZE];
 };

src/net/pccrc.c

 	if ( ( rc = info->op->segment ( segment ) ) != 0 )
 		return rc;
 
-	DBGC2 ( info, "PCCRC %p segment %d covers [%08zx,%08zx) with %d "
+	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,
 			  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 */
 	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 covers [%08zx,%08zx)\n",
-		info, segment->index, block->index, block->range.start,
-		block->range.end );
+	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;
 }

src/tests/pccrc_test.c

 /** Define inline raw data */
 #define DATA(...) { __VA_ARGS__ }
 
+/**
+ * Define an inline content range
+ *
+ * @v START		Start offset
+ * @v END		End offset
+ * @ret range		Content range
+ */
+#define RANGE( START, END ) { .start = START, .end = END }
+
+/**
+ * Define an inline trimmed content range
+ *
+ * @v START		Start offset
+ * @v END		End offset
+ * @ret trim		Trimmed content range
+ */
+#define TRIM( START, END ) { .start = START, .end = END }
+
 /** A content information test */
 struct peerdist_info_test {
 	/** Raw content information */
 	struct digest_algorithm *expected_digest;
 	/** Expected digest size */
 	size_t expected_digestsize;
+	/** Expected content range */
+	struct peerdist_range expected_range;
 	/** Expected trimmed content range */
 	struct peerdist_range expected_trim;
 	/** Expected number of segments */
  * @v DATA		Raw content information
  * @v DIGEST		Expected digest algorithm
  * @v DIGESTSIZE	Expected digest size
- * @v START		Expected trimmed content range start offset
- * @v END		Expected trimmed content range end offset
+ * @v RANGE		Expected content range
+ * @v TRIM		Expected trimmer content range
  * @v SEGMENTS		Expected number of segments
  * @ret test		Content information test
  *
  *   X-P2P-PeerDist: Version=1.1
  *   X-P2P-PeerDistEx: MinContentInformation=2.0, MaxContentInformation=2.0
  */
-#define PEERDIST_INFO_TEST( name, DATA, DIGEST, DIGESTSIZE, START, END,	\
-			    SEGMENTS )					\
+#define PEERDIST_INFO_TEST( name, DATA, DIGEST, DIGESTSIZE, RANGE,	\
+			    TRIM, SEGMENTS )				\
 	static const uint8_t name ## _data[] = DATA;			\
 	static struct peerdist_info_test name = {			\
 		.data = name ## _data,					\
 		.len = sizeof ( name ## _data ),			\
 		.expected_digest = DIGEST,				\
 		.expected_digestsize = DIGESTSIZE,			\
-		.expected_trim = {					\
-			.start = START,					\
-			.end = END,					\
-		},							\
+		.expected_range = RANGE,				\
+		.expected_trim = TRIM,					\
 		.expected_segments = SEGMENTS,				\
 	}
 
  *
  * @v name		Test name
  * @v INDEX		Segment index
- * @v START		Expected content range start offset
- * @v END		Expected content range end offset
+ * @v RANGE		Expected content range
  * @v BLOCKS		Expected number of blocks
  * @v BLKSIZE		Expected block size
  * @v HASH		Expected segment hash of data
  * @v ID		Expected segment identifier
  * @ret test		Content information segment test
  */
-#define PEERDIST_INFO_SEGMENT_TEST( name, INDEX, START, END, BLOCKS,	\
+#define PEERDIST_INFO_SEGMENT_TEST( name, INDEX, RANGE, BLOCKS,		\
 				    BLKSIZE, HASH, SECRET, ID )		\
 	static struct peerdist_info_segment_test name = {		\
 		.index = INDEX,						\
-		.expected_range = {					\
-			.start = START,					\
-			.end = END,					\
-		},							\
+		.expected_range = RANGE,				\
 		.expected_blocks = BLOCKS,				\
 		.expected_blksize = BLKSIZE,				\
 		.expected_hash = HASH,					\
 	unsigned int index;
 	/** Expected content range */
 	struct peerdist_range expected_range;
+	/** Expected trimmed content range */
+	struct peerdist_range expected_trim;
 	/** Expected hash of data */
 	uint8_t expected_hash[PEERDIST_DIGEST_MAX_SIZE];
 };
  *
  * @v name		Test name
  * @v INDEX		Block index
- * @v START		Expected content range start offset
- * @v END		Expected content range end offset
+ * @v RANGE		Expected content range
+ * @v TRIM		Expected trimmed content range
  * @v HASH		Expected hash of data
  * @ret test		Content information block test
  */
-#define PEERDIST_INFO_BLOCK_TEST( name, INDEX, START, END, HASH )	\
+#define PEERDIST_INFO_BLOCK_TEST( name, INDEX, RANGE, TRIM, HASH )	\
 	static struct peerdist_info_block_test name = {			\
 		.index = INDEX,						\
-		.expected_range = {					\
-			.start = START,					\
-			.end = END,					\
-		},							\
+		.expected_range = RANGE,				\
+		.expected_trim = TRIM,					\
 		.expected_hash = HASH,					\
 	}
 
 	       0xaf, 0xe4, 0x57, 0xa9, 0x50, 0x3b, 0x45, 0x48, 0xf6, 0x6e, 0xd3,
 	       0xb1, 0x88, 0xdc, 0xfd, 0xa0, 0xac, 0x38, 0x2b, 0x09, 0x71, 0x1a,
 	       0xcc ),
-	&sha256_algorithm, 32, 0, 99710, 1 );
+	&sha256_algorithm, 32, RANGE ( 0, 99710 ), TRIM ( 0, 99710 ), 1 );
 
 /** IIS logo (iis-85.png) content information version 1 segment 0 */
 PEERDIST_INFO_SEGMENT_TEST ( iis_85_png_v1_s0, 0,
-	0, 99710, 2, 65536,
+	RANGE ( 0, 99710 ), 2, 65536,
 	DATA ( 0xd8, 0xd9, 0x76, 0x35, 0x4a, 0x48, 0x72, 0xe9, 0x25, 0x76, 0x18,
 	       0x03, 0xf4, 0x58, 0xd9, 0xda, 0xaa, 0x67, 0xf8, 0xe3, 0x1c, 0x63,
 	       0x0f, 0xb7, 0x4e, 0x6a, 0x31, 0x2e, 0xf8, 0xa2, 0x5a, 0xba ),
 
 /** IIS logo (iis-85.png) content information version 1 segment 0 block 0 */
 PEERDIST_INFO_BLOCK_TEST ( iis_85_png_v1_s0_b0, 0,
-	0, 65536,
+	RANGE ( 0, 65536 ),
+	TRIM ( 0, 65536 ),
 	DATA ( 0x73, 0xc1, 0x8a, 0xb8, 0x54, 0x91, 0x10, 0xf8, 0xe9, 0x0e, 0x71,
 	       0xbb, 0xc3, 0xab, 0x2a, 0xa8, 0xc4, 0x4d, 0x13, 0xf4, 0x92, 0x94,
 	       0x99, 0x25, 0x5b, 0x66, 0x0f, 0x24, 0xec, 0x77, 0x80, 0x0b ) );
 
 /** IIS logo (iis-85.png) content information version 1 segment 0 block 1 */
 PEERDIST_INFO_BLOCK_TEST ( iis_85_png_v1_s0_b1, 1,
-	65536, 99710,
+	RANGE ( 65536, 99710 ),
+	TRIM ( 65536, 99710 ),
 	DATA ( 0x97, 0x4b, 0xdd, 0x65, 0x56, 0x7f, 0xde, 0xec, 0xcd, 0xaf, 0xe4,
 	       0x57, 0xa9, 0x50, 0x3b, 0x45, 0x48, 0xf6, 0x6e, 0xd3, 0xb1, 0x88,
 	       0xdc, 0xfd, 0xa0, 0xac, 0x38, 0x2b, 0x09, 0x71, 0x1a, 0xcc ) );
 	       0x77, 0x83, 0xe4, 0xf8, 0x07, 0x64, 0x7b, 0x63, 0xf1, 0x46, 0xb5,
 	       0x2f, 0x4a, 0xc8, 0x9c, 0xcc, 0x7a, 0xbf, 0x5f, 0xa1, 0x1a, 0xca,
 	       0xfc, 0x2a, 0xcf, 0x50, 0x28, 0x58, 0x6c ),
-	&sha512_algorithm, 32, 0, 99710, 2 );
+	&sha512_algorithm, 32, RANGE ( 0, 99710 ), TRIM ( 0, 99710 ), 2 );
 
 /** IIS logo (iis-85.png) content information version 2 segment 0 */
 PEERDIST_INFO_SEGMENT_TEST ( iis_85_png_v2_s0, 0,
-	0, 39390, 1, 39390,
+	RANGE ( 0, 39390 ), 1, 39390,
 	DATA ( 0xe0, 0xd0, 0xc3, 0x58, 0xe2, 0x68, 0x4b, 0x62, 0x33, 0x0d, 0x32,
 	       0xb5, 0xf1, 0x97, 0x87, 0x24, 0xa0, 0xd0, 0xa5, 0x2b, 0xdc, 0x5e,
 	       0x78, 0x1f, 0xae, 0x71, 0xff, 0x57, 0xa8, 0xbe, 0x3d, 0xd4 ),
 
 /** IIS logo (iis-85.png) content information version 2 segment 0 block 0 */
 PEERDIST_INFO_BLOCK_TEST ( iis_85_png_v2_s0_b0, 0,
-	0, 39390,
+	RANGE ( 0, 39390 ),
+	TRIM ( 0, 39390 ),
 	DATA ( 0xe0, 0xd0, 0xc3, 0x58, 0xe2, 0x68, 0x4b, 0x62, 0x33, 0x0d, 0x32,
 	       0xb5, 0xf1, 0x97, 0x87, 0x24, 0xa0, 0xd0, 0xa5, 0x2b, 0xdc, 0x5e,
 	       0x78, 0x1f, 0xae, 0x71, 0xff, 0x57, 0xa8, 0xbe, 0x3d, 0xd4 ) );
 
 /** IIS logo (iis-85.png) content information version 2 segment 1 */
 PEERDIST_INFO_SEGMENT_TEST ( iis_85_png_v2_s1, 1,
-	39390, 99710, 1, 60320,
+	RANGE ( 39390, 99710 ), 1, 60320,
 	DATA ( 0x33, 0x81, 0xd0, 0xd0, 0xcb, 0x74, 0xf4, 0xb6, 0x13, 0xd8, 0x21,
 	       0x0f, 0x37, 0xf0, 0x02, 0xa0, 0x6f, 0x39, 0x10, 0x58, 0x60, 0x96,
 	       0xa1, 0x30, 0xd3, 0x43, 0x98, 0xc0, 0x8e, 0x66, 0xd7, 0xbc ),
 
 /** IIS logo (iis-85.png) content information version 2 segment 1 block 0 */
 PEERDIST_INFO_BLOCK_TEST ( iis_85_png_v2_s1_b0, 0,
-	39390, 99710,
+	RANGE ( 39390, 99710 ),
+	TRIM ( 39390, 99710 ),
 	DATA ( 0x33, 0x81, 0xd0, 0xd0, 0xcb, 0x74, 0xf4, 0xb6, 0x13, 0xd8, 0x21,
 	       0x0f, 0x37, 0xf0, 0x02, 0xa0, 0x6f, 0x39, 0x10, 0x58, 0x60, 0x96,
 	       0xa1, 0x30, 0xd3, 0x43, 0x98, 0xc0, 0x8e, 0x66, 0xd7, 0xbc ) );
 	okx ( info->raw.len == test->len, file, line );
 	okx ( info->digest == test->expected_digest, file, line );
 	okx ( info->digestsize == test->expected_digestsize, file, line );
-	okx ( info->trim.start >= info->range.start, file, line );
+	okx ( info->range.start == test->expected_range.start, file, line );
+	okx ( info->range.end == test->expected_range.end, file, line );
 	okx ( info->trim.start == test->expected_trim.start, file, line );
-	okx ( info->trim.end <= info->range.end, file, line );
 	okx ( info->trim.end == test->expected_trim.end, file, line );
+	okx ( info->trim.start >= info->range.start, file, line );
+	okx ( info->trim.end <= info->range.end, file, line );
 	okx ( info->segments == test->expected_segments, file, line );
 }
 #define peerdist_info_ok( test, info ) \
 	okx ( block->index == test->index, file, line );
 	okx ( block->range.start == test->expected_range.start, file, line );
 	okx ( block->range.end == test->expected_range.end, file, line );
+	okx ( block->trim.start == test->expected_trim.start, file, line );
+	okx ( block->trim.end == test->expected_trim.end, file, line );
 	okx ( memcmp ( block->hash, test->expected_hash,
 		       digestsize ) == 0, file, line );
 }