fix: pass correct chunk index to checkChunkSize in getContents

In getContents, checkChunkSize was called with idx (reqChunks[from])
but the chunk file was opened for availableChunks[index]. These can be
different values, causing incorrect size validation — especially for the
last chunk which has a different (smaller) expected size.

Fixes omalloc/tavern#issue

Co-authored-by: sendya <5404542+sendya@users.noreply.github.com>

Author: Copilot

server/middleware/caching/caching_chunkpart_test.go

@@ -90,3 +90,74 @@ func Test_getContents(t *testing.T) {
 	// 所以最终会返回一个流，包含 chunk1 和 chunk2 的数据
 	assert.Equal(t, 1, len(readers))
 }
+
+// Test_getContents_lastChunkSizeMismatch verifies that checkChunkSize receives
+// the correct chunk index (availableChunks[index]) rather than the requested
+// chunk index (idx). When the available anchor chunk is the last chunk with a
+// smaller size, passing the wrong index would cause a false size-mismatch error.
+func Test_getContents_lastChunkSizeMismatch(t *testing.T) {
+	memoryBucket, _ := memory.New(&storage.BucketConfig{}, sharedkv.NewEmpty())
+
+	req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://www.example.com/path/to/2.apk", nil)
+	req.Header.Set("Range", "bytes=524288-1672863")
+	objectID, _ := newObjectIDFromRequest(req, "", true)
+
+	blockSize := uint64(524288)
+	totalSize := blockSize*3 + 100000 // 3 full chunks + 1 partial last chunk (100000 bytes)
+
+	c := &Caching{
+		log:       log.NewHelper(log.GetLogger()),
+		processor: mockProcessorChain(),
+		id:        objectID,
+		req:       req,
+		opt: &cachingOption{
+			SliceSize: blockSize,
+		},
+		md: &object.Metadata{
+			ID:        objectID,
+			Size:      totalSize,
+			BlockSize: blockSize,
+			Chunks:    bitmap.Bitmap{},
+		},
+		bucket:      memoryBucket,
+		proxyClient: proxy.New(),
+	}
+
+	// Cached chunks: 0 (full) and 3 (last, partial)
+	c.md.Chunks.Set(0)
+	c.md.Chunks.Set(3)
+
+	// Write chunk 0 with full block size
+	f0, _, err := memoryBucket.WriteChunkFile(context.Background(), objectID, 0)
+	assert.NoError(t, err)
+	_, _ = f0.Write(makebuf(int(blockSize)))
+	_ = f0.Close()
+
+	// Write chunk 3 (last chunk) with partial size
+	f3, _, err := memoryBucket.WriteChunkFile(context.Background(), objectID, 3)
+	assert.NoError(t, err)
+	_, _ = f3.Write(makebuf(int(totalSize % blockSize))) // 100000 bytes
+	_ = f3.Close()
+
+	// Request chunks 1, 2, 3
+	// idx will be reqChunks[0]=1, but the anchor chunk found is chunk 3 (the last chunk).
+	// Before the fix, checkChunkSize was called with idx=1 instead of 3,
+	// causing it to expect full blockSize (524288) for a 100000-byte file.
+	reqChunks := []uint32{1, 2, 3}
+
+	readers := make([]io.ReadCloser, 0, len(reqChunks))
+	for i := 0; i < len(reqChunks); {
+		reader, count, err := getContents(c, reqChunks, uint32(i))
+		assert.NoError(t, err, "getContents should not return a size mismatch error")
+
+		if count == -1 {
+			break
+		}
+
+		readers = append(readers, reader)
+		i += count
+	}
+
+	t.Logf("all readers %d", len(readers))
+	assert.Equal(t, 1, len(readers))
+}

server/middleware/caching/internal.go

@@ -192,7 +192,7 @@ func getContents(c *Caching, reqChunks []uint32, from uint32) (io.ReadCloser, in
 	if index < len(availableChunks) {
 		chunkFile, _ := getSliceChunkFile(c, availableChunks[index])
 		if chunkFile != nil {
-			if err := checkChunkSize(c, chunkFile, idx); err != nil {
+			if err := checkChunkSize(c, chunkFile, availableChunks[index]); err != nil {
 				_ = chunkFile.Close()
 				_ = c.bucket.Discard(context.Background(), c.id)
 				return nil, 0, err