go-tg-screenshot-bot

1
package dbus
2

3
import (
4
	"bytes"
5
	"encoding/binary"
6
	"io"
7
	"reflect"
8
	"strings"
9
	"unicode/utf8"
10
)
11

12
// An encoder encodes values to the D-Bus wire format.
13
type encoder struct {
14
	out   io.Writer
15
	fds   []int
16
	order binary.ByteOrder
17
	pos   int
18
}
19

20
// NewEncoder returns a new encoder that writes to out in the given byte order.
21
func newEncoder(out io.Writer, order binary.ByteOrder, fds []int) *encoder {
22
	enc := newEncoderAtOffset(out, 0, order, fds)
23
	return enc
24
}
25

26
// newEncoderAtOffset returns a new encoder that writes to out in the given
27
// byte order. Specify the offset to initialize pos for proper alignment
28
// computation.
29
func newEncoderAtOffset(out io.Writer, offset int, order binary.ByteOrder, fds []int) *encoder {
30
	enc := new(encoder)
31
	enc.out = out
32
	enc.order = order
33
	enc.pos = offset
34
	enc.fds = fds
35
	return enc
36
}
37

38
// Aligns the next output to be on a multiple of n. Panics on write errors.
39
func (enc *encoder) align(n int) {
40
	pad := enc.padding(0, n)
41
	if pad > 0 {
42
		empty := make([]byte, pad)
43
		if _, err := enc.out.Write(empty); err != nil {
44
			panic(err)
45
		}
46
		enc.pos += pad
47
	}
48
}
49

50
// pad returns the number of bytes of padding, based on current position and additional offset.
51
// and alignment.
52
func (enc *encoder) padding(offset, algn int) int {
53
	abs := enc.pos + offset
54
	if abs%algn != 0 {
55
		newabs := (abs + algn - 1) & ^(algn - 1)
56
		return newabs - abs
57
	}
58
	return 0
59
}
60

61
// Calls binary.Write(enc.out, enc.order, v) and panics on write errors.
62
func (enc *encoder) binwrite(v interface{}) {
63
	if err := binary.Write(enc.out, enc.order, v); err != nil {
64
		panic(err)
65
	}
66
}
67

68
// Encode encodes the given values to the underlying reader. All written values
69
// are aligned properly as required by the D-Bus spec.
70
func (enc *encoder) Encode(vs ...interface{}) (err error) {
71
	defer func() {
72
		err, _ = recover().(error)
73
	}()
74
	for _, v := range vs {
75
		enc.encode(reflect.ValueOf(v), 0)
76
	}
77
	return nil
78
}
79

80
// encode encodes the given value to the writer and panics on error. depth holds
81
// the depth of the container nesting.
82
func (enc *encoder) encode(v reflect.Value, depth int) {
83
	if depth > 64 {
84
		panic(FormatError("input exceeds depth limitation"))
85
	}
86
	enc.align(alignment(v.Type()))
87
	switch v.Kind() {
88
	case reflect.Uint8:
89
		var b [1]byte
90
		b[0] = byte(v.Uint())
91
		if _, err := enc.out.Write(b[:]); err != nil {
92
			panic(err)
93
		}
94
		enc.pos++
95
	case reflect.Bool:
96
		if v.Bool() {
97
			enc.encode(reflect.ValueOf(uint32(1)), depth)
98
		} else {
99
			enc.encode(reflect.ValueOf(uint32(0)), depth)
100
		}
101
	case reflect.Int16:
102
		enc.binwrite(int16(v.Int()))
103
		enc.pos += 2
104
	case reflect.Uint16:
105
		enc.binwrite(uint16(v.Uint()))
106
		enc.pos += 2
107
	case reflect.Int, reflect.Int32:
108
		if v.Type() == unixFDType {
109
			fd := v.Int()
110
			idx := len(enc.fds)
111
			enc.fds = append(enc.fds, int(fd))
112
			enc.binwrite(uint32(idx))
113
		} else {
114
			enc.binwrite(int32(v.Int()))
115
		}
116
		enc.pos += 4
117
	case reflect.Uint, reflect.Uint32:
118
		enc.binwrite(uint32(v.Uint()))
119
		enc.pos += 4
120
	case reflect.Int64:
121
		enc.binwrite(v.Int())
122
		enc.pos += 8
123
	case reflect.Uint64:
124
		enc.binwrite(v.Uint())
125
		enc.pos += 8
126
	case reflect.Float64:
127
		enc.binwrite(v.Float())
128
		enc.pos += 8
129
	case reflect.String:
130
		str := v.String()
131
		if !utf8.ValidString(str) {
132
			panic(FormatError("input has a not-utf8 char in string"))
133
		}
134
		if strings.IndexByte(str, byte(0)) != -1 {
135
			panic(FormatError("input has a null char('\\000') in string"))
136
		}
137
		if v.Type() == objectPathType {
138
			if !ObjectPath(str).IsValid() {
139
				panic(FormatError("invalid object path"))
140
			}
141
		}
142
		enc.encode(reflect.ValueOf(uint32(len(str))), depth)
143
		b := make([]byte, v.Len()+1)
144
		copy(b, str)
145
		b[len(b)-1] = 0
146
		n, err := enc.out.Write(b)
147
		if err != nil {
148
			panic(err)
149
		}
150
		enc.pos += n
151
	case reflect.Ptr:
152
		enc.encode(v.Elem(), depth)
153
	case reflect.Slice, reflect.Array:
154
		// Lookahead offset: 4 bytes for uint32 length (with alignment),
155
		// plus alignment for elements.
156
		n := enc.padding(0, 4) + 4
157
		offset := enc.pos + n + enc.padding(n, alignment(v.Type().Elem()))
158

159
		var buf bytes.Buffer
160
		bufenc := newEncoderAtOffset(&buf, offset, enc.order, enc.fds)
161

162
		for i := 0; i < v.Len(); i++ {
163
			bufenc.encode(v.Index(i), depth+1)
164
		}
165

166
		if buf.Len() > 1<<26 {
167
			panic(FormatError("input exceeds array size limitation"))
168
		}
169

170
		enc.fds = bufenc.fds
171
		enc.encode(reflect.ValueOf(uint32(buf.Len())), depth)
172
		length := buf.Len()
173
		enc.align(alignment(v.Type().Elem()))
174
		if _, err := buf.WriteTo(enc.out); err != nil {
175
			panic(err)
176
		}
177
		enc.pos += length
178
	case reflect.Struct:
179
		switch t := v.Type(); t {
180
		case signatureType:
181
			str := v.Field(0)
182
			enc.encode(reflect.ValueOf(byte(str.Len())), depth)
183
			b := make([]byte, str.Len()+1)
184
			copy(b, str.String())
185
			b[len(b)-1] = 0
186
			n, err := enc.out.Write(b)
187
			if err != nil {
188
				panic(err)
189
			}
190
			enc.pos += n
191
		case variantType:
192
			variant := v.Interface().(Variant)
193
			enc.encode(reflect.ValueOf(variant.sig), depth+1)
194
			enc.encode(reflect.ValueOf(variant.value), depth+1)
195
		default:
196
			for i := 0; i < v.Type().NumField(); i++ {
197
				field := t.Field(i)
198
				if field.PkgPath == "" && field.Tag.Get("dbus") != "-" {
199
					enc.encode(v.Field(i), depth+1)
200
				}
201
			}
202
		}
203
	case reflect.Map:
204
		// Maps are arrays of structures, so they actually increase the depth by
205
		// 2.
206
		if !isKeyType(v.Type().Key()) {
207
			panic(InvalidTypeError{v.Type()})
208
		}
209
		keys := v.MapKeys()
210
		// Lookahead offset: 4 bytes for uint32 length (with alignment),
211
		// plus 8-byte alignment
212
		n := enc.padding(0, 4) + 4
213
		offset := enc.pos + n + enc.padding(n, 8)
214

215
		var buf bytes.Buffer
216
		bufenc := newEncoderAtOffset(&buf, offset, enc.order, enc.fds)
217
		for _, k := range keys {
218
			bufenc.align(8)
219
			bufenc.encode(k, depth+2)
220
			bufenc.encode(v.MapIndex(k), depth+2)
221
		}
222
		enc.fds = bufenc.fds
223
		enc.encode(reflect.ValueOf(uint32(buf.Len())), depth)
224
		length := buf.Len()
225
		enc.align(8)
226
		if _, err := buf.WriteTo(enc.out); err != nil {
227
			panic(err)
228
		}
229
		enc.pos += length
230
	case reflect.Interface:
231
		enc.encode(reflect.ValueOf(MakeVariant(v.Interface())), depth)
232
	default:
233
		panic(InvalidTypeError{v.Type()})
234
	}
235
}
236