Ejemplo n.º 1
0
// Attaches to the running Skype instance.
// Client must already be logged-in.
// More than one Skype client is unsupported.
func Attach() (*Connection, error) {
	conn, err := dbus.SessionBus()
	if err != nil {
		return nil, err
	}

	c := &Connection{}
	c.Events = make(chan Event, 10)
	c.conn = conn
	c.obj = conn.Object("com.Skype.API", "/com/Skype")

	l := Listener{conn: c}
	if err := conn.Export(l, "/com/Skype/Client", "com.Skype.API.Client"); err != nil {
		return nil, err
	}

	if err := c.SetName("skype4go"); err != nil {
		return nil, err
	}

	if err := c.SetProtocol(7); err != nil {
		return nil, err
	}

	return c, nil
}
Ejemplo n.º 2
0
// Show sends the information in the notification object to the server to be
// displayed.
func (n Notification) Show() (id uint32, err error) {
	conn, err := dbus.SessionBus()
	if err != nil {
		return
	}

	// We need to convert the interface type of the map to dbus.Variant as
	// people dont want to have to import the dbus package just to make use
	// of the notification hints.
	hints := map[string]dbus.Variant{}
	for k, v := range n.Hints {
		hints[k] = dbus.MakeVariant(v)
	}

	obj := conn.Object(interfacePath, objectPath)
	call := obj.Call(
		notify,
		0,
		n.AppName,
		n.ReplacesID,
		n.AppIcon,
		n.Summary,
		n.Body,
		n.Actions,
		hints,
		n.Timeout)
	if err = call.Err; err != nil {
		return
	}

	err = call.Store(&id)
	return
}
Ejemplo n.º 3
0
// GetClient return a connection to the active instance of the internal Dbus
// service if any. Return nil, nil if none found.
// InterfacePath is an optional string to provide if the object use an interface
// path different from SrvObj
//
func GetClient(SrvObj, SrvPath string, InterfacePath ...string) (*Client, error) {
	conn, ec := dbus.SessionBus()
	if ec != nil {
		return nil, ec
	}

	reply, e := conn.RequestName(SrvObj, dbus.NameFlagDoNotQueue)
	if e != nil {
		return nil, e
	}
	conn.ReleaseName(SrvObj)

	if reply == dbus.RequestNameReplyPrimaryOwner { // no active instance.
		return nil, errors.New("no service found")
	}

	if len(InterfacePath) == 0 { // Set default interface path = object name.
		InterfacePath = []string{SrvObj}
	}

	// Found active instance, return client.
	return &Client{
		BusObject: conn.Object(SrvObj, dbus.ObjectPath(SrvPath)),
		srvObj:    InterfacePath[0],
		testErr:   func(e error, method string) {},
	}, nil
}
Ejemplo n.º 4
0
// getAddgetAddressBookContactsFromDBus gets the phone contacts via the address-book DBus service
func getAddressBookContactsFromDBus() ([]textsecure.Contact, error) {
	var o dbus.ObjectPath
	var vcardContacts []string

	conn, err := dbus.SessionBus()
	if err != nil {
		return nil, err
	}

	obj := conn.Object("com.canonical.pim", "/com/canonical/pim/AddressBook")
	err = obj.Call("com.canonical.pim.AddressBook.query", 0, "", "", []string{}).Store(&o)
	if err != nil {
		return nil, err
	}
	obj2 := conn.Object("com.canonical.pim", o)
	err = obj2.Call("com.canonical.pim.AddressBookView.contactsDetails", 0, []string{}, int32(0), int32(-1)).Store(&vcardContacts)
	if err != nil {
		return nil, err
	}
	obj.Call("com.canonical.pim.AddressBook.close", 0)
	if err != nil {
		return nil, err
	}

	return parseVCards(vcardContacts)
}
Ejemplo n.º 5
0
func main() {
	log.SetFlags(log.LstdFlags | log.Lshortfile)
	flag.Parse()
	conn, err := dbus.SessionBus()
	if err != nil {
		log.Fatal(err)
	}
	o := conn.Object("org.gnome.SessionManager", "/org/gnome/SessionManager")
	inhibit(o, "inhibitor", "inhibiting", inhibitIdle)
	inhibit(o, "inhibitor", "inhibiting", inhibitSuspend)
	if *pid == 0 {
		fmt.Fprint(os.Stderr, "Inhibiting until this process is killed\n")
		select {}
	}
	fmt.Fprintf(os.Stderr, "Inhibiting until this process or PID %d is killed\n", *pid)
	for {
		_, err := os.Stat(fmt.Sprintf("/proc/%d", *pid))
		if os.IsNotExist(err) {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		time.Sleep(*d)
	}
}
Ejemplo n.º 6
0
func NewdbusWrapper(path string, iface string) (*dbusWrapper, error) {
	d := new(dbusWrapper)

	conn, err := dbus.SystemBus()
	if err != nil {
		conn, err = dbus.SessionBus()
		if err != nil {
			log.Panic(err)
		}
	}

	d.handlers = make(map[string]signalHandler)

	d.conn = conn
	d.path = path
	d.iface = iface
	d.queue = &signalQueue{cond: &sync.Cond{L: &sync.Mutex{}}}
	heap.Init(d.queue)

	filter := fmt.Sprintf("type='signal',path='%[1]s',interface='%[2]s',sender='%[2]s'", path, iface)
	log.Printf("Filter: %s", filter)

	conn.Object("org.freedesktop.DBus", "/org/freedesktop/DBus").Call("org.freedesktop.DBus.AddMatch", 0, filter)

	go func() {
		ch := make(chan *dbus.Signal, 2*QueueCapacity)
		conn.Signal(ch)
		for signal := range ch {
			if !((strings.Index(signal.Name, iface) == 0) && (string(signal.Path) == path)) {
				continue
			}
			if val, ok := d.handlers[signal.Name]; ok {
				for d.queue.Len() > QueueCapacity-1 {
					item := heap.Remove(d.queue, d.queue.Len()-1)
					log.Printf("Removing %+v from queue", item)
				}
				heap.Push(d.queue, signalItem{handler: val, signal: signal, timestamp: uint64(time.Now().Unix())})
			} else {
				log.Printf("Unhandled signal: %s", signal.Name)
			}
		}
	}()

	go func() {
		for {
			d.queue.cond.L.Lock()
			for d.queue.Len() == 0 {
				d.queue.cond.Wait()
			}
			d.queue.cond.L.Unlock()
			item := heap.Pop(d.queue).(signalItem)
			item.handler.handler(item.signal.Body...)
		}
	}()

	return d, nil
}
Ejemplo n.º 7
0
// SessionBus creates a Dbus session with a listening chan.
//
func SessionBus() (*dbus.Conn, chan *dbus.Signal, error) {
	conn, e := dbus.SessionBus()
	if e != nil {
		return nil, nil, e
	}

	c := make(chan *dbus.Signal, 10)
	conn.Signal(c)
	return conn, c, nil
}
Ejemplo n.º 8
0
func newDesktopNotifications() *desktopNotifications {
	if _, err := dbus.SessionBus(); err != nil {
		log.Printf("Error enabling dbus based notifications! %+v\n", err)
		return createDesktopNotifications()
	}

	dn := createDesktopNotifications()
	dn.supported = true
	dn.notifications = make(map[string]uint32)
	return dn
}
Ejemplo n.º 9
0
// SessionBus is part of Interface
func (db *dbusImpl) SessionBus() (Connection, error) {
	if db.sessionBus == nil {
		bus, err := godbus.SessionBus()
		if err != nil {
			return nil, err
		}
		db.sessionBus = &connImpl{bus}
	}

	return db.sessionBus, nil
}
Ejemplo n.º 10
0
// CloseNotification closes the notification if it exists using its id.
func CloseNotification(id uint32) (err error) {
	conn, err := dbus.SessionBus()
	if err != nil {
		return
	}

	obj := conn.Object(interfacePath, objectPath)
	call := obj.Call(closeNotification, 0, id)
	err = call.Err
	return
}
Ejemplo n.º 11
0
func NewService() (*Service, error) {
	conn, err := dbus.SessionBus()
	if err != nil {
		return &Service{}, err
	}

	return &Service{
		conn: conn,
		dbus: conn.Object(DBusServiceName, DBusPath),
	}, nil
}
Ejemplo n.º 12
0
func connDbus() *dbus.Object {

	conn, err := dbus.SessionBus()

	// couldnt connect to session bus
	if err != nil {
		panic(err)
	}

	return conn.Object("org.mpris.MediaPlayer2.spotify", "/org/mpris/MediaPlayer2")
}
Ejemplo n.º 13
0
func main() {
	conn, err := dbus.SessionBus()
	if err != nil {
		panic(err)
	}
	node, err := introspect.Call(conn.Object("org.freedesktop.DBus", "/org/freedesktop/DBus"))
	if err != nil {
		panic(err)
	}
	data, _ := json.MarshalIndent(node, "", "    ")
	os.Stdout.Write(data)
}
Ejemplo n.º 14
0
func ConnectToDBus(bus string) (*DBusClient, error) {
	c := new(DBusClient)

	var err error
	switch bus {
	case "session":
		c.bus, err = dbus.SessionBus()

	case "system":
		c.bus, err = dbus.SystemBus()

	default:
		c.bus, err = dbus.Dial(bus)
	}

	if err != nil {
		return nil, err
	}
	if !c.bus.SupportsUnixFDs() {
		return nil, errors.New("DBus connection does not support file descriptors")
	}

	c.path = dbus.ObjectPath("/com/firelizzard/teasvc/Client")
	err = c.bus.Export(c, c.path, "com.firelizzard.teasvc.Client")
	if err != nil {
		return nil, err
	}

	c.sigchans = make(map[string](chan *dbus.Signal))
	chsig := make(chan *dbus.Signal, 10)

	go func() {
		for {
			sig := <-chsig
			ch, ok := c.sigchans[sig.Name]
			if !ok {
				log.Print("Unhandled signal: " + sig.Name)
			}

			select {
			case ch <- sig:
				// sent singal, done

			default:
				log.Print("Unhandled signal (full channel): " + sig.Name)
			}
		}
	}()
	c.bus.Signal(chsig)
	c.bus.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, "type='signal',interface='com.firelizzard.teasvc',member='Pong'")

	return c, nil
}
Ejemplo n.º 15
0
// GetCapabilities returns the capabilities of the notification server.
func GetCapabilities() (c Capabilities, err error) {
	conn, err := dbus.SessionBus()
	if err != nil {
		return
	}

	obj := conn.Object(interfacePath, objectPath)
	call := obj.Call(getCapabilities, 0)
	if err = call.Err; err != nil {
		return
	}

	s := []string{}
	if err = call.Store(&s); err != nil {
		return
	}

	for _, v := range s {
		switch v {
		case "action-icons":
			c.ActionIcons = true
			break
		case "actions":
			c.Actions = true
			break
		case "body":
			c.Body = true
			break
		case "body-hyperlinks":
			c.BodyHyperlinks = true
			break
		case "body-images":
			c.BodyImages = true
			break
		case "body-markup":
			c.BodyMarkup = true
			break
		case "icon-multi":
			c.IconMulti = true
			break
		case "icon-static":
			c.IconStatic = true
			break
		case "persistence":
			c.Persistence = true
			break
		case "sound":
			c.Sound = true
			break
		}
	}
	return
}
Ejemplo n.º 16
0
// GetCapabilities returns the capabilities of the notification server.
func GetCapabilities() (c Capabilities, err error) {
	connection, err := dbus.SessionBus()
	if err != nil {
		return
	}
	obj := connection.Object("org.freedesktop.Notifications", "/org/freedesktop/Notifications")

	call := obj.Call("org.freedesktop.Notifications.GetCapabilities", 0)
	if call.Err != nil {
		return Capabilities{}, call.Err
	}

	s := []string{}
	if err = call.Store(&s); err != nil {
		return
	}
	for _, v := range s {
		switch v {
		case "action-icons":
			c.ActionIcons = true
			break
		case "actions":
			c.Actions = true
			break
		case "body":
			c.Body = true
			break
		case "body-hyperlinks":
			c.BodyHyperlinks = true
			break
		case "body-images":
			c.BodyImages = true
			break
		case "body-markup":
			c.BodyMarkup = true
			break
		case "icon-multi":
			c.IconMulti = true
			break
		case "icon-static":
			c.IconStatic = true
			break
		case "persistence":
			c.Persistence = true
			break
		case "sound":
			c.Sound = true
			break
		}
	}
	return
}
Ejemplo n.º 17
0
// EavesDrop registers to receive Dbus events for custom parsing.
//
func EavesDrop(match string) (chan *dbus.Message, error) {
	conn, e := dbus.SessionBus()
	if e != nil {
		return nil, e
	}
	e = conn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, match).Err
	if e != nil {
		return nil, e
	}
	c := make(chan *dbus.Message, 10)
	conn.Eavesdrop(c)
	return c, nil
}
Ejemplo n.º 18
0
// CloseNotification closes the notification if it exists using its id.
func CloseNotification(id uint32) (err error) {
	connection, err := dbus.SessionBus()
	if err != nil {
		return
	}
	obj := connection.Object("org.freedesktop.Notifications", "/org/freedesktop/Notifications")

	call := obj.Call("org.freedesktop.Notifications.CloseNotification", 0, id)
	if call.Err != nil {
		return call.Err
	}
	return
}
Ejemplo n.º 19
0
func main() {
	conn, err := dbus.SessionBus()
	if err != nil {
		panic(err)
	}
	obj := conn.Object("org.freedesktop.Notifications", "/org/freedesktop/Notifications")
	call := obj.Call("org.freedesktop.Notifications.Notify", 0, "", uint32(0),
		"", "Test", "This is a test of the DBus bindings for go.", []string{},
		map[string]dbus.Variant{}, int32(5000))
	if call.Err != nil {
		panic(call.Err)
	}
}
Ejemplo n.º 20
0
Archivo: prop.go Proyecto: 98pm/docker
func main() {
	conn, err := dbus.SessionBus()
	if err != nil {
		panic(err)
	}
	reply, err := conn.RequestName("com.github.guelfey.Demo",
		dbus.NameFlagDoNotQueue)
	if err != nil {
		panic(err)
	}
	if reply != dbus.RequestNameReplyPrimaryOwner {
		fmt.Fprintln(os.Stderr, "name already taken")
		os.Exit(1)
	}
	propsSpec := map[string]map[string]*prop.Prop{
		"com.github.guelfey.Demo": {
			"SomeInt": {
				int32(0),
				true,
				prop.EmitTrue,
				func(c *prop.Change) *dbus.Error {
					fmt.Println(c.Name, "changed to", c.Value)
					return nil
				},
			},
		},
	}
	f := foo("Bar")
	conn.Export(f, "/com/github/guelfey/Demo", "com.github.guelfey.Demo")
	props := prop.New(conn, "/com/github/guelfey/Demo", propsSpec)
	n := &introspect.Node{
		Name: "/com/github/guelfey/Demo",
		Interfaces: []introspect.Interface{
			introspect.IntrospectData,
			prop.IntrospectData,
			{
				Name:       "com.github.guelfey.Demo",
				Methods:    introspect.Methods(f),
				Properties: props.Introspection("com.github.guelfey.Demo"),
			},
		},
	}
	conn.Export(introspect.NewIntrospectable(n), "/com/github/guelfey/Demo",
		"org.freedesktop.DBus.Introspectable")
	fmt.Println("Listening on com.github.guelfey.Demo / /com/github/guelfey/Demo ...")

	c := make(chan *dbus.Signal)
	conn.Signal(c)
	for _ = range c {
	}
}
Ejemplo n.º 21
0
// GetServerInformation returns information about the notification server such
// as its name and version.
func GetServerInformation() (i ServerInformation, err error) {
	conn, err := dbus.SessionBus()
	if err != nil {
		return
	}

	obj := conn.Object(interfacePath, objectPath)
	call := obj.Call(gsInformation, 0)
	if err = call.Err; err != nil {
		return
	}

	err = call.Store(&i.Name, &i.Vendor, &i.Version, &i.SpecVersion)
	return
}
Ejemplo n.º 22
0
func main() {
	iconName := "mail-unread"

	conn, err := dbus.SessionBus()
	if err != nil {
		panic(err)
	}

	notificator := notify.New(conn)

	n := notify.Notification{
		AppName:       "Test GO App",
		ReplacesID:    uint32(0),
		AppIcon:       iconName,
		Summary:       "Test",
		Body:          "This is a test of the DBus bindings for go.",
		Actions:       []string{},
		Hints:         map[string]dbus.Variant{},
		ExpireTimeout: int32(5000),
	}

	id, err := notificator.SendNotification(n)
	if err != nil {
		panic(err)
	}
	log.Printf("sent notification id: %v", id)

	caps, err := notificator.GetCapabilities()
	if err != nil {
		log.Printf("error fetching capabilities: %v", err)
	}
	for x := range caps {
		fmt.Printf("Registered capability: %v\n", caps[x])
	}

	info, err := notificator.GetServerInformation()
	if err != nil {
		log.Printf("error getting server information: %v", err)
	}
	fmt.Printf("Name:    %v\n", info.Name)
	fmt.Printf("Vendor:  %v\n", info.Vendor)
	fmt.Printf("Version: %v\n", info.Version)
	fmt.Printf("Spec:    %v\n", info.SpecVersion)

	// And there is a helper for just sending notifications directly:
	notify.SendNotification(conn, n)

}
Ejemplo n.º 23
0
func NewDbus(path, iface string) (*Dbus, error) {
	w := new(Dbus)

	conn, err := dbus.SystemBus()
	if err != nil {
		conn, err = dbus.SessionBus()
		if err != nil {
			return nil, err
		}
	}

	w.path = path
	w.iface = iface
	w.conn = conn
	return w, nil
}
Ejemplo n.º 24
0
func (s *Service) Enable() (err error) {
	s.System, err = dbus.SystemBus()
	if err != nil {
		return err
	}

	s.Session, err = dbus.SessionBus()
	if err != nil {
		return err
	}

	s.Subscribe("notify", "", s.handleNotify)
	s.Subscribe("poweroff", "", s.handlePowerOff)

	return s.setupSignals()
}
Ejemplo n.º 25
0
func main() {
	conn, err := dbus.SessionBus()
	if err != nil {
		fmt.Fprintln(os.Stderr, "Failed to connect to session bus:", err)
		os.Exit(1)
	}

	conn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0,
		"type='signal',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',sender='org.freedesktop.DBus'")

	c := make(chan *dbus.Signal, 10)
	conn.Signal(c)
	for v := range c {
		fmt.Println(v)
	}
}
Ejemplo n.º 26
0
func main() {
	say.SetLevelWithConfName("info")

	configFile, config, err := conf.FromArgs()
	switch {
	case err != nil:
		say.Fatalf("Cannot read configuration in `%s` with error: %s", configFile, err.Error())
	case configFile == "":
		say.Infof("You should specify configuration file. Starting with test configuration: %+v", config)
	default:
		say.Infof("Starting DeviceHive gateway with configuration in '%s': %+v", configFile, config)
	}

	say.SetLevelWithConfName(config.LoggingLevel)

	bus, err := dbus.SystemBus()
	if err != nil {
		say.Infof("Cannot get system bus with error: %s", err.Error())
		say.Infof("Trying to use session bus for testing purposes...")
		if bus, err = dbus.SessionBus(); err != nil {
			say.Fatalf("Cannot get session bus with error: %s\n", err.Error())
			return
		}
	}

	reply, err := bus.RequestName(DBusConnName, dbus.NameFlagDoNotQueue)
	switch {
	case err != nil:
		say.Fatalf("Cannot request name '%s' with error: %s\n", DBusConnName, err.Error())
	case reply != dbus.RequestNameReplyPrimaryOwner:
		say.Fatalf("The name '%s' already taken.", DBusConnName)
	}

	if config.DeviceNotificationReceive == conf.DeviceNotificationReceiveByWS {
		say.Infof("Starting as websocket...")
		wsImplementation(bus, config)
		return
	}

	if config.DeviceNotificationReceive == conf.DeviceNotificationReceiveByREST {
		say.Infof("Starting as rest...")
		restImplementation(bus, config)
		return
	}

}
Ejemplo n.º 27
0
// GetServerInformation returns information about the notification server such as its name
// and version.
func GetServerInformation() (i ServerInformation, err error) {
	connection, err := dbus.SessionBus()
	if err != nil {
		return
	}
	obj := connection.Object("org.freedesktop.Notifications", "/org/freedesktop/Notifications")

	call := obj.Call("org.freedesktop.Notifications.GetServerInformation", 0)
	if call.Err != nil {
		return ServerInformation{}, call.Err
	}

	if err = call.Store(&i.Name, &i.Vendor, &i.Version, &i.SpecVersion); err != nil {
		return
	}
	return
}
Ejemplo n.º 28
0
func main() {
	var err error
	SystemBus, err = dbus.SystemBus()
	if err != nil {
		log.Errorln("connect to system bus:", err)
	} else {
		go monitor(SystemBus, "system")
	}
	SessionBus, err = dbus.SessionBus()
	if err != nil {
		log.Errorln("connect to session bus:", err)
	} else {
		go monitor(SessionBus, "session")
	}

	log.Fatalln(ListenAndServe(":3000"))
}
Ejemplo n.º 29
0
func main() {
	conf := WMATADbus{}
	if err := config.Load("wmatadbusd", &conf); err != nil {
		panic(err)
	}
	wmata.SetAPIKey(conf.APIKey)

	conn, err := dbus.SessionBus()
	if err != nil {
		panic(err)
	}
	reply, err := conn.RequestName("org.anized.wmata.Rail",
		dbus.NameFlagDoNotQueue)
	if err != nil {
		panic(err)
	}
	if reply != dbus.RequestNameReplyPrimaryOwner {
		fmt.Fprintln(os.Stderr, "name already taken")
		os.Exit(1)
	}

	wmata := WMATADbusInterface{}
	introspectedMethods := introspect.Methods(wmata)

	node := introspect.Node{
		Name: "/org/anized/wmata",
		Interfaces: []introspect.Interface{
			introspect.Interface{
				Name:    "org.anized.wmata.Rail",
				Methods: introspectedMethods,
			},
		},
	}

	export := introspect.NewIntrospectable(&node)
	// str, err := export.Introspect()
	// fmt.Printf("%s %s\n", str, err)
	conn.Export(wmata, "/org/anized/wmata/Rail", "org.anized.wmata.Rail")
	conn.Export(
		export,
		"/org/anized/wmata/Rail",
		"org.freedesktop.DBus.Introspectable",
	)
	select {}
}
Ejemplo n.º 30
0
func main() {
	conn, err := dbus.SessionBus()
	if err != nil {
		fmt.Fprintln(os.Stderr, "Failed to connect to session bus:", err)
		os.Exit(1)
	}

	var s []string
	err = conn.BusObject().Call("org.freedesktop.DBus.ListNames", 0).Store(&s)
	if err != nil {
		fmt.Fprintln(os.Stderr, "Failed to get list of owned names:", err)
		os.Exit(1)
	}

	fmt.Println("Currently owned names on the session bus:")
	for _, v := range s {
		fmt.Println(v)
	}
}