gtsocial-umbx

decoder.go (6457B)

---

 package dbus
 
 import (
 	"encoding/binary"
 	"io"
 	"reflect"
 )
 
 type decoder struct {
 	in    io.Reader
 	order binary.ByteOrder
 	pos   int
 }
 
 // newDecoder returns a new decoder that reads values from in. The input is
 // expected to be in the given byte order.
 func newDecoder(in io.Reader, order binary.ByteOrder) *decoder {
 	dec := new(decoder)
 	dec.in = in
 	dec.order = order
 	return dec
 }
 
 // align aligns the input to the given boundary and panics on error.
 func (dec *decoder) align(n int) {
 	if dec.pos%n != 0 {
 		newpos := (dec.pos + n - 1) & ^(n - 1)
 		empty := make([]byte, newpos-dec.pos)
 		if _, err := io.ReadFull(dec.in, empty); err != nil {
 			panic(err)
 		}
 		dec.pos = newpos
 	}
 }
 
 // Calls binary.Read(dec.in, dec.order, v) and panics on read errors.
 func (dec *decoder) binread(v interface{}) {
 	if err := binary.Read(dec.in, dec.order, v); err != nil {
 		panic(err)
 	}
 }
 
 func (dec *decoder) Decode(sig Signature) (vs []interface{}, err error) {
 	defer func() {
 		var ok bool
 		v := recover()
 		if err, ok = v.(error); ok {
 			if err == io.EOF || err == io.ErrUnexpectedEOF {
 				err = FormatError("unexpected EOF")
 			}
 		}
 	}()
 	vs = make([]interface{}, 0)
 	s := sig.str
 	for s != "" {
 		err, rem := validSingle(s, 0)
 		if err != nil {
 			return nil, err
 		}
 		v := dec.decode(s[:len(s)-len(rem)], 0)
 		vs = append(vs, v)
 		s = rem
 	}
 	return vs, nil
 }
 
 func (dec *decoder) decode(s string, depth int) interface{} {
 	dec.align(alignment(typeFor(s)))
 	switch s[0] {
 	case 'y':
 		var b [1]byte
 		if _, err := dec.in.Read(b[:]); err != nil {
 			panic(err)
 		}
 		dec.pos++
 		return b[0]
 	case 'b':
 		i := dec.decode("u", depth).(uint32)
 		switch {
 		case i == 0:
 			return false
 		case i == 1:
 			return true
 		default:
 			panic(FormatError("invalid value for boolean"))
 		}
 	case 'n':
 		var i int16
 		dec.binread(&i)
 		dec.pos += 2
 		return i
 	case 'i':
 		var i int32
 		dec.binread(&i)
 		dec.pos += 4
 		return i
 	case 'x':
 		var i int64
 		dec.binread(&i)
 		dec.pos += 8
 		return i
 	case 'q':
 		var i uint16
 		dec.binread(&i)
 		dec.pos += 2
 		return i
 	case 'u':
 		var i uint32
 		dec.binread(&i)
 		dec.pos += 4
 		return i
 	case 't':
 		var i uint64
 		dec.binread(&i)
 		dec.pos += 8
 		return i
 	case 'd':
 		var f float64
 		dec.binread(&f)
 		dec.pos += 8
 		return f
 	case 's':
 		length := dec.decode("u", depth).(uint32)
 		b := make([]byte, int(length)+1)
 		if _, err := io.ReadFull(dec.in, b); err != nil {
 			panic(err)
 		}
 		dec.pos += int(length) + 1
 		return string(b[:len(b)-1])
 	case 'o':
 		return ObjectPath(dec.decode("s", depth).(string))
 	case 'g':
 		length := dec.decode("y", depth).(byte)
 		b := make([]byte, int(length)+1)
 		if _, err := io.ReadFull(dec.in, b); err != nil {
 			panic(err)
 		}
 		dec.pos += int(length) + 1
 		sig, err := ParseSignature(string(b[:len(b)-1]))
 		if err != nil {
 			panic(err)
 		}
 		return sig
 	case 'v':
 		if depth >= 64 {
 			panic(FormatError("input exceeds container depth limit"))
 		}
 		var variant Variant
 		sig := dec.decode("g", depth).(Signature)
 		if len(sig.str) == 0 {
 			panic(FormatError("variant signature is empty"))
 		}
 		err, rem := validSingle(sig.str, 0)
 		if err != nil {
 			panic(err)
 		}
 		if rem != "" {
 			panic(FormatError("variant signature has multiple types"))
 		}
 		variant.sig = sig
 		variant.value = dec.decode(sig.str, depth+1)
 		return variant
 	case 'h':
 		return UnixFDIndex(dec.decode("u", depth).(uint32))
 	case 'a':
 		if len(s) > 1 && s[1] == '{' {
 			ksig := s[2:3]
 			vsig := s[3 : len(s)-1]
 			v := reflect.MakeMap(reflect.MapOf(typeFor(ksig), typeFor(vsig)))
 			if depth >= 63 {
 				panic(FormatError("input exceeds container depth limit"))
 			}
 			length := dec.decode("u", depth).(uint32)
 			// Even for empty maps, the correct padding must be included
 			dec.align(8)
 			spos := dec.pos
 			for dec.pos < spos+int(length) {
 				dec.align(8)
 				if !isKeyType(v.Type().Key()) {
 					panic(InvalidTypeError{v.Type()})
 				}
 				kv := dec.decode(ksig, depth+2)
 				vv := dec.decode(vsig, depth+2)
 				v.SetMapIndex(reflect.ValueOf(kv), reflect.ValueOf(vv))
 			}
 			return v.Interface()
 		}
 		if depth >= 64 {
 			panic(FormatError("input exceeds container depth limit"))
 		}
 		sig := s[1:]
 		length := dec.decode("u", depth).(uint32)
 		// capacity can be determined only for fixed-size element types
 		var capacity int
 		if s := sigByteSize(sig); s != 0 {
 			capacity = int(length) / s
 		}
 		v := reflect.MakeSlice(reflect.SliceOf(typeFor(sig)), 0, capacity)
 		// Even for empty arrays, the correct padding must be included
 		align := alignment(typeFor(s[1:]))
 		if len(s) > 1 && s[1] == '(' {
 			//Special case for arrays of structs
 			//structs decode as a slice of interface{} values
 			//but the dbus alignment does not match this
 			align = 8
 		}
 		dec.align(align)
 		spos := dec.pos
 		for dec.pos < spos+int(length) {
 			ev := dec.decode(s[1:], depth+1)
 			v = reflect.Append(v, reflect.ValueOf(ev))
 		}
 		return v.Interface()
 	case '(':
 		if depth >= 64 {
 			panic(FormatError("input exceeds container depth limit"))
 		}
 		dec.align(8)
 		v := make([]interface{}, 0)
 		s = s[1 : len(s)-1]
 		for s != "" {
 			err, rem := validSingle(s, 0)
 			if err != nil {
 				panic(err)
 			}
 			ev := dec.decode(s[:len(s)-len(rem)], depth+1)
 			v = append(v, ev)
 			s = rem
 		}
 		return v
 	default:
 		panic(SignatureError{Sig: s})
 	}
 }
 
 // sigByteSize tries to calculates size of the given signature in bytes.
 //
 // It returns zero when it can't, for example when it contains non-fixed size
 // types such as strings, maps and arrays that require reading of the transmitted
 // data, for that we would need to implement the unread method for Decoder first.
 func sigByteSize(sig string) int {
 	var total int
 	for offset := 0; offset < len(sig); {
 		switch sig[offset] {
 		case 'y':
 			total += 1
 			offset += 1
 		case 'n', 'q':
 			total += 2
 			offset += 1
 		case 'b', 'i', 'u', 'h':
 			total += 4
 			offset += 1
 		case 'x', 't', 'd':
 			total += 8
 			offset += 1
 		case '(':
 			i := 1
 			depth := 1
 			for i < len(sig[offset:]) && depth != 0 {
 				if sig[offset+i] == '(' {
 					depth++
 				} else if sig[offset+i] == ')' {
 					depth--
 				}
 				i++
 			}
 			s := sigByteSize(sig[offset+1 : offset+i-1])
 			if s == 0 {
 				return 0
 			}
 			total += s
 			offset += i
 		default:
 			return 0
 		}
 	}
 	return total
 }
 
 // A FormatError is an error in the wire format.
 type FormatError string
 
 func (e FormatError) Error() string {
 	return "dbus: wire format error: " + string(e)
 }