connection.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later OR BSD-3-Clause
/***************************************************************************
 *   Copyright (C) 2009,2010 by Rick L. Vinyard, Jr.                       *
 *   rvinyard@cs.nmsu.edu                                                  *
 *   Copyright (C) 2019 by Robert Middleton                                *
 *   robert.middleton@rm5248.com                                           *
 *                                                                         *
 *   This file is part of the dbus-cxx library.                            *
 ***************************************************************************/
#include <stdint.h>
#include <dbus-cxx/signal.h>
#include <dbus-cxx/signalproxy.h>
#include <dbus-cxx/threaddispatcher.h>
#include <dbus-cxx/errormessage.h>
#include <dbus-cxx/dbus-cxx-config.h>
#include <deque>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "enums.h"
#include <sigc++/sigc++.h>
#include <future>
#include <queue>
 
#ifndef DBUSCXX_CONNECTION_H
#define DBUSCXX_CONNECTION_H
 
#define DBUSCXX_NAME_FLAG_ALLOW_REPLACEMENT 0x01
#define DBUSCXX_NAME_FLAG_REPLACE_EXISTING 0x02
#define DBUSCXX_NAME_FLAG_DO_NOT_QUEUE 0x04
 
#define DBUSCXX_INTERFACE_INTROSPECTABLE "org.freedesktop.DBus.Introspectable"
#define DBUSCXX_INTROSPECT_1_0_XML_NAMESPACE         "http://www.freedesktop.org/standards/dbus"
#define DBUSCXX_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
#define DBUSCXX_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd"
#define DBUSCXX_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE "<!DOCTYPE node PUBLIC \""\
    DBUSCXX_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER "\"\n\"" DBUSCXX_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER "\">\n"
 
 
namespace DBus {
class Message;
class Object;
class ObjectPathHandler;
class ObjectProxy;
class PendingCall;
class ReturnMessage;
class SignalMessage;
class Timeout;
class Watch;
class ThreadDispatcher;
class ErrorMessage;
class DBusDaemonProxy;
 
namespace priv {
class Transport;
}
 
class Connection : public std::enable_shared_from_this<Connection> {
 
private:
    Connection( BusType type );
 
    Connection( std::string address );
 
public:
    static std::shared_ptr<Connection> create( BusType type );
 
    static std::shared_ptr<Connection> create( std::string address );
 
    ~Connection();
 
    operator bool() const;
 
    bool is_valid() const;
 
    bool is_registered() const;
 
    bool bus_register();
 
    std::string unique_name() const;
 
    RequestNameResponse request_name( const std::string& name, unsigned int flags = 0 );
 
    ReleaseNameResponse release_name( const std::string& name );
 
    bool name_has_owner( const std::string& name ) const;
 
    StartReply start_service( const std::string& name, uint32_t flags = 0 ) const;
 
    bool add_match( const std::string& rule );
 
    void add_match_nonblocking( const std::string& rule );
 
    bool remove_match( const std::string& rule );
 
    bool is_connected() const;
 
    bool is_authenticated() const;
 
    bool is_anonymous() const;
 
    const char* server_id() const;
 
    uint32_t send( const std::shared_ptr<const Message> message );
 
    Connection& operator<<( std::shared_ptr<const Message> msg );
 
    std::shared_ptr<ReturnMessage> send_with_reply_blocking( std::shared_ptr<const CallMessage> msg, int timeout_milliseconds = -1 );
 
    std::shared_ptr<ReturnMessage> send_with_reply_blocking_notimeout( std::shared_ptr<const CallMessage> msg );
 
    void flush();
 
    DispatchStatus dispatch_status( ) const;
 
    DispatchStatus dispatch( );
 
    int unix_fd() const;
 
    int socket() const;
 
    bool has_messages_to_send();
 
    sigc::signal<void()>& signal_needs_dispatch();
 
    std::shared_ptr<Object> create_object( const std::string& path,
                                           ThreadForCalling calling = ThreadForCalling::DispatcherThread );
 
    RegistrationStatus register_object( std::shared_ptr<Object> object,
        ThreadForCalling calling = ThreadForCalling::DispatcherThread );
 
    bool change_object_calling_thread( std::shared_ptr<Object> object,
                                       ThreadForCalling calling );
 
    bool change_object_proxy_calling_thread( std::shared_ptr<ObjectProxy> object,
                                             ThreadForCalling calling );
 
    std::shared_ptr<ObjectProxy> create_object_proxy( const std::string& path,
                                                      ThreadForCalling calling = ThreadForCalling::DispatcherThread );
 
    std::shared_ptr<ObjectProxy> create_object_proxy( const std::string& destination, const std::string& path,
                                                      ThreadForCalling calling = ThreadForCalling::DispatcherThread);
 
    bool register_object_proxy( std::shared_ptr<ObjectProxy> obj,
                                ThreadForCalling calling = ThreadForCalling::DispatcherThread );
 
 
    bool unregister_object_proxy( ObjectProxy* obj );
 
    bool unregister_object_proxy( std::shared_ptr<ObjectProxy> obj );
 
    bool unregister_object( const std::string& path );
 
    template<typename... T_arg>
    std::shared_ptr<SignalProxy<T_arg...> > create_free_signal_proxy( const SignalMatchRule& rule,
                                                                 ThreadForCalling calling = ThreadForCalling::DispatcherThread ) {
        std::shared_ptr<SignalProxy<T_arg...> > sig;
        sig = SignalProxy<T_arg...>::create( rule );
        this->add_free_signal_proxy( sig, calling );
        return sig;
    }
 
    std::shared_ptr<SignalProxyBase> add_free_signal_proxy( std::shared_ptr<SignalProxyBase> Signal,
                                                       ThreadForCalling calling = ThreadForCalling::DispatcherThread );
 
    bool remove_free_signal_proxy( std::shared_ptr<SignalProxyBase> proxy );
 
    const std::vector<std::shared_ptr<SignalProxyBase>> get_free_signal_proxies();
 
    std::vector<std::shared_ptr<SignalProxyBase>> get_free_signal_proxies( const std::string& interface_name );
 
    std::vector<std::shared_ptr<SignalProxyBase>> get_free_signal_proxies( const std::string& interface_name, const std::string& member );
 
    template <class T_arg>
    std::shared_ptr<Signal<T_arg> > create_free_signal( const std::string& path, const std::string& interface_name, const std::string& member ) {
        std::shared_ptr<Signal<T_arg> > sig;
        sig = Signal<T_arg>::create( path, interface_name, member );
        sig->set_connection( shared_from_this() );
        return sig;
    }
 
    std::string introspect( const std::string& destination, const std::string& path );
 
    void set_dispatching_thread( std::thread::id tid );
 
    void add_thread_dispatcher( std::weak_ptr<ThreadDispatcher> disp );
 
private:
    void notify_dispatcher_or_dispatch();
 
    uint32_t write_single_message( std::shared_ptr<const Message> msg );
 
    void process_single_message();
 
    void remove_invalid_threaddispatchers_and_associated_objects();
 
    std::shared_ptr<ReturnMessage> send_with_reply_blocking_impl( std::shared_ptr<const CallMessage> msg, int timeout_milliseconds, bool disable_timeout );
 
    void send_error_on_handler_result( std::shared_ptr<const CallMessage> msg, HandlerResult result );
 
    void process_call_message( std::shared_ptr<const CallMessage> msg );
    void process_signal_message( std::shared_ptr<const SignalMessage> msg );
 
    std::thread::id thread_id_from_calling( ThreadForCalling calling );
 
private:
    class priv_data;
 
    DBUS_CXX_PROPAGATE_CONST( std::unique_ptr<priv_data> ) m_priv;
};
 
inline
std::shared_ptr<DBus::Connection> operator<<( std::shared_ptr<DBus::Connection> ptr, std::shared_ptr<DBus::Message> msg ) {
    if( !ptr ) { return ptr; }
 
    *ptr << msg;
    return ptr;
}
 
inline
std::shared_ptr<DBus::Connection> operator<<( std::shared_ptr<DBus::Connection> ptr, std::shared_ptr<const DBus::Message> msg ) {
    if( !ptr ) { return ptr; }
 
    *ptr << msg;
    return ptr;
}
 
inline
std::shared_ptr<DBus::Connection> operator<<( std::shared_ptr<DBus::Connection> ptr, std::shared_ptr<DBus::ReturnMessage> msg ) {
    if( !ptr ) { return ptr; }
 
    *ptr << msg;
    return ptr;
}
 
inline
std::shared_ptr<DBus::Connection> operator<<( std::shared_ptr<DBus::Connection> ptr, std::shared_ptr<const DBus::ReturnMessage> msg ) {
    if( !ptr ) { return ptr; }
 
    *ptr << msg;
    return ptr;
}
 
inline
std::shared_ptr<DBus::Connection> operator<<( std::shared_ptr<DBus::Connection> ptr, std::shared_ptr<DBus::SignalMessage> msg ) {
    if( !ptr ) { return ptr; }
 
    *ptr << msg;
    return ptr;
}
 
inline
std::shared_ptr<DBus::Connection> operator<<( std::shared_ptr<DBus::Connection> ptr, std::shared_ptr<const DBus::SignalMessage> msg ) {
    if( !ptr ) { return ptr; }
 
    *ptr << msg;
    return ptr;
}
 
inline
std::shared_ptr<DBus::Connection> operator<<( std::shared_ptr<DBus::Connection> ptr, std::shared_ptr<DBus::ErrorMessage> msg ) {
    if( !ptr ) { return ptr; }
 
    *ptr << msg;
    return ptr;
}
 
inline
std::shared_ptr<DBus::Connection> operator<<( std::shared_ptr<DBus::Connection> ptr, std::shared_ptr<const DBus::ErrorMessage> msg ) {
    if( !ptr ) { return ptr; }
 
    *ptr << msg;
    return ptr;
}
 
} /* namespace DBus */
 
#endif