123 lines
2.7 KiB
Go
123 lines
2.7 KiB
Go
package wire
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"errors"
|
|
)
|
|
|
|
// Writer builds redapricot/Minecraft primitive types into a byte slice.
|
|
type Writer struct {
|
|
buf []byte
|
|
}
|
|
|
|
func NewWriter() *Writer { return &Writer{} }
|
|
|
|
func (w *Writer) U8(v byte) *Writer { w.buf = append(w.buf, v); return w }
|
|
func (w *Writer) VarInt(v int) *Writer { w.buf = AppendVarInt(w.buf, v); return w }
|
|
func (w *Writer) U16(v uint16) *Writer { w.buf = append(w.buf, byte(v>>8), byte(v)); return w }
|
|
func (w *Writer) Bytes(p []byte) *Writer { w.buf = append(w.buf, p...); return w }
|
|
|
|
func (w *Writer) I64(v int64) *Writer {
|
|
var b [8]byte
|
|
binary.BigEndian.PutUint64(b[:], uint64(v))
|
|
w.buf = append(w.buf, b[:]...)
|
|
return w
|
|
}
|
|
|
|
func (w *Writer) String(s string) *Writer {
|
|
w.VarInt(len(s))
|
|
w.buf = append(w.buf, s...)
|
|
return w
|
|
}
|
|
|
|
// Out returns the built bytes.
|
|
func (w *Writer) Out() []byte { return w.buf }
|
|
|
|
// Reader consumes redapricot/Minecraft primitive types from a byte slice.
|
|
type Reader struct {
|
|
buf []byte
|
|
pos int
|
|
}
|
|
|
|
func NewReader(b []byte) *Reader { return &Reader{buf: b} }
|
|
|
|
var errUnderflow = errors.New("wire: read underflow")
|
|
|
|
func (r *Reader) U8() (byte, error) {
|
|
if r.pos >= len(r.buf) {
|
|
return 0, errUnderflow
|
|
}
|
|
v := r.buf[r.pos]
|
|
r.pos++
|
|
return v, nil
|
|
}
|
|
|
|
func (r *Reader) VarInt() (int, error) {
|
|
br := bytes.NewReader(r.buf[r.pos:])
|
|
before := br.Len()
|
|
v, err := ReadVarInt(br)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
r.pos += before - br.Len()
|
|
return v, nil
|
|
}
|
|
|
|
func (r *Reader) U16() (uint16, error) {
|
|
if r.pos+2 > len(r.buf) {
|
|
return 0, errUnderflow
|
|
}
|
|
v := binary.BigEndian.Uint16(r.buf[r.pos:])
|
|
r.pos += 2
|
|
return v, nil
|
|
}
|
|
|
|
func (r *Reader) I64() (int64, error) {
|
|
if r.pos+8 > len(r.buf) {
|
|
return 0, errUnderflow
|
|
}
|
|
v := int64(binary.BigEndian.Uint64(r.buf[r.pos:]))
|
|
r.pos += 8
|
|
return v, nil
|
|
}
|
|
|
|
func (r *Reader) Bytes(n int) ([]byte, error) {
|
|
if n < 0 || r.pos+n > len(r.buf) {
|
|
return nil, errUnderflow
|
|
}
|
|
out := make([]byte, n)
|
|
copy(out, r.buf[r.pos:r.pos+n])
|
|
r.pos += n
|
|
return out, nil
|
|
}
|
|
|
|
func (r *Reader) String() (string, error) {
|
|
n, err := r.VarInt()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
b, err := r.Bytes(n)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(b), nil
|
|
}
|
|
|
|
// Remaining returns the unread bytes (a copy is not made).
|
|
func (r *Reader) Remaining() []byte { return r.buf[r.pos:] }
|
|
|
|
// BuildHandshake produces a full uncompressed Minecraft Handshake packet
|
|
// (length-prefixed, packet id 0x00).
|
|
func BuildHandshake(protocolVersion int, address string, port uint16, intent int) []byte {
|
|
body := NewWriter().
|
|
VarInt(0x00). // packet id
|
|
VarInt(protocolVersion).
|
|
String(address).
|
|
U16(port).
|
|
VarInt(intent).
|
|
Out()
|
|
out := AppendVarInt(nil, len(body))
|
|
return append(out, body...)
|
|
}
|