Python: how to unpack variable-length data from byte string?

There's a byte-string like this:

[lenght1][sequence1][len2][seq2][len3][seq3][len1][seq1]...

where lengthX is the length of the sequenceX following just after that lenghtX. Please note there're no separators at all, and all "len-data" pairs are grouped in a set of three (after seq3 immediately comes len1 of the next group).

I'm trying to extract all sequences, but looks like using struct.unpack() is very cumbersome (or idk how to use it properly):

 loop_start:
   my_len = unpack("<B", content[:1])[0]
   content = content[1:]
   ..get sequence1
   ..shift byte-string
   ..repeat two times...

Is there any simpler way?

p.s. seqX is in fact multi-byte string, if it's matter.

This data structure is very useful when, for example, sending arbitrary data over a socket. Using separators can be problematic due to ambiguity - e.g, if you use STX/ETX there may be an issue if the [real] data contains the equivalent of either of those markers.

Sending data with length/data pairs removes ambiguity. All that needs to happen is that the client and server need to agree on the format of the length value being transmitted (native, little- big-endian).

This is best explained by example.

We have a list of strings and we build a bytearray of length/data pairs. We'll agree on native unsigned int for the preamble. We know that the packed value is comprised of 4 bytes.

So...

from struct import pack, unpack

strings = [
    'To be, or not to be: that is the question',
    'All the world\'s a stage, and all the men and women merely players',
    'We are such stuff as dreams are made on',
    'The course of true love never did run smooth',
    'If music be the food of love, play on',
    'Friends, Romans, countrymen, lend me your ears',
    'A horse! a horse! my kingdom for a horse!',
    'Once more unto the breach, dear friends, once more',
    'To thine own self be true',
    'Parting is such sweet sorrow'
]

FMT = '=I' # native unsigned int
FMTL = 4 # standard size

b = bytearray()

for string in strings:
    bs = string.encode()
    b += pack(FMT, len(bs)) + bs

# at this point we have a bytearray comprised of length/data pairs
# now let's unravel it

while b:
    length, *_ = unpack(FMT, b[:FMTL])
    print(b[FMTL:length+FMTL].decode())
    b = b[length+FMTL:]

This code is easily adapted for any integer type by specifying FMT and FMTL appropriately. Type 'c' is hinted at in OP's question. That has to be dealt with in a slightly different manner

Since there's no example how the data could look like, I provided my own sample (length is always a integer, therefore 4 bytes). If your bytes come in big- or little endian you have to see for yourself. I decided to use big endian since it's a bit easier to read an understand. To change that, you just have to change the > to <.
The code works by padding the number and using the biggest available type (unsigned long long). Since added zeroes on the left side of a big endian number does not have any effect, this approach should work. For little endian, you have to add the padding to the right side.
To prevent problems with different architectures, where data types may differ, the size of the needed padding is calculated using struct.calcsize().

import struct


content = b'\x00\x00\x00\x04\x12\x4a\x13\x10\x00\x00\x00\x03\x01\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\xff'
out = []

while True:
    if content == b'':
        break
    length = struct.unpack('>I', content[:4])[0]
    pad_len = struct.calcsize('Q') - length
    padding = b'\x00' * pad_len
    value = struct.unpack('>Q', padding + content[4:4+length])[0]
    out.append(value)
    content = content[4+length:]

print(out)

output:

[306844432, 65537, 255]