go-tg-screenshot-bot

1
package dbus
2

3
import (
4
	"bytes"
5
	"encoding/binary"
6
	"errors"
7
	"io"
8
	"reflect"
9
	"strconv"
10
)
11

12
const protoVersion byte = 1
13

14
// Flags represents the possible flags of a D-Bus message.
15
type Flags byte
16

17
const (
18
	// FlagNoReplyExpected signals that the message is not expected to generate
19
	// a reply. If this flag is set on outgoing messages, any possible reply
20
	// will be discarded.
21
	FlagNoReplyExpected Flags = 1 << iota
22
	// FlagNoAutoStart signals that the message bus should not automatically
23
	// start an application when handling this message.
24
	FlagNoAutoStart
25
	// FlagAllowInteractiveAuthorization may be set on a method call
26
	// message to inform the receiving side that the caller is prepared
27
	// to wait for interactive authorization, which might take a
28
	// considerable time to complete. For instance, if this flag is set,
29
	// it would be appropriate to query the user for passwords or
30
	// confirmation via Polkit or a similar framework.
31
	FlagAllowInteractiveAuthorization
32
)
33

34
// Type represents the possible types of a D-Bus message.
35
type Type byte
36

37
const (
38
	TypeMethodCall Type = 1 + iota
39
	TypeMethodReply
40
	TypeError
41
	TypeSignal
42
	typeMax
43
)
44

45
func (t Type) String() string {
46
	switch t {
47
	case TypeMethodCall:
48
		return "method call"
49
	case TypeMethodReply:
50
		return "reply"
51
	case TypeError:
52
		return "error"
53
	case TypeSignal:
54
		return "signal"
55
	}
56
	return "invalid"
57
}
58

59
// HeaderField represents the possible byte codes for the headers
60
// of a D-Bus message.
61
type HeaderField byte
62

63
const (
64
	FieldPath HeaderField = 1 + iota
65
	FieldInterface
66
	FieldMember
67
	FieldErrorName
68
	FieldReplySerial
69
	FieldDestination
70
	FieldSender
71
	FieldSignature
72
	FieldUnixFDs
73
	fieldMax
74
)
75

76
// An InvalidMessageError describes the reason why a D-Bus message is regarded as
77
// invalid.
78
type InvalidMessageError string
79

80
func (e InvalidMessageError) Error() string {
81
	return "dbus: invalid message: " + string(e)
82
}
83

84
// fieldType are the types of the various header fields.
85
var fieldTypes = [fieldMax]reflect.Type{
86
	FieldPath:        objectPathType,
87
	FieldInterface:   stringType,
88
	FieldMember:      stringType,
89
	FieldErrorName:   stringType,
90
	FieldReplySerial: uint32Type,
91
	FieldDestination: stringType,
92
	FieldSender:      stringType,
93
	FieldSignature:   signatureType,
94
	FieldUnixFDs:     uint32Type,
95
}
96

97
// requiredFields lists the header fields that are required by the different
98
// message types.
99
var requiredFields = [typeMax][]HeaderField{
100
	TypeMethodCall:  {FieldPath, FieldMember},
101
	TypeMethodReply: {FieldReplySerial},
102
	TypeError:       {FieldErrorName, FieldReplySerial},
103
	TypeSignal:      {FieldPath, FieldInterface, FieldMember},
104
}
105

106
// Message represents a single D-Bus message.
107
type Message struct {
108
	Type
109
	Flags
110
	Headers map[HeaderField]Variant
111
	Body    []interface{}
112

113
	serial uint32
114
}
115

116
type header struct {
117
	Field byte
118
	Variant
119
}
120

121
func DecodeMessageWithFDs(rd io.Reader, fds []int) (msg *Message, err error) {
122
	var order binary.ByteOrder
123
	var hlength, length uint32
124
	var typ, flags, proto byte
125
	var headers []header
126

127
	b := make([]byte, 1)
128
	_, err = rd.Read(b)
129
	if err != nil {
130
		return
131
	}
132
	switch b[0] {
133
	case 'l':
134
		order = binary.LittleEndian
135
	case 'B':
136
		order = binary.BigEndian
137
	default:
138
		return nil, InvalidMessageError("invalid byte order")
139
	}
140

141
	dec := newDecoder(rd, order, fds)
142
	dec.pos = 1
143

144
	msg = new(Message)
145
	vs, err := dec.Decode(Signature{"yyyuu"})
146
	if err != nil {
147
		return nil, err
148
	}
149
	if err = Store(vs, &typ, &flags, &proto, &length, &msg.serial); err != nil {
150
		return nil, err
151
	}
152
	msg.Type = Type(typ)
153
	msg.Flags = Flags(flags)
154

155
	// get the header length separately because we need it later
156
	b = make([]byte, 4)
157
	_, err = io.ReadFull(rd, b)
158
	if err != nil {
159
		return nil, err
160
	}
161
	binary.Read(bytes.NewBuffer(b), order, &hlength)
162
	if hlength+length+16 > 1<<27 {
163
		return nil, InvalidMessageError("message is too long")
164
	}
165
	dec = newDecoder(io.MultiReader(bytes.NewBuffer(b), rd), order, fds)
166
	dec.pos = 12
167
	vs, err = dec.Decode(Signature{"a(yv)"})
168
	if err != nil {
169
		return nil, err
170
	}
171
	if err = Store(vs, &headers); err != nil {
172
		return nil, err
173
	}
174

175
	msg.Headers = make(map[HeaderField]Variant)
176
	for _, v := range headers {
177
		msg.Headers[HeaderField(v.Field)] = v.Variant
178
	}
179

180
	dec.align(8)
181
	body := make([]byte, int(length))
182
	if length != 0 {
183
		_, err := io.ReadFull(rd, body)
184
		if err != nil {
185
			return nil, err
186
		}
187
	}
188

189
	if err = msg.IsValid(); err != nil {
190
		return nil, err
191
	}
192
	sig, _ := msg.Headers[FieldSignature].value.(Signature)
193
	if sig.str != "" {
194
		buf := bytes.NewBuffer(body)
195
		dec = newDecoder(buf, order, fds)
196
		vs, err := dec.Decode(sig)
197
		if err != nil {
198
			return nil, err
199
		}
200
		msg.Body = vs
201
	}
202

203
	return
204
}
205

206
// DecodeMessage tries to decode a single message in the D-Bus wire format
207
// from the given reader. The byte order is figured out from the first byte.
208
// The possibly returned error can be an error of the underlying reader, an
209
// InvalidMessageError or a FormatError.
210
func DecodeMessage(rd io.Reader) (msg *Message, err error) {
211
	return DecodeMessageWithFDs(rd, make([]int, 0))
212
}
213

214
type nullwriter struct{}
215

216
func (nullwriter) Write(p []byte) (cnt int, err error) {
217
	return len(p), nil
218
}
219

220
func (msg *Message) CountFds() (int, error) {
221
	if len(msg.Body) == 0 {
222
		return 0, nil
223
	}
224
	enc := newEncoder(nullwriter{}, nativeEndian, make([]int, 0))
225
	err := enc.Encode(msg.Body...)
226
	return len(enc.fds), err
227
}
228

229
func (msg *Message) EncodeToWithFDs(out io.Writer, order binary.ByteOrder) (fds []int, err error) {
230
	if err := msg.validateHeader(); err != nil {
231
		return nil, err
232
	}
233
	var vs [7]interface{}
234
	switch order {
235
	case binary.LittleEndian:
236
		vs[0] = byte('l')
237
	case binary.BigEndian:
238
		vs[0] = byte('B')
239
	default:
240
		return nil, errors.New("dbus: invalid byte order")
241
	}
242
	body := new(bytes.Buffer)
243
	fds = make([]int, 0)
244
	enc := newEncoder(body, order, fds)
245
	if len(msg.Body) != 0 {
246
		err = enc.Encode(msg.Body...)
247
		if err != nil {
248
			return
249
		}
250
	}
251
	vs[1] = msg.Type
252
	vs[2] = msg.Flags
253
	vs[3] = protoVersion
254
	vs[4] = uint32(len(body.Bytes()))
255
	vs[5] = msg.serial
256
	headers := make([]header, 0, len(msg.Headers))
257
	for k, v := range msg.Headers {
258
		headers = append(headers, header{byte(k), v})
259
	}
260
	vs[6] = headers
261
	var buf bytes.Buffer
262
	enc = newEncoder(&buf, order, enc.fds)
263
	err = enc.Encode(vs[:]...)
264
	if err != nil {
265
		return
266
	}
267
	enc.align(8)
268
	body.WriteTo(&buf)
269
	if buf.Len() > 1<<27 {
270
		return make([]int, 0), InvalidMessageError("message is too long")
271
	}
272
	if _, err := buf.WriteTo(out); err != nil {
273
		return make([]int, 0), err
274
	}
275
	return enc.fds, nil
276
}
277

278
// EncodeTo encodes and sends a message to the given writer. The byte order must
279
// be either binary.LittleEndian or binary.BigEndian. If the message is not
280
// valid or an error occurs when writing, an error is returned.
281
func (msg *Message) EncodeTo(out io.Writer, order binary.ByteOrder) (err error) {
282
	_, err = msg.EncodeToWithFDs(out, order)
283
	return err
284
}
285

286
// IsValid checks whether msg is a valid message and returns an
287
// InvalidMessageError or FormatError if it is not.
288
func (msg *Message) IsValid() error {
289
	var b bytes.Buffer
290
	return msg.EncodeTo(&b, nativeEndian)
291
}
292

293
func (msg *Message) validateHeader() error {
294
	if msg.Flags & ^(FlagNoAutoStart|FlagNoReplyExpected|FlagAllowInteractiveAuthorization) != 0 {
295
		return InvalidMessageError("invalid flags")
296
	}
297
	if msg.Type == 0 || msg.Type >= typeMax {
298
		return InvalidMessageError("invalid message type")
299
	}
300
	for k, v := range msg.Headers {
301
		if k == 0 || k >= fieldMax {
302
			return InvalidMessageError("invalid header")
303
		}
304
		if reflect.TypeOf(v.value) != fieldTypes[k] {
305
			return InvalidMessageError("invalid type of header field")
306
		}
307
	}
308
	for _, v := range requiredFields[msg.Type] {
309
		if _, ok := msg.Headers[v]; !ok {
310
			return InvalidMessageError("missing required header")
311
		}
312
	}
313
	if path, ok := msg.Headers[FieldPath]; ok {
314
		if !path.value.(ObjectPath).IsValid() {
315
			return InvalidMessageError("invalid path name")
316
		}
317
	}
318
	if iface, ok := msg.Headers[FieldInterface]; ok {
319
		if !isValidInterface(iface.value.(string)) {
320
			return InvalidMessageError("invalid interface name")
321
		}
322
	}
323
	if member, ok := msg.Headers[FieldMember]; ok {
324
		if !isValidMember(member.value.(string)) {
325
			return InvalidMessageError("invalid member name")
326
		}
327
	}
328
	if errname, ok := msg.Headers[FieldErrorName]; ok {
329
		if !isValidInterface(errname.value.(string)) {
330
			return InvalidMessageError("invalid error name")
331
		}
332
	}
333
	if len(msg.Body) != 0 {
334
		if _, ok := msg.Headers[FieldSignature]; !ok {
335
			return InvalidMessageError("missing signature")
336
		}
337
	}
338

339
	return nil
340
}
341

342
// Serial returns the message's serial number. The returned value is only valid
343
// for messages received by eavesdropping.
344
func (msg *Message) Serial() uint32 {
345
	return msg.serial
346
}
347

348
// String returns a string representation of a message similar to the format of
349
// dbus-monitor.
350
func (msg *Message) String() string {
351
	if err := msg.IsValid(); err != nil {
352
		return "<invalid>"
353
	}
354
	s := msg.Type.String()
355
	if v, ok := msg.Headers[FieldSender]; ok {
356
		s += " from " + v.value.(string)
357
	}
358
	if v, ok := msg.Headers[FieldDestination]; ok {
359
		s += " to " + v.value.(string)
360
	}
361
	s += " serial " + strconv.FormatUint(uint64(msg.serial), 10)
362
	if v, ok := msg.Headers[FieldReplySerial]; ok {
363
		s += " reply_serial " + strconv.FormatUint(uint64(v.value.(uint32)), 10)
364
	}
365
	if v, ok := msg.Headers[FieldUnixFDs]; ok {
366
		s += " unixfds " + strconv.FormatUint(uint64(v.value.(uint32)), 10)
367
	}
368
	if v, ok := msg.Headers[FieldPath]; ok {
369
		s += " path " + string(v.value.(ObjectPath))
370
	}
371
	if v, ok := msg.Headers[FieldInterface]; ok {
372
		s += " interface " + v.value.(string)
373
	}
374
	if v, ok := msg.Headers[FieldErrorName]; ok {
375
		s += " error " + v.value.(string)
376
	}
377
	if v, ok := msg.Headers[FieldMember]; ok {
378
		s += " member " + v.value.(string)
379
	}
380
	if len(msg.Body) != 0 {
381
		s += "\n"
382
	}
383
	for i, v := range msg.Body {
384
		s += "  " + MakeVariant(v).String()
385
		if i != len(msg.Body)-1 {
386
			s += "\n"
387
		}
388
	}
389
	return s
390
}
391