go-tg-screenshot-bot

1
package dbus
2

3
import (
4
	"bytes"
5
	"reflect"
6
	"strings"
7
	"sync"
8
)
9

10
func newIntrospectIntf(h *defaultHandler) *exportedIntf {
11
	methods := make(map[string]Method)
12
	methods["Introspect"] = exportedMethod{
13
		reflect.ValueOf(func(msg Message) (string, *Error) {
14
			path := msg.Headers[FieldPath].value.(ObjectPath)
15
			return h.introspectPath(path), nil
16
		}),
17
	}
18
	return newExportedIntf(methods, true)
19
}
20

21
//NewDefaultHandler returns an instance of the default
22
//call handler. This is useful if you want to implement only
23
//one of the two handlers but not both.
24
//
25
// Deprecated: this is the default value, don't use it, it will be unexported.
26
func NewDefaultHandler() *defaultHandler {
27
	h := &defaultHandler{
28
		objects:     make(map[ObjectPath]*exportedObj),
29
		defaultIntf: make(map[string]*exportedIntf),
30
	}
31
	h.defaultIntf["org.freedesktop.DBus.Introspectable"] = newIntrospectIntf(h)
32
	return h
33
}
34

35
type defaultHandler struct {
36
	sync.RWMutex
37
	objects     map[ObjectPath]*exportedObj
38
	defaultIntf map[string]*exportedIntf
39
}
40

41
func (h *defaultHandler) PathExists(path ObjectPath) bool {
42
	_, ok := h.objects[path]
43
	return ok
44
}
45

46
func (h *defaultHandler) introspectPath(path ObjectPath) string {
47
	subpath := make(map[string]struct{})
48
	var xml bytes.Buffer
49
	xml.WriteString("<node>")
50
	for obj := range h.objects {
51
		p := string(path)
52
		if p != "/" {
53
			p += "/"
54
		}
55
		if strings.HasPrefix(string(obj), p) {
56
			node_name := strings.Split(string(obj[len(p):]), "/")[0]
57
			subpath[node_name] = struct{}{}
58
		}
59
	}
60
	for s := range subpath {
61
		xml.WriteString("\n\t<node name=\"" + s + "\"/>")
62
	}
63
	xml.WriteString("\n</node>")
64
	return xml.String()
65
}
66

67
func (h *defaultHandler) LookupObject(path ObjectPath) (ServerObject, bool) {
68
	h.RLock()
69
	defer h.RUnlock()
70
	object, ok := h.objects[path]
71
	if ok {
72
		return object, ok
73
	}
74

75
	// If an object wasn't found for this exact path,
76
	// look for a matching subtree registration
77
	subtreeObject := newExportedObject()
78
	path = path[:strings.LastIndex(string(path), "/")]
79
	for len(path) > 0 {
80
		object, ok = h.objects[path]
81
		if ok {
82
			for name, iface := range object.interfaces {
83
				// Only include this handler if it registered for the subtree
84
				if iface.isFallbackInterface() {
85
					subtreeObject.interfaces[name] = iface
86
				}
87
			}
88
			break
89
		}
90

91
		path = path[:strings.LastIndex(string(path), "/")]
92
	}
93

94
	for name, intf := range h.defaultIntf {
95
		if _, exists := subtreeObject.interfaces[name]; exists {
96
			continue
97
		}
98
		subtreeObject.interfaces[name] = intf
99
	}
100

101
	return subtreeObject, true
102
}
103

104
func (h *defaultHandler) AddObject(path ObjectPath, object *exportedObj) {
105
	h.Lock()
106
	h.objects[path] = object
107
	h.Unlock()
108
}
109

110
func (h *defaultHandler) DeleteObject(path ObjectPath) {
111
	h.Lock()
112
	delete(h.objects, path)
113
	h.Unlock()
114
}
115

116
type exportedMethod struct {
117
	reflect.Value
118
}
119

120
func (m exportedMethod) Call(args ...interface{}) ([]interface{}, error) {
121
	t := m.Type()
122

123
	params := make([]reflect.Value, len(args))
124
	for i := 0; i < len(args); i++ {
125
		params[i] = reflect.ValueOf(args[i]).Elem()
126
	}
127

128
	ret := m.Value.Call(params)
129
	var err error
130
	nilErr := false // The reflection will find almost-nils, let's only pass back clean ones!
131
	if t.NumOut() > 0 {
132
		if e, ok := ret[t.NumOut()-1].Interface().(*Error); ok { // godbus *Error
133
			nilErr = ret[t.NumOut()-1].IsNil()
134
			ret = ret[:t.NumOut()-1]
135
			err = e
136
		} else if ret[t.NumOut()-1].Type().Implements(errType) { // Go error
137
			i := ret[t.NumOut()-1].Interface()
138
			if i == nil {
139
				nilErr = ret[t.NumOut()-1].IsNil()
140
			} else {
141
				err = i.(error)
142
			}
143
			ret = ret[:t.NumOut()-1]
144
		}
145
	}
146
	out := make([]interface{}, len(ret))
147
	for i, val := range ret {
148
		out[i] = val.Interface()
149
	}
150
	if nilErr || err == nil {
151
		//concrete type to interface nil is a special case
152
		return out, nil
153
	}
154
	return out, err
155
}
156

157
func (m exportedMethod) NumArguments() int {
158
	return m.Value.Type().NumIn()
159
}
160

161
func (m exportedMethod) ArgumentValue(i int) interface{} {
162
	return reflect.Zero(m.Type().In(i)).Interface()
163
}
164

165
func (m exportedMethod) NumReturns() int {
166
	return m.Value.Type().NumOut()
167
}
168

169
func (m exportedMethod) ReturnValue(i int) interface{} {
170
	return reflect.Zero(m.Type().Out(i)).Interface()
171
}
172

173
func newExportedObject() *exportedObj {
174
	return &exportedObj{
175
		interfaces: make(map[string]*exportedIntf),
176
	}
177
}
178

179
type exportedObj struct {
180
	mu         sync.RWMutex
181
	interfaces map[string]*exportedIntf
182
}
183

184
func (obj *exportedObj) LookupInterface(name string) (Interface, bool) {
185
	if name == "" {
186
		return obj, true
187
	}
188
	obj.mu.RLock()
189
	defer obj.mu.RUnlock()
190
	intf, exists := obj.interfaces[name]
191
	return intf, exists
192
}
193

194
func (obj *exportedObj) AddInterface(name string, iface *exportedIntf) {
195
	obj.mu.Lock()
196
	defer obj.mu.Unlock()
197
	obj.interfaces[name] = iface
198
}
199

200
func (obj *exportedObj) DeleteInterface(name string) {
201
	obj.mu.Lock()
202
	defer obj.mu.Unlock()
203
	delete(obj.interfaces, name)
204
}
205

206
func (obj *exportedObj) LookupMethod(name string) (Method, bool) {
207
	obj.mu.RLock()
208
	defer obj.mu.RUnlock()
209
	for _, intf := range obj.interfaces {
210
		method, exists := intf.LookupMethod(name)
211
		if exists {
212
			return method, exists
213
		}
214
	}
215
	return nil, false
216
}
217

218
func (obj *exportedObj) isFallbackInterface() bool {
219
	return false
220
}
221

222
func newExportedIntf(methods map[string]Method, includeSubtree bool) *exportedIntf {
223
	return &exportedIntf{
224
		methods:        methods,
225
		includeSubtree: includeSubtree,
226
	}
227
}
228

229
type exportedIntf struct {
230
	methods map[string]Method
231

232
	// Whether or not this export is for the entire subtree
233
	includeSubtree bool
234
}
235

236
func (obj *exportedIntf) LookupMethod(name string) (Method, bool) {
237
	out, exists := obj.methods[name]
238
	return out, exists
239
}
240

241
func (obj *exportedIntf) isFallbackInterface() bool {
242
	return obj.includeSubtree
243
}
244

245
//NewDefaultSignalHandler returns an instance of the default
246
//signal handler. This is useful if you want to implement only
247
//one of the two handlers but not both.
248
//
249
// Deprecated: this is the default value, don't use it, it will be unexported.
250
func NewDefaultSignalHandler() *defaultSignalHandler {
251
	return &defaultSignalHandler{}
252
}
253

254
type defaultSignalHandler struct {
255
	mu      sync.RWMutex
256
	closed  bool
257
	signals []*signalChannelData
258
}
259

260
func (sh *defaultSignalHandler) DeliverSignal(intf, name string, signal *Signal) {
261
	sh.mu.RLock()
262
	defer sh.mu.RUnlock()
263
	if sh.closed {
264
		return
265
	}
266
	for _, scd := range sh.signals {
267
		scd.deliver(signal)
268
	}
269
}
270

271
func (sh *defaultSignalHandler) Terminate() {
272
	sh.mu.Lock()
273
	defer sh.mu.Unlock()
274
	if sh.closed {
275
		return
276
	}
277

278
	for _, scd := range sh.signals {
279
		scd.close()
280
		close(scd.ch)
281
	}
282
	sh.closed = true
283
	sh.signals = nil
284
}
285

286
func (sh *defaultSignalHandler) AddSignal(ch chan<- *Signal) {
287
	sh.mu.Lock()
288
	defer sh.mu.Unlock()
289
	if sh.closed {
290
		return
291
	}
292
	sh.signals = append(sh.signals, &signalChannelData{
293
		ch:   ch,
294
		done: make(chan struct{}),
295
	})
296
}
297

298
func (sh *defaultSignalHandler) RemoveSignal(ch chan<- *Signal) {
299
	sh.mu.Lock()
300
	defer sh.mu.Unlock()
301
	if sh.closed {
302
		return
303
	}
304
	for i := len(sh.signals) - 1; i >= 0; i-- {
305
		if ch == sh.signals[i].ch {
306
			sh.signals[i].close()
307
			copy(sh.signals[i:], sh.signals[i+1:])
308
			sh.signals[len(sh.signals)-1] = nil
309
			sh.signals = sh.signals[:len(sh.signals)-1]
310
		}
311
	}
312
}
313

314
type signalChannelData struct {
315
	wg   sync.WaitGroup
316
	ch   chan<- *Signal
317
	done chan struct{}
318
}
319

320
func (scd *signalChannelData) deliver(signal *Signal) {
321
	select {
322
	case scd.ch <- signal:
323
	case <-scd.done:
324
		return
325
	default:
326
		scd.wg.Add(1)
327
		go scd.deferredDeliver(signal)
328
	}
329
}
330

331
func (scd *signalChannelData) deferredDeliver(signal *Signal) {
332
	select {
333
	case scd.ch <- signal:
334
	case <-scd.done:
335
	}
336
	scd.wg.Done()
337
}
338

339
func (scd *signalChannelData) close() {
340
	close(scd.done)
341
	scd.wg.Wait() // wait until all spawned goroutines return
342
}
343