Exercise 1 solution

    import struct


    def make_wav(pcm, rate=8000, channels=1, extra=b""):
        fmt = struct.pack("<HHIIHH", 1, channels, rate, rate * channels * 2, channels * 2, 16)
        body = (b"WAVE" + b"fmt " + struct.pack("<I", 16) + fmt + extra
                + b"data" + struct.pack("<I", len(pcm)) + pcm)
        return b"RIFF" + struct.pack("<I", len(body)) + body


    def list_chunks(raw):
        if raw[:4] != b"RIFF" or raw[8:12] != b"WAVE":
            raise ValueError("not a WAV file")
        pos, found = 12, []
        while pos < len(raw):
            if pos + 8 > len(raw):
                raise ValueError("truncated chunk header")
            cid, size = struct.unpack_from("<4sI", raw, pos)
            if pos + 8 + size > len(raw):
                raise ValueError(f"chunk {cid!r} runs past end of file")
            found.append((cid, size))
            pos += 8 + size + (size & 1)      # odd sizes are followed by one pad byte
        return found


    odd = b"junk" + struct.pack("<I", 3) + b"abc" + b"\x00"   # 3 data bytes + 1 pad byte
    wav = make_wav(struct.pack("<3h", 1, 2, 3), extra=odd)
    print(list_chunks(wav))

    for label, bad in [
        ("signature", b"RIFX" + wav[4:]),
        ("past end", wav[:-2]),
        ("short header", wav + b"abc"),
    ]:
        try:
            list_chunks(bad)
        except ValueError as e:
            print(label, "->", e)

    # [(b'fmt ', 16), (b'junk', 3), (b'data', 6)]
    # signature -> not a WAV file
    # past end -> chunk b'data' runs past end of file
    # short header -> truncated chunk header

(Run as written; the output matched the comments.)

Explanation: The walker starts at byte 12, after "RIFF", the size and "WAVE". Each
chunk is a 4-letter id, a 4-byte little-endian size and the data, and a chunk with an
odd size is followed by one pad byte that is not counted in the size. The test chunk
has 3 data bytes, so skipping its pad byte is what lets the walker find "data" next.
Every size is checked against the bytes really present before it is used.