minor improvements to file scanners (#22)

Author: ostafen

internal/format/au.go

@@ -63,19 +63,19 @@ func ScanSunAudio(r *Reader) (*ScanResult, error) {
 		return nil, fmt.Errorf("failed to read AU header: %w", err)
 	}
 
-	// 1. Check Magic Number (Big Endian)
+	// Check Magic Number (Big Endian)
 	magic := binary.BigEndian.Uint32(headerBuf[0:4])
 	if magic != AU_MAGIC {
 		return nil, fmt.Errorf("reader does not start with AU magic signature")
 	}
 
-	// 2. Read Header Size (Big Endian)
+	// Read Header Size (Big Endian)
 	headerSize := binary.BigEndian.Uint32(headerBuf[4:8])
 	if headerSize < MIN_AU_HEADER_SIZE {
 		return nil, fmt.Errorf("AU header size (%d) is invalid", headerSize)
 	}
 
-	// 3. Read Data Size (Big Endian)
+	// Read Data Size (Big Endian)
 	dataSize := binary.BigEndian.Uint32(headerBuf[8:12])
 
 	bytesRead := uint64(MIN_AU_HEADER_SIZE)
@@ -97,32 +97,24 @@ func ScanSunAudio(r *Reader) (*ScanResult, error) {
 
 	var totalAUSize uint64
 	if dataSize == AU_DATA_SIZE_UNKNOWN {
-		// Data extends to the end of the file.
-		// We've read the header, so the remaining size is what's left in the reader.
-		// Since we don't know the full length, we'll return the bytes read so far.
-		// The caller would typically read until EOF for the data.
-		return &ScanResult{Size: bytesRead}, nil // Indicate that the valid part up to the header is found
-	} else {
-		// Data size is explicitly defined.
-		totalAUSize = uint64(headerSize) + uint64(dataSize)
-
-		// We need to advance the reader past the data chunk for the returned bytesRead to be accurate.
-		// Calculate how many bytes of data are yet to be read.
-		dataBytesToRead := int64(totalAUSize - bytesRead)
-
-		if dataBytesToRead > 0 { // Only skip if there's data left to read
-			skipped, err := io.CopyN(io.Discard, r, dataBytesToRead)
-			if err != nil {
-				if err == io.EOF && skipped < dataBytesToRead {
-					// Data chunk is truncated. The valid AU ends here.
-					return &ScanResult{Size: bytesRead + uint64(skipped)}, nil
-				}
-				return nil, fmt.Errorf("failed to skip AU data: %w", err)
+		// Data size is not explicitly defined. Return an error for now.
+		return &ScanResult{Size: bytesRead}, fmt.Errorf("unknown AU file size")
+	}
+
+	totalAUSize = uint64(headerSize) + uint64(dataSize)
+
+	bytesToSkip := int(totalAUSize - bytesRead)
+
+	if bytesToSkip > 0 {
+		skipped, err := r.Discard(bytesToSkip)
+		if err != nil {
+			if err == io.EOF && skipped < bytesToSkip {
+				// Data chunk is truncated. The valid AU ends here.
+				return &ScanResult{Size: bytesRead + uint64(skipped)}, nil
 			}
-			bytesRead += uint64(skipped)
+			return nil, fmt.Errorf("failed to skip AU data: %w", err)
 		}
+		bytesRead += uint64(skipped)
 	}
-
-	// If we reach here, we've successfully scanned and potentially skipped all valid AU data.
 	return &ScanResult{Size: totalAUSize}, nil
 }

internal/format/bmp.go

@@ -81,7 +81,7 @@ func ScanBMP(r *Reader) (*ScanResult, error) {
 	var bmpHeader BMPHeader
 	var dibHeader DIBHeader
 
-	// 1. Read the BMP File Header (14 bytes)
+	// Read the BMP File Header (14 bytes)
 	err := binary.Read(r, binary.LittleEndian, &bmpHeader)
 	if err != nil {
 		if errors.Is(err, io.EOF) {
@@ -104,7 +104,7 @@ func ScanBMP(r *Reader) (*ScanResult, error) {
 		return nil, errors.New("invalid BMP header: data offset is before the BMP file header")
 	}
 
-	// 2. Read the DIB Header (assume BITMAPINFOHEADER for commonality, 40 bytes)
+	// Read the DIB Header (assume BITMAPINFOHEADER for commonality, 40 bytes)
 	// We need to peek at the HeaderSize field to determine the exact DIB header type.
 	// For simplicity, we'll assume BITMAPINFOHEADER (40 bytes) and then read it.
 	// A more robust solution might read only the HeaderSize first, then seek/read the rest.
@@ -121,7 +121,7 @@ func ScanBMP(r *Reader) (*ScanResult, error) {
 	}
 	dibHeader.HeaderSize = binary.LittleEndian.Uint32(buf[:])
 
-	// More robust validation of DIB Header fields
+	// Validate DIB Header fields
 	if dibHeader.HeaderSize != 40 &&
 		dibHeader.HeaderSize != 12 && // BITMAPCOREHEADER
 		dibHeader.HeaderSize != 64 && // BITMAPINFOHEADER V2
@@ -130,8 +130,7 @@ func ScanBMP(r *Reader) (*ScanResult, error) {
 		return nil, fmt.Errorf("unsupported DIB header size: %d", dibHeader.HeaderSize)
 	}
 
-	// Now read the rest of the DIBHeader based on its size
-	// We've already read the first 4 bytes (HeaderSize), so adjust the read length.
+	// Read the rest of the DIBHeader based on its size
 	n, err = r.Read(buf[4:dibHeader.HeaderSize])
 	if err != nil {
 		if errors.Is(err, io.EOF) {

internal/format/gif.go

@@ -17,7 +17,6 @@ package format
 import (
 	"errors"
 	"fmt"
-	"io"
 )
 
 var gifFileHeader = FileHeader{
@@ -55,7 +54,7 @@ const (
 
 type gifDecoder struct {
 	loopCount int
-	r         io.Reader
+	r         *Reader
 
 	width, height       int
 	imageFields         byte
@@ -77,7 +76,7 @@ func ScanGIF(r *Reader) (*ScanResult, error) {
 	}
 
 	for {
-		c, err := readByte(d.r.(io.ByteReader))
+		c, err := d.r.ReadByte()
 		if err != nil {
 			return nil, fmt.Errorf("gif: reading frames: %v", err)
 		}
@@ -108,7 +107,7 @@ func ScanGIF(r *Reader) (*ScanResult, error) {
 }
 
 func (d *gifDecoder) readExtension() error {
-	extension, err := readByte(d.r.(io.ByteReader))
+	extension, err := d.r.ReadByte()
 	if err != nil {
 		return fmt.Errorf("gif: reading extension: %v", err)
 	}
@@ -121,7 +120,7 @@ func (d *gifDecoder) readExtension() error {
 	case eComment:
 		// nothing to do but read the data.
 	case eApplication:
-		b, err := readByte(d.r.(io.ByteReader))
+		b, err := d.r.ReadByte()
 		if err != nil {
 			return fmt.Errorf("gif: reading extension: %v", err)
 		}
@@ -131,7 +130,7 @@ func (d *gifDecoder) readExtension() error {
 		return fmt.Errorf("gif: unknown extension 0x%.2x", extension)
 	}
 	if size > 0 {
-		if err := readFull(d.r, d.tmp[:size]); err != nil {
+		if _, err := d.r.Read(d.tmp[:size]); err != nil {
 			return fmt.Errorf("gif: reading extension: %v", err)
 		}
 	}
@@ -162,7 +161,7 @@ func (d *gifDecoder) readExtension() error {
 }
 
 func (d *gifDecoder) readGraphicControl() error {
-	if err := readFull(d.r, d.tmp[:6]); err != nil {
+	if _, err := d.r.Read(d.tmp[:6]); err != nil {
 		return fmt.Errorf("gif: can't read graphic control: %s", err)
 	}
 	if d.tmp[0] != 4 {
@@ -175,7 +174,7 @@ func (d *gifDecoder) readGraphicControl() error {
 }
 
 func (d *gifDecoder) parseImageDescriptorBounds() error {
-	if err := readFull(d.r, d.tmp[:9]); err != nil {
+	if _, err := d.r.Read(d.tmp[:9]); err != nil {
 		return fmt.Errorf("gif: can't read image descriptor: %s", err)
 	}
 	left := int(d.tmp[0]) + int(d.tmp[1])<<8
@@ -220,7 +219,7 @@ func (d *gifDecoder) readImageDescriptor() error {
 		return errors.New("gif: no color table")
 	}
 
-	litWidth, err := readByte(d.r.(io.ByteReader))
+	litWidth, err := d.r.ReadByte()
 	if err != nil {
 		return fmt.Errorf("gif: reading image data: %v", err)
 	}
@@ -230,15 +229,15 @@ func (d *gifDecoder) readImageDescriptor() error {
 
 	// discard LZW encoded blocks
 	for {
-		size, err := readByte(d.r.(io.ByteReader)) // read LZW minimum code size
+		size, err := d.r.ReadByte() // read LZW minimum code size
 		if err != nil {
 			return fmt.Errorf("gif: reading image data: %v", err)
 		}
 		if size == 0 {
 			// 0 means end of LZW data.
 			break
 		}
-		if err := discard(int(size), d.r); err != nil {
+		if _, err := d.r.Discard(int(size)); err != nil {
 			return err
 		}
 	}
@@ -248,18 +247,18 @@ func (d *gifDecoder) readImageDescriptor() error {
 }
 
 func (d *gifDecoder) readBlock() (int, error) {
-	n, err := readByte(d.r.(io.ByteReader))
+	n, err := d.r.ReadByte()
 	if n == 0 || err != nil {
 		return 0, err
 	}
-	if err := readFull(d.r, d.tmp[:n]); err != nil {
+	if _, err := d.r.Read(d.tmp[:n]); err != nil {
 		return 0, err
 	}
 	return int(n), nil
 }
 
 func (d *gifDecoder) readHeaderAndScreenDescriptor() error {
-	err := readFull(d.r, d.tmp[:13])
+	_, err := d.r.Read(d.tmp[:13])
 	if err != nil {
 		return fmt.Errorf("gif: reading header: %v", err)
 	}
@@ -286,28 +285,9 @@ func (d *gifDecoder) readHeaderAndScreenDescriptor() error {
 
 func (d *gifDecoder) skipColorTable(fields byte) error {
 	n := 1 << (1 + uint(fields&fColorTableBitsMask))
-	err := readFull(d.r, d.tmp[:3*n])
+	_, err := d.r.Read(d.tmp[:3*n])
 	if err != nil {
 		return fmt.Errorf("gif: reading color table: %s", err)
 	}
 	return nil
 }
-
-func readByte(r io.ByteReader) (byte, error) {
-	b, err := r.ReadByte()
-	if err != nil {
-		if err == io.EOF {
-			return 0, io.ErrUnexpectedEOF
-		}
-		return 0, fmt.Errorf("gif: reading byte: %v", err)
-	}
-	return b, nil
-}
-
-func readFull(r io.Reader, b []byte) error {
-	_, err := io.ReadFull(r, b)
-	if err == io.EOF {
-		err = io.ErrUnexpectedEOF
-	}
-	return err
-}

internal/format/jpeg.go

@@ -17,7 +17,6 @@ package format
 
 import (
 	"fmt"
-	"io"
 )
 
 var jpegFileHeader = FileHeader{
@@ -50,11 +49,6 @@ const (
 	app15Marker = 0xef
 )
 
-func discard(n int, r io.Reader) error {
-	_, err := io.CopyN(io.Discard, r, int64(n))
-	return err
-}
-
 // ScanJPEG attempts to validate a JPEG file from the beginning of the 'data'
 // buffer and determine its total size. This function is adapted from the
 // standard library's 'image/jpeg' package's internal scanning logic,
@@ -158,10 +152,10 @@ func ScanJPEG(r *Reader) (*ScanResult, error) {
 		case sof0Marker, sof1Marker, sof2Marker,
 			dhtMarker, dqtMarker, sosMarker,
 			driMarker, app0Marker, app14Marker:
-			err = discard(n, r)
+			_, err = r.Discard(n)
 		default:
 			if app0Marker <= marker && marker <= app15Marker || marker == comMarker {
-				err = discard(n, r)
+				_, err = r.Discard(n)
 			} else if marker < 0xc0 { // See Table B.1 "Marker code assignments".
 				err = fmt.Errorf("unknown marker")
 			} else {

internal/format/pcx.go

@@ -179,7 +179,7 @@ func ScanPCX(r *Reader) (*ScanResult, error) {
 	if header.Encoding == 0 { // Uncompressed
 		expectedImageDataSize := uint32(header.BytesPerLine) * uint32(header.NumPlanes) * height
 		// We've only read the header. Now, skip the image data.
-		skipped, err := io.CopyN(io.Discard, r, int64(expectedImageDataSize))
+		skipped, err := r.Discard(int(expectedImageDataSize))
 		if err != nil {
 			if errors.Is(err, io.EOF) {
 				return nil, errors.New("unexpected EOF while skipping uncompressed image data")

internal/format/pdf.go

@@ -41,23 +41,9 @@ var (
 // ScanPDF reads a byte stream from an io.Reader, identifies a potential PDF file,
 // and returns its carved size.
 //
-// This function assumes that the entire potential PDF segment can be read into
-// memory. For extremely large files (gigabytes), a more advanced streaming
-// parser with limited look-behind would be necessary.
-//
 // It searches for the first occurrence of the standard PDF header (%PDF-X.Y)
 // and the last occurrence of the end-of-file marker (%%EOF). The carved size
 // is determined by the position of the last %%EOF marker plus its length.
-//
-// Parameters:
-//
-//	r io.Reader: The input stream from which to read the PDF data.
-//
-// Returns:
-//
-//	uint64: The size of the carved PDF file in bytes.
-//	error: An error if the PDF header or EOF marker is not found, or if the
-//	       EOF marker appears before the header.
 func ScanPDF(r *Reader) (*ScanResult, error) {
 	var headerBuf [5]byte
 	_, err := r.Read(headerBuf[:])

internal/format/wav.go

@@ -47,11 +47,9 @@ const (
 // WAV data, or 0 and an error if no valid WAV file is found at the beginning.
 // The reader's position will be at the end of the WAV data upon successful return.
 func ScanWAV(r *Reader) (*ScanResult, error) {
-	// We'll use a small buffer for reading headers and sizes.
-
 	var headerBuf [8]byte // For ChunkID and ChunkSize
 
-	// 1. Check RIFF chunk
+	// Check RIFF chunk
 	// Read Offset 0-3: ChunkID "RIFF" and Offset 4-7: ChunkSize
 	n, err := io.ReadFull(r, headerBuf[:])
 	if err != nil {
@@ -81,7 +79,7 @@ func ScanWAV(r *Reader) (*ScanResult, error) {
 
 	bytesRead := uint64(12) // RIFF (8 bytes) + WAVE (4 bytes)
 
-	// 2. Find and parse 'fmt ' sub-chunk
+	// Find and parse 'fmt ' sub-chunk
 	fmtChunkFound := false
 	for bytesRead < uint64(riffChunkSize)+8 { // Ensure we don't read beyond the declared RIFF chunk
 		n, err = io.ReadFull(r, headerBuf[:])
@@ -130,7 +128,7 @@ func ScanWAV(r *Reader) (*ScanResult, error) {
 		return nil, fmt.Errorf("missing 'fmt ' sub-chunk")
 	}
 
-	// 3. Find and parse 'data' sub-chunk
+	// Find and parse 'data' sub-chunk
 	dataChunkFound := false
 	dataChunkSize := uint32(0)
 
@@ -159,9 +157,9 @@ func ScanWAV(r *Reader) (*ScanResult, error) {
 		}
 
 		// Skip over the current chunk's data
-		skipped, err := io.CopyN(io.Discard, r, int64(chunkSize))
+		skipped, err := r.Discard(int(chunkSize))
 		if err != nil {
-			if err == io.EOF && skipped < int64(chunkSize) {
+			if err == io.EOF && skipped < int(chunkSize) {
 				// Truncated chunk data, can't determine full WAV size
 				bytesRead += uint64(skipped)
 				return &ScanResult{Size: bytesRead}, nil // Return what was read before truncation