summaryrefslogtreecommitdiff
path: root/vendor/github.com/godbus/dbus/v5/conn.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/godbus/dbus/v5/conn.go')
-rw-r--r--vendor/github.com/godbus/dbus/v5/conn.go959
1 files changed, 0 insertions, 959 deletions
diff --git a/vendor/github.com/godbus/dbus/v5/conn.go b/vendor/github.com/godbus/dbus/v5/conn.go
deleted file mode 100644
index 29fe018ad..000000000
--- a/vendor/github.com/godbus/dbus/v5/conn.go
+++ /dev/null
@@ -1,959 +0,0 @@
-package dbus
-
-import (
- "context"
- "errors"
- "io"
- "os"
- "strings"
- "sync"
-)
-
-var (
- systemBus *Conn
- systemBusLck sync.Mutex
- sessionBus *Conn
- sessionBusLck sync.Mutex
-)
-
-// ErrClosed is the error returned by calls on a closed connection.
-var ErrClosed = errors.New("dbus: connection closed by user")
-
-// Conn represents a connection to a message bus (usually, the system or
-// session bus).
-//
-// Connections are either shared or private. Shared connections
-// are shared between calls to the functions that return them. As a result,
-// the methods Close, Auth and Hello must not be called on them.
-//
-// Multiple goroutines may invoke methods on a connection simultaneously.
-type Conn struct {
- transport
-
- ctx context.Context
- cancelCtx context.CancelFunc
-
- closeOnce sync.Once
- closeErr error
-
- busObj BusObject
- unixFD bool
- uuid string
-
- handler Handler
- signalHandler SignalHandler
- serialGen SerialGenerator
- inInt Interceptor
- outInt Interceptor
- auth []Auth
-
- names *nameTracker
- calls *callTracker
- outHandler *outputHandler
-
- eavesdropped chan<- *Message
- eavesdroppedLck sync.Mutex
-}
-
-// SessionBus returns a shared connection to the session bus, connecting to it
-// if not already done.
-func SessionBus() (conn *Conn, err error) {
- sessionBusLck.Lock()
- defer sessionBusLck.Unlock()
- if sessionBus != nil &&
- sessionBus.Connected() {
- return sessionBus, nil
- }
- defer func() {
- if conn != nil {
- sessionBus = conn
- }
- }()
- conn, err = ConnectSessionBus()
- return
-}
-
-func getSessionBusAddress() (string, error) {
- if address := os.Getenv("DBUS_SESSION_BUS_ADDRESS"); address != "" && address != "autolaunch:" {
- return address, nil
-
- } else if address := tryDiscoverDbusSessionBusAddress(); address != "" {
- os.Setenv("DBUS_SESSION_BUS_ADDRESS", address)
- return address, nil
- }
- return getSessionBusPlatformAddress()
-}
-
-// SessionBusPrivate returns a new private connection to the session bus.
-func SessionBusPrivate(opts ...ConnOption) (*Conn, error) {
- address, err := getSessionBusAddress()
- if err != nil {
- return nil, err
- }
-
- return Dial(address, opts...)
-}
-
-// SessionBusPrivate returns a new private connection to the session bus.
-//
-// Deprecated: use SessionBusPrivate with options instead.
-func SessionBusPrivateHandler(handler Handler, signalHandler SignalHandler) (*Conn, error) {
- return SessionBusPrivate(WithHandler(handler), WithSignalHandler(signalHandler))
-}
-
-// SystemBus returns a shared connection to the system bus, connecting to it if
-// not already done.
-func SystemBus() (conn *Conn, err error) {
- systemBusLck.Lock()
- defer systemBusLck.Unlock()
- if systemBus != nil &&
- systemBus.Connected() {
- return systemBus, nil
- }
- defer func() {
- if conn != nil {
- systemBus = conn
- }
- }()
- conn, err = ConnectSystemBus()
- return
-}
-
-// ConnectSessionBus connects to the session bus.
-func ConnectSessionBus(opts ...ConnOption) (*Conn, error) {
- address, err := getSessionBusAddress()
- if err != nil {
- return nil, err
- }
- return Connect(address, opts...)
-}
-
-// ConnectSystemBus connects to the system bus.
-func ConnectSystemBus(opts ...ConnOption) (*Conn, error) {
- return Connect(getSystemBusPlatformAddress(), opts...)
-}
-
-// Connect connects to the given address.
-//
-// Returned connection is ready to use and doesn't require calling
-// Auth and Hello methods to make it usable.
-func Connect(address string, opts ...ConnOption) (*Conn, error) {
- conn, err := Dial(address, opts...)
- if err != nil {
- return nil, err
- }
- if err = conn.Auth(conn.auth); err != nil {
- _ = conn.Close()
- return nil, err
- }
- if err = conn.Hello(); err != nil {
- _ = conn.Close()
- return nil, err
- }
- return conn, nil
-}
-
-// SystemBusPrivate returns a new private connection to the system bus.
-// Note: this connection is not ready to use. One must perform Auth and Hello
-// on the connection before it is useable.
-func SystemBusPrivate(opts ...ConnOption) (*Conn, error) {
- return Dial(getSystemBusPlatformAddress(), opts...)
-}
-
-// SystemBusPrivateHandler returns a new private connection to the system bus, using the provided handlers.
-//
-// Deprecated: use SystemBusPrivate with options instead.
-func SystemBusPrivateHandler(handler Handler, signalHandler SignalHandler) (*Conn, error) {
- return SystemBusPrivate(WithHandler(handler), WithSignalHandler(signalHandler))
-}
-
-// Dial establishes a new private connection to the message bus specified by address.
-func Dial(address string, opts ...ConnOption) (*Conn, error) {
- tr, err := getTransport(address)
- if err != nil {
- return nil, err
- }
- return newConn(tr, opts...)
-}
-
-// DialHandler establishes a new private connection to the message bus specified by address, using the supplied handlers.
-//
-// Deprecated: use Dial with options instead.
-func DialHandler(address string, handler Handler, signalHandler SignalHandler) (*Conn, error) {
- return Dial(address, WithSignalHandler(signalHandler))
-}
-
-// ConnOption is a connection option.
-type ConnOption func(conn *Conn) error
-
-// WithHandler overrides the default handler.
-func WithHandler(handler Handler) ConnOption {
- return func(conn *Conn) error {
- conn.handler = handler
- return nil
- }
-}
-
-// WithSignalHandler overrides the default signal handler.
-func WithSignalHandler(handler SignalHandler) ConnOption {
- return func(conn *Conn) error {
- conn.signalHandler = handler
- return nil
- }
-}
-
-// WithSerialGenerator overrides the default signals generator.
-func WithSerialGenerator(gen SerialGenerator) ConnOption {
- return func(conn *Conn) error {
- conn.serialGen = gen
- return nil
- }
-}
-
-// WithAuth sets authentication methods for the auth conversation.
-func WithAuth(methods ...Auth) ConnOption {
- return func(conn *Conn) error {
- conn.auth = methods
- return nil
- }
-}
-
-// Interceptor intercepts incoming and outgoing messages.
-type Interceptor func(msg *Message)
-
-// WithIncomingInterceptor sets the given interceptor for incoming messages.
-func WithIncomingInterceptor(interceptor Interceptor) ConnOption {
- return func(conn *Conn) error {
- conn.inInt = interceptor
- return nil
- }
-}
-
-// WithOutgoingInterceptor sets the given interceptor for outgoing messages.
-func WithOutgoingInterceptor(interceptor Interceptor) ConnOption {
- return func(conn *Conn) error {
- conn.outInt = interceptor
- return nil
- }
-}
-
-// WithContext overrides the default context for the connection.
-func WithContext(ctx context.Context) ConnOption {
- return func(conn *Conn) error {
- conn.ctx = ctx
- return nil
- }
-}
-
-// NewConn creates a new private *Conn from an already established connection.
-func NewConn(conn io.ReadWriteCloser, opts ...ConnOption) (*Conn, error) {
- return newConn(genericTransport{conn}, opts...)
-}
-
-// NewConnHandler creates a new private *Conn from an already established connection, using the supplied handlers.
-//
-// Deprecated: use NewConn with options instead.
-func NewConnHandler(conn io.ReadWriteCloser, handler Handler, signalHandler SignalHandler) (*Conn, error) {
- return NewConn(genericTransport{conn}, WithHandler(handler), WithSignalHandler(signalHandler))
-}
-
-// newConn creates a new *Conn from a transport.
-func newConn(tr transport, opts ...ConnOption) (*Conn, error) {
- conn := new(Conn)
- conn.transport = tr
- for _, opt := range opts {
- if err := opt(conn); err != nil {
- return nil, err
- }
- }
- if conn.ctx == nil {
- conn.ctx = context.Background()
- }
- conn.ctx, conn.cancelCtx = context.WithCancel(conn.ctx)
- go func() {
- <-conn.ctx.Done()
- conn.Close()
- }()
-
- conn.calls = newCallTracker()
- if conn.handler == nil {
- conn.handler = NewDefaultHandler()
- }
- if conn.signalHandler == nil {
- conn.signalHandler = NewDefaultSignalHandler()
- }
- if conn.serialGen == nil {
- conn.serialGen = newSerialGenerator()
- }
- conn.outHandler = &outputHandler{conn: conn}
- conn.names = newNameTracker()
- conn.busObj = conn.Object("org.freedesktop.DBus", "/org/freedesktop/DBus")
- return conn, nil
-}
-
-// BusObject returns the object owned by the bus daemon which handles
-// administrative requests.
-func (conn *Conn) BusObject() BusObject {
- return conn.busObj
-}
-
-// Close closes the connection. Any blocked operations will return with errors
-// and the channels passed to Eavesdrop and Signal are closed. This method must
-// not be called on shared connections.
-func (conn *Conn) Close() error {
- conn.closeOnce.Do(func() {
- conn.outHandler.close()
- if term, ok := conn.signalHandler.(Terminator); ok {
- term.Terminate()
- }
-
- if term, ok := conn.handler.(Terminator); ok {
- term.Terminate()
- }
-
- conn.eavesdroppedLck.Lock()
- if conn.eavesdropped != nil {
- close(conn.eavesdropped)
- }
- conn.eavesdroppedLck.Unlock()
-
- conn.cancelCtx()
-
- conn.closeErr = conn.transport.Close()
- })
- return conn.closeErr
-}
-
-// Context returns the context associated with the connection. The
-// context will be cancelled when the connection is closed.
-func (conn *Conn) Context() context.Context {
- return conn.ctx
-}
-
-// Connected returns whether conn is connected
-func (conn *Conn) Connected() bool {
- return conn.ctx.Err() == nil
-}
-
-// Eavesdrop causes conn to send all incoming messages to the given channel
-// without further processing. Method replies, errors and signals will not be
-// sent to the appropriate channels and method calls will not be handled. If nil
-// is passed, the normal behaviour is restored.
-//
-// The caller has to make sure that ch is sufficiently buffered;
-// if a message arrives when a write to ch is not possible, the message is
-// discarded.
-func (conn *Conn) Eavesdrop(ch chan<- *Message) {
- conn.eavesdroppedLck.Lock()
- conn.eavesdropped = ch
- conn.eavesdroppedLck.Unlock()
-}
-
-// getSerial returns an unused serial.
-func (conn *Conn) getSerial() uint32 {
- return conn.serialGen.GetSerial()
-}
-
-// Hello sends the initial org.freedesktop.DBus.Hello call. This method must be
-// called after authentication, but before sending any other messages to the
-// bus. Hello must not be called for shared connections.
-func (conn *Conn) Hello() error {
- var s string
- err := conn.busObj.Call("org.freedesktop.DBus.Hello", 0).Store(&s)
- if err != nil {
- return err
- }
- conn.names.acquireUniqueConnectionName(s)
- return nil
-}
-
-// inWorker runs in an own goroutine, reading incoming messages from the
-// transport and dispatching them appropriately.
-func (conn *Conn) inWorker() {
- sequenceGen := newSequenceGenerator()
- for {
- msg, err := conn.ReadMessage()
- if err != nil {
- if _, ok := err.(InvalidMessageError); !ok {
- // Some read error occurred (usually EOF); we can't really do
- // anything but to shut down all stuff and returns errors to all
- // pending replies.
- conn.Close()
- conn.calls.finalizeAllWithError(sequenceGen, err)
- return
- }
- // invalid messages are ignored
- continue
- }
- conn.eavesdroppedLck.Lock()
- if conn.eavesdropped != nil {
- select {
- case conn.eavesdropped <- msg:
- default:
- }
- conn.eavesdroppedLck.Unlock()
- continue
- }
- conn.eavesdroppedLck.Unlock()
- dest, _ := msg.Headers[FieldDestination].value.(string)
- found := dest == "" ||
- !conn.names.uniqueNameIsKnown() ||
- conn.names.isKnownName(dest)
- if !found {
- // Eavesdropped a message, but no channel for it is registered.
- // Ignore it.
- continue
- }
-
- if conn.inInt != nil {
- conn.inInt(msg)
- }
- sequence := sequenceGen.next()
- switch msg.Type {
- case TypeError:
- conn.serialGen.RetireSerial(conn.calls.handleDBusError(sequence, msg))
- case TypeMethodReply:
- conn.serialGen.RetireSerial(conn.calls.handleReply(sequence, msg))
- case TypeSignal:
- conn.handleSignal(sequence, msg)
- case TypeMethodCall:
- go conn.handleCall(msg)
- }
-
- }
-}
-
-func (conn *Conn) handleSignal(sequence Sequence, msg *Message) {
- iface := msg.Headers[FieldInterface].value.(string)
- member := msg.Headers[FieldMember].value.(string)
- // as per http://dbus.freedesktop.org/doc/dbus-specification.html ,
- // sender is optional for signals.
- sender, _ := msg.Headers[FieldSender].value.(string)
- if iface == "org.freedesktop.DBus" && sender == "org.freedesktop.DBus" {
- if member == "NameLost" {
- // If we lost the name on the bus, remove it from our
- // tracking list.
- name, ok := msg.Body[0].(string)
- if !ok {
- panic("Unable to read the lost name")
- }
- conn.names.loseName(name)
- } else if member == "NameAcquired" {
- // If we acquired the name on the bus, add it to our
- // tracking list.
- name, ok := msg.Body[0].(string)
- if !ok {
- panic("Unable to read the acquired name")
- }
- conn.names.acquireName(name)
- }
- }
- signal := &Signal{
- Sender: sender,
- Path: msg.Headers[FieldPath].value.(ObjectPath),
- Name: iface + "." + member,
- Body: msg.Body,
- Sequence: sequence,
- }
- conn.signalHandler.DeliverSignal(iface, member, signal)
-}
-
-// Names returns the list of all names that are currently owned by this
-// connection. The slice is always at least one element long, the first element
-// being the unique name of the connection.
-func (conn *Conn) Names() []string {
- return conn.names.listKnownNames()
-}
-
-// Object returns the object identified by the given destination name and path.
-func (conn *Conn) Object(dest string, path ObjectPath) BusObject {
- return &Object{conn, dest, path}
-}
-
-func (conn *Conn) sendMessageAndIfClosed(msg *Message, ifClosed func()) {
- if msg.serial == 0 {
- msg.serial = conn.getSerial()
- }
- if conn.outInt != nil {
- conn.outInt(msg)
- }
- err := conn.outHandler.sendAndIfClosed(msg, ifClosed)
- conn.calls.handleSendError(msg, err)
- if err != nil {
- conn.serialGen.RetireSerial(msg.serial)
- } else if msg.Type != TypeMethodCall {
- conn.serialGen.RetireSerial(msg.serial)
- }
-}
-
-// Send sends the given message to the message bus. You usually don't need to
-// use this; use the higher-level equivalents (Call / Go, Emit and Export)
-// instead. If msg is a method call and NoReplyExpected is not set, a non-nil
-// call is returned and the same value is sent to ch (which must be buffered)
-// once the call is complete. Otherwise, ch is ignored and a Call structure is
-// returned of which only the Err member is valid.
-func (conn *Conn) Send(msg *Message, ch chan *Call) *Call {
- return conn.send(context.Background(), msg, ch)
-}
-
-// SendWithContext acts like Send but takes a context
-func (conn *Conn) SendWithContext(ctx context.Context, msg *Message, ch chan *Call) *Call {
- return conn.send(ctx, msg, ch)
-}
-
-func (conn *Conn) send(ctx context.Context, msg *Message, ch chan *Call) *Call {
- if ctx == nil {
- panic("nil context")
- }
- if ch == nil {
- ch = make(chan *Call, 1)
- } else if cap(ch) == 0 {
- panic("dbus: unbuffered channel passed to (*Conn).Send")
- }
-
- var call *Call
- ctx, canceler := context.WithCancel(ctx)
- msg.serial = conn.getSerial()
- if msg.Type == TypeMethodCall && msg.Flags&FlagNoReplyExpected == 0 {
- call = new(Call)
- call.Destination, _ = msg.Headers[FieldDestination].value.(string)
- call.Path, _ = msg.Headers[FieldPath].value.(ObjectPath)
- iface, _ := msg.Headers[FieldInterface].value.(string)
- member, _ := msg.Headers[FieldMember].value.(string)
- call.Method = iface + "." + member
- call.Args = msg.Body
- call.Done = ch
- call.ctx = ctx
- call.ctxCanceler = canceler
- conn.calls.track(msg.serial, call)
- go func() {
- <-ctx.Done()
- conn.calls.handleSendError(msg, ctx.Err())
- }()
- conn.sendMessageAndIfClosed(msg, func() {
- conn.calls.handleSendError(msg, ErrClosed)
- canceler()
- })
- } else {
- canceler()
- call = &Call{Err: nil, Done: ch}
- ch <- call
- conn.sendMessageAndIfClosed(msg, func() {
- call = &Call{Err: ErrClosed}
- })
- }
- return call
-}
-
-// sendError creates an error message corresponding to the parameters and sends
-// it to conn.out.
-func (conn *Conn) sendError(err error, dest string, serial uint32) {
- var e *Error
- switch em := err.(type) {
- case Error:
- e = &em
- case *Error:
- e = em
- case DBusError:
- name, body := em.DBusError()
- e = NewError(name, body)
- default:
- e = MakeFailedError(err)
- }
- msg := new(Message)
- msg.Type = TypeError
- msg.Headers = make(map[HeaderField]Variant)
- if dest != "" {
- msg.Headers[FieldDestination] = MakeVariant(dest)
- }
- msg.Headers[FieldErrorName] = MakeVariant(e.Name)
- msg.Headers[FieldReplySerial] = MakeVariant(serial)
- msg.Body = e.Body
- if len(e.Body) > 0 {
- msg.Headers[FieldSignature] = MakeVariant(SignatureOf(e.Body...))
- }
- conn.sendMessageAndIfClosed(msg, nil)
-}
-
-// sendReply creates a method reply message corresponding to the parameters and
-// sends it to conn.out.
-func (conn *Conn) sendReply(dest string, serial uint32, values ...interface{}) {
- msg := new(Message)
- msg.Type = TypeMethodReply
- msg.Headers = make(map[HeaderField]Variant)
- if dest != "" {
- msg.Headers[FieldDestination] = MakeVariant(dest)
- }
- msg.Headers[FieldReplySerial] = MakeVariant(serial)
- msg.Body = values
- if len(values) > 0 {
- msg.Headers[FieldSignature] = MakeVariant(SignatureOf(values...))
- }
- conn.sendMessageAndIfClosed(msg, nil)
-}
-
-// AddMatchSignal registers the given match rule to receive broadcast
-// signals based on their contents.
-func (conn *Conn) AddMatchSignal(options ...MatchOption) error {
- return conn.AddMatchSignalContext(context.Background(), options...)
-}
-
-// AddMatchSignalContext acts like AddMatchSignal but takes a context.
-func (conn *Conn) AddMatchSignalContext(ctx context.Context, options ...MatchOption) error {
- options = append([]MatchOption{withMatchType("signal")}, options...)
- return conn.busObj.CallWithContext(
- ctx,
- "org.freedesktop.DBus.AddMatch", 0,
- formatMatchOptions(options),
- ).Store()
-}
-
-// RemoveMatchSignal removes the first rule that matches previously registered with AddMatchSignal.
-func (conn *Conn) RemoveMatchSignal(options ...MatchOption) error {
- return conn.RemoveMatchSignalContext(context.Background(), options...)
-}
-
-// RemoveMatchSignalContext acts like RemoveMatchSignal but takes a context.
-func (conn *Conn) RemoveMatchSignalContext(ctx context.Context, options ...MatchOption) error {
- options = append([]MatchOption{withMatchType("signal")}, options...)
- return conn.busObj.CallWithContext(
- ctx,
- "org.freedesktop.DBus.RemoveMatch", 0,
- formatMatchOptions(options),
- ).Store()
-}
-
-// Signal registers the given channel to be passed all received signal messages.
-//
-// Multiple of these channels can be registered at the same time.
-//
-// These channels are "overwritten" by Eavesdrop; i.e., if there currently is a
-// channel for eavesdropped messages, this channel receives all signals, and
-// none of the channels passed to Signal will receive any signals.
-//
-// Panics if the signal handler is not a `SignalRegistrar`.
-func (conn *Conn) Signal(ch chan<- *Signal) {
- handler, ok := conn.signalHandler.(SignalRegistrar)
- if !ok {
- panic("cannot use this method with a non SignalRegistrar handler")
- }
- handler.AddSignal(ch)
-}
-
-// RemoveSignal removes the given channel from the list of the registered channels.
-//
-// Panics if the signal handler is not a `SignalRegistrar`.
-func (conn *Conn) RemoveSignal(ch chan<- *Signal) {
- handler, ok := conn.signalHandler.(SignalRegistrar)
- if !ok {
- panic("cannot use this method with a non SignalRegistrar handler")
- }
- handler.RemoveSignal(ch)
-}
-
-// SupportsUnixFDs returns whether the underlying transport supports passing of
-// unix file descriptors. If this is false, method calls containing unix file
-// descriptors will return an error and emitted signals containing them will
-// not be sent.
-func (conn *Conn) SupportsUnixFDs() bool {
- return conn.unixFD
-}
-
-// Error represents a D-Bus message of type Error.
-type Error struct {
- Name string
- Body []interface{}
-}
-
-func NewError(name string, body []interface{}) *Error {
- return &Error{name, body}
-}
-
-func (e Error) Error() string {
- if len(e.Body) >= 1 {
- s, ok := e.Body[0].(string)
- if ok {
- return s
- }
- }
- return e.Name
-}
-
-// Signal represents a D-Bus message of type Signal. The name member is given in
-// "interface.member" notation, e.g. org.freedesktop.D-Bus.NameLost.
-type Signal struct {
- Sender string
- Path ObjectPath
- Name string
- Body []interface{}
- Sequence Sequence
-}
-
-// transport is a D-Bus transport.
-type transport interface {
- // Read and Write raw data (for example, for the authentication protocol).
- io.ReadWriteCloser
-
- // Send the initial null byte used for the EXTERNAL mechanism.
- SendNullByte() error
-
- // Returns whether this transport supports passing Unix FDs.
- SupportsUnixFDs() bool
-
- // Signal the transport that Unix FD passing is enabled for this connection.
- EnableUnixFDs()
-
- // Read / send a message, handling things like Unix FDs.
- ReadMessage() (*Message, error)
- SendMessage(*Message) error
-}
-
-var (
- transports = make(map[string]func(string) (transport, error))
-)
-
-func getTransport(address string) (transport, error) {
- var err error
- var t transport
-
- addresses := strings.Split(address, ";")
- for _, v := range addresses {
- i := strings.IndexRune(v, ':')
- if i == -1 {
- err = errors.New("dbus: invalid bus address (no transport)")
- continue
- }
- f := transports[v[:i]]
- if f == nil {
- err = errors.New("dbus: invalid bus address (invalid or unsupported transport)")
- continue
- }
- t, err = f(v[i+1:])
- if err == nil {
- return t, nil
- }
- }
- return nil, err
-}
-
-// getKey gets a key from a the list of keys. Returns "" on error / not found...
-func getKey(s, key string) string {
- for _, keyEqualsValue := range strings.Split(s, ",") {
- keyValue := strings.SplitN(keyEqualsValue, "=", 2)
- if len(keyValue) == 2 && keyValue[0] == key {
- return keyValue[1]
- }
- }
- return ""
-}
-
-type outputHandler struct {
- conn *Conn
- sendLck sync.Mutex
- closed struct {
- isClosed bool
- lck sync.RWMutex
- }
-}
-
-func (h *outputHandler) sendAndIfClosed(msg *Message, ifClosed func()) error {
- h.closed.lck.RLock()
- defer h.closed.lck.RUnlock()
- if h.closed.isClosed {
- if ifClosed != nil {
- ifClosed()
- }
- return nil
- }
- h.sendLck.Lock()
- defer h.sendLck.Unlock()
- return h.conn.SendMessage(msg)
-}
-
-func (h *outputHandler) close() {
- h.closed.lck.Lock()
- defer h.closed.lck.Unlock()
- h.closed.isClosed = true
-}
-
-type serialGenerator struct {
- lck sync.Mutex
- nextSerial uint32
- serialUsed map[uint32]bool
-}
-
-func newSerialGenerator() *serialGenerator {
- return &serialGenerator{
- serialUsed: map[uint32]bool{0: true},
- nextSerial: 1,
- }
-}
-
-func (gen *serialGenerator) GetSerial() uint32 {
- gen.lck.Lock()
- defer gen.lck.Unlock()
- n := gen.nextSerial
- for gen.serialUsed[n] {
- n++
- }
- gen.serialUsed[n] = true
- gen.nextSerial = n + 1
- return n
-}
-
-func (gen *serialGenerator) RetireSerial(serial uint32) {
- gen.lck.Lock()
- defer gen.lck.Unlock()
- delete(gen.serialUsed, serial)
-}
-
-type nameTracker struct {
- lck sync.RWMutex
- unique string
- names map[string]struct{}
-}
-
-func newNameTracker() *nameTracker {
- return &nameTracker{names: map[string]struct{}{}}
-}
-func (tracker *nameTracker) acquireUniqueConnectionName(name string) {
- tracker.lck.Lock()
- defer tracker.lck.Unlock()
- tracker.unique = name
-}
-func (tracker *nameTracker) acquireName(name string) {
- tracker.lck.Lock()
- defer tracker.lck.Unlock()
- tracker.names[name] = struct{}{}
-}
-func (tracker *nameTracker) loseName(name string) {
- tracker.lck.Lock()
- defer tracker.lck.Unlock()
- delete(tracker.names, name)
-}
-
-func (tracker *nameTracker) uniqueNameIsKnown() bool {
- tracker.lck.RLock()
- defer tracker.lck.RUnlock()
- return tracker.unique != ""
-}
-func (tracker *nameTracker) isKnownName(name string) bool {
- tracker.lck.RLock()
- defer tracker.lck.RUnlock()
- _, ok := tracker.names[name]
- return ok || name == tracker.unique
-}
-func (tracker *nameTracker) listKnownNames() []string {
- tracker.lck.RLock()
- defer tracker.lck.RUnlock()
- out := make([]string, 0, len(tracker.names)+1)
- out = append(out, tracker.unique)
- for k := range tracker.names {
- out = append(out, k)
- }
- return out
-}
-
-type callTracker struct {
- calls map[uint32]*Call
- lck sync.RWMutex
-}
-
-func newCallTracker() *callTracker {
- return &callTracker{calls: map[uint32]*Call{}}
-}
-
-func (tracker *callTracker) track(sn uint32, call *Call) {
- tracker.lck.Lock()
- tracker.calls[sn] = call
- tracker.lck.Unlock()
-}
-
-func (tracker *callTracker) handleReply(sequence Sequence, msg *Message) uint32 {
- serial := msg.Headers[FieldReplySerial].value.(uint32)
- tracker.lck.RLock()
- _, ok := tracker.calls[serial]
- tracker.lck.RUnlock()
- if ok {
- tracker.finalizeWithBody(serial, sequence, msg.Body)
- }
- return serial
-}
-
-func (tracker *callTracker) handleDBusError(sequence Sequence, msg *Message) uint32 {
- serial := msg.Headers[FieldReplySerial].value.(uint32)
- tracker.lck.RLock()
- _, ok := tracker.calls[serial]
- tracker.lck.RUnlock()
- if ok {
- name, _ := msg.Headers[FieldErrorName].value.(string)
- tracker.finalizeWithError(serial, sequence, Error{name, msg.Body})
- }
- return serial
-}
-
-func (tracker *callTracker) handleSendError(msg *Message, err error) {
- if err == nil {
- return
- }
- tracker.lck.RLock()
- _, ok := tracker.calls[msg.serial]
- tracker.lck.RUnlock()
- if ok {
- tracker.finalizeWithError(msg.serial, NoSequence, err)
- }
-}
-
-// finalize was the only func that did not strobe Done
-func (tracker *callTracker) finalize(sn uint32) {
- tracker.lck.Lock()
- defer tracker.lck.Unlock()
- c, ok := tracker.calls[sn]
- if ok {
- delete(tracker.calls, sn)
- c.ContextCancel()
- }
-}
-
-func (tracker *callTracker) finalizeWithBody(sn uint32, sequence Sequence, body []interface{}) {
- tracker.lck.Lock()
- c, ok := tracker.calls[sn]
- if ok {
- delete(tracker.calls, sn)
- }
- tracker.lck.Unlock()
- if ok {
- c.Body = body
- c.ResponseSequence = sequence
- c.done()
- }
-}
-
-func (tracker *callTracker) finalizeWithError(sn uint32, sequence Sequence, err error) {
- tracker.lck.Lock()
- c, ok := tracker.calls[sn]
- if ok {
- delete(tracker.calls, sn)
- }
- tracker.lck.Unlock()
- if ok {
- c.Err = err
- c.ResponseSequence = sequence
- c.done()
- }
-}
-
-func (tracker *callTracker) finalizeAllWithError(sequenceGen *sequenceGenerator, err error) {
- tracker.lck.Lock()
- closedCalls := make([]*Call, 0, len(tracker.calls))
- for sn := range tracker.calls {
- closedCalls = append(closedCalls, tracker.calls[sn])
- }
- tracker.calls = map[uint32]*Call{}
- tracker.lck.Unlock()
- for _, call := range closedCalls {
- call.Err = err
- call.ResponseSequence = sequenceGen.next()
- call.done()
- }
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 01:55:23 +0000