XTLS/Xray-core · error

packet size too large:

Error message

packet size too large: 

What it means

PacketReader.ReadMultiBuffer read a uint16 length prefix for a UDP-over-mux packet that exceeds buf.Size (the maximum buffer Xray allocates, a few KB). The peer claims a single packet larger than any legal buffer, so the reader refuses instead of attempting an oversized allocation.

Source

Thrown at common/mux/reader.go:41

		reader: reader,
		eof:    false,
		dest:   dest,
	}
}

// ReadMultiBuffer implements buf.Reader.
func (r *PacketReader) ReadMultiBuffer() (buf.MultiBuffer, error) {
	if r.eof {
		return nil, io.EOF
	}

	size, err := serial.ReadUint16(r.reader)
	if err != nil {
		return nil, err
	}

	if size > buf.Size {
		return nil, errors.New("packet size too large: ", size)
	}

	b := buf.New()
	if _, err := b.ReadFullFrom(r.reader, int32(size)); err != nil {
		b.Release()
		return nil, err
	}
	r.eof = true
	if r.dest != nil && r.dest.Network == net.Network_UDP {
		b.UDP = r.dest
	}
	return buf.MultiBuffer{b}, nil
}

// NewStreamReader creates a new StreamReader.
func NewStreamReader(reader *buf.BufferedReader) buf.Reader {
	return crypto.NewChunkStreamReaderWithChunkCount(crypto.PlainChunkSizeParser{}, reader, 1)
}

View on GitHub (pinned to 7d214f8b09)

Solutions

1. Check the reported size value: near 65535 suggests reading garbage (desync); slightly above 8192 suggests an oversized datagram from the client.
2. Ensure client-side XUDP writes packets within buf.Size limits (split large payloads at the application layer).
3. Verify both sides use the same XUDP/mux version; earlier frames may have been misparsed, desynchronizing the length-prefix stream.
4. Look at preceding log lines for the original parse error that caused the desync and fix that first.

// Client side: before writing a packet into a mux/XUDP stream, check size:
if len(payload) > int(buf.Size) {
    return fmt.Errorf("packet of %d bytes exceeds mux limit %d; split at application layer", len(payload), buf.Size)
}

mb, err := pr.ReadMultiBuffer()
if err != nil {
    if strings.Contains(err.Error(), "packet size too large") {
        // stream is desynced or peer sent junk: tear down, never skip bytes and continue
        return nil, err
    }
}

When it happens

Trigger: XUDP/packet transfer where the 2-byte size prefix is > buf.Size; typical when a stream is misaligned (reading the middle of a packet as a length prefix), the peer has a bug, or the data is corrupted.

Common situations: Mux carrying UDP (XUDP) with stream desynchronization after an earlier parse error, or clients that forward jumbo UDP datagrams without fragmentation.

Related errors

• failed to process mux outbound traffic
• XUDP rejected UDP/443 traffic
• invalid metalen
• insufficient buffer:
• failed to parse address and port

AI-assisted analysis of XTLS/Xray-core@7d214f8b09 (2026-08-15). Data as JSON: /api/errors/6933cacc4918585c. Report an issue: GitHub.