go-tg-screenshot-bot

1
//+build !windows,!solaris
2

3
package dbus
4

5
import (
6
	"bytes"
7
	"encoding/binary"
8
	"errors"
9
	"io"
10
	"net"
11
	"syscall"
12
)
13

14
type oobReader struct {
15
	conn *net.UnixConn
16
	oob  []byte
17
	buf  [4096]byte
18
}
19

20
func (o *oobReader) Read(b []byte) (n int, err error) {
21
	n, oobn, flags, _, err := o.conn.ReadMsgUnix(b, o.buf[:])
22
	if err != nil {
23
		return n, err
24
	}
25
	if flags&syscall.MSG_CTRUNC != 0 {
26
		return n, errors.New("dbus: control data truncated (too many fds received)")
27
	}
28
	o.oob = append(o.oob, o.buf[:oobn]...)
29
	return n, nil
30
}
31

32
type unixTransport struct {
33
	*net.UnixConn
34
	rdr        *oobReader
35
	hasUnixFDs bool
36
}
37

38
func newUnixTransport(keys string) (transport, error) {
39
	var err error
40

41
	t := new(unixTransport)
42
	abstract := getKey(keys, "abstract")
43
	path := getKey(keys, "path")
44
	switch {
45
	case abstract == "" && path == "":
46
		return nil, errors.New("dbus: invalid address (neither path nor abstract set)")
47
	case abstract != "" && path == "":
48
		t.UnixConn, err = net.DialUnix("unix", nil, &net.UnixAddr{Name: "@" + abstract, Net: "unix"})
49
		if err != nil {
50
			return nil, err
51
		}
52
		return t, nil
53
	case abstract == "" && path != "":
54
		t.UnixConn, err = net.DialUnix("unix", nil, &net.UnixAddr{Name: path, Net: "unix"})
55
		if err != nil {
56
			return nil, err
57
		}
58
		return t, nil
59
	default:
60
		return nil, errors.New("dbus: invalid address (both path and abstract set)")
61
	}
62
}
63

64
func init() {
65
	transports["unix"] = newUnixTransport
66
}
67

68
func (t *unixTransport) EnableUnixFDs() {
69
	t.hasUnixFDs = true
70
}
71

72
func (t *unixTransport) ReadMessage() (*Message, error) {
73
	var (
74
		blen, hlen uint32
75
		csheader   [16]byte
76
		headers    []header
77
		order      binary.ByteOrder
78
		unixfds    uint32
79
	)
80
	// To be sure that all bytes of out-of-band data are read, we use a special
81
	// reader that uses ReadUnix on the underlying connection instead of Read
82
	// and gathers the out-of-band data in a buffer.
83
	if t.rdr == nil {
84
		t.rdr = &oobReader{conn: t.UnixConn}
85
	} else {
86
		t.rdr.oob = nil
87
	}
88

89
	// read the first 16 bytes (the part of the header that has a constant size),
90
	// from which we can figure out the length of the rest of the message
91
	if _, err := io.ReadFull(t.rdr, csheader[:]); err != nil {
92
		return nil, err
93
	}
94
	switch csheader[0] {
95
	case 'l':
96
		order = binary.LittleEndian
97
	case 'B':
98
		order = binary.BigEndian
99
	default:
100
		return nil, InvalidMessageError("invalid byte order")
101
	}
102
	// csheader[4:8] -> length of message body, csheader[12:16] -> length of
103
	// header fields (without alignment)
104
	binary.Read(bytes.NewBuffer(csheader[4:8]), order, &blen)
105
	binary.Read(bytes.NewBuffer(csheader[12:]), order, &hlen)
106
	if hlen%8 != 0 {
107
		hlen += 8 - (hlen % 8)
108
	}
109

110
	// decode headers and look for unix fds
111
	headerdata := make([]byte, hlen+4)
112
	copy(headerdata, csheader[12:])
113
	if _, err := io.ReadFull(t.rdr, headerdata[4:]); err != nil {
114
		return nil, err
115
	}
116
	dec := newDecoder(bytes.NewBuffer(headerdata), order, make([]int, 0))
117
	dec.pos = 12
118
	vs, err := dec.Decode(Signature{"a(yv)"})
119
	if err != nil {
120
		return nil, err
121
	}
122
	Store(vs, &headers)
123
	for _, v := range headers {
124
		if v.Field == byte(FieldUnixFDs) {
125
			unixfds, _ = v.Variant.value.(uint32)
126
		}
127
	}
128
	all := make([]byte, 16+hlen+blen)
129
	copy(all, csheader[:])
130
	copy(all[16:], headerdata[4:])
131
	if _, err := io.ReadFull(t.rdr, all[16+hlen:]); err != nil {
132
		return nil, err
133
	}
134
	if unixfds != 0 {
135
		if !t.hasUnixFDs {
136
			return nil, errors.New("dbus: got unix fds on unsupported transport")
137
		}
138
		// read the fds from the OOB data
139
		scms, err := syscall.ParseSocketControlMessage(t.rdr.oob)
140
		if err != nil {
141
			return nil, err
142
		}
143
		if len(scms) != 1 {
144
			return nil, errors.New("dbus: received more than one socket control message")
145
		}
146
		fds, err := syscall.ParseUnixRights(&scms[0])
147
		if err != nil {
148
			return nil, err
149
		}
150
		msg, err := DecodeMessageWithFDs(bytes.NewBuffer(all), fds)
151
		if err != nil {
152
			return nil, err
153
		}
154
		// substitute the values in the message body (which are indices for the
155
		// array receiver via OOB) with the actual values
156
		for i, v := range msg.Body {
157
			switch index := v.(type) {
158
			case UnixFDIndex:
159
				if uint32(index) >= unixfds {
160
					return nil, InvalidMessageError("invalid index for unix fd")
161
				}
162
				msg.Body[i] = UnixFD(fds[index])
163
			case []UnixFDIndex:
164
				fdArray := make([]UnixFD, len(index))
165
				for k, j := range index {
166
					if uint32(j) >= unixfds {
167
						return nil, InvalidMessageError("invalid index for unix fd")
168
					}
169
					fdArray[k] = UnixFD(fds[j])
170
				}
171
				msg.Body[i] = fdArray
172
			}
173
		}
174
		return msg, nil
175
	}
176
	return DecodeMessage(bytes.NewBuffer(all))
177
}
178

179
func (t *unixTransport) SendMessage(msg *Message) error {
180
	fdcnt, err := msg.CountFds()
181
	if err != nil {
182
		return err
183
	}
184
	if fdcnt != 0 {
185
		if !t.hasUnixFDs {
186
			return errors.New("dbus: unix fd passing not enabled")
187
		}
188
		msg.Headers[FieldUnixFDs] = MakeVariant(uint32(fdcnt))
189
		buf := new(bytes.Buffer)
190
		fds, err := msg.EncodeToWithFDs(buf, nativeEndian)
191
		if err != nil {
192
			return err
193
		}
194
		oob := syscall.UnixRights(fds...)
195
		n, oobn, err := t.UnixConn.WriteMsgUnix(buf.Bytes(), oob, nil)
196
		if err != nil {
197
			return err
198
		}
199
		if n != buf.Len() || oobn != len(oob) {
200
			return io.ErrShortWrite
201
		}
202
	} else {
203
		if err := msg.EncodeTo(t, nativeEndian); err != nil {
204
			return err
205
		}
206
	}
207
	return nil
208
}
209

210
func (t *unixTransport) SupportsUnixFDs() bool {
211
	return true
212
}
213