/usr/include/shevek/avahi.hh is in libshevek-dev 1.3-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 | /* avahi.hh - publish and browse network ports with avahi
* Copyright 2009 Bas Wijnen <wijnen@debian.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SHEVEK_AVAHI_HH
#define SHEVEK_AVAHI_HH
#include <map>
#include <set>
#include <glibmm.h>
#include "refbase.hh"
#include <avahi-client/client.h>
#include <avahi-client/lookup.h>
#include <avahi-client/publish.h>
#include <avahi-common/alternative.h>
#include <avahi-common/error.h>
#include <avahi-common/simple-watch.h>
#include <avahi-glib/glib-watch.h>
namespace shevek
{
/// Serve and browse the local network using avahi.
/** Easy to use interface for serving and browsing avahi-supporting hosts.
* Note that it is not as configurable as using libavahi directly.
*/
class avahi : public refbase
{
public:
/// Publish a service on a port.
/** The protocol is the name of the protocol, without leading underscore and without protocol specification. The published port is _NAME._tcp. It is not possible to publish over udp with this class. Note that you must separately set up a server to listen on the port.
*/
void publish (Glib::ustring const &protocol, int port);
/// Class for browsing other hosts.
class browser;
/// Create a browser and populate it with a list of available hosts for the requested protocol.
/** The browser must not contain a leading underscore, and must not contain the protocol specification. The actual requested port is _NAME._tcp. It is not possible to browse udp with this class.
*/
inline Glib::RefPtr <browser> create_browser (Glib::ustring const &protocol);
/// Create an avahi object for serving and/or browsing.
static Glib::RefPtr <avahi> create (Glib::ustring const &name = Glib::ustring ()) { return Glib::RefPtr <avahi> (new avahi (name)); }
/// Unpublish all ports and free all structures associated with the object.
~avahi ();
private:
avahi (Glib::ustring const &name, bool allow_restart = true, bool blocking_poller = false);
std::map <Glib::ustring, int> m_ports;
char *m_name;
bool m_allow_restart;
AvahiPoll const *m_poll_api;
AvahiGLibPoll *m_glib_poll;
AvahiEntryGroup *m_group;
AvahiClient *m_client;
AvahiSimplePoll *m_poller;
void create_services (AvahiClient *client);
void create_client ();
void name_change (AvahiClient *client);
static void group_callback (AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata);
static void callback (AvahiClient *client, AvahiClientState state, void *userdata);
};
/// Class for browsing other hosts.
class avahi::browser : public refbase
{
public:
/// Details about a discovered service. These are internally created and may be examined by the application.
struct details
{
/// Network interface.
AvahiIfIndex interface;
/// Protocol. This is always tcp, because other protocols are never browsed by this class.
AvahiProtocol protocol;
/// Hostname or ip address of the server.
Glib::ustring address;
/// Some flags about the result. Usually not useful; see the avahi documentation for possible values and their meanings.
AvahiLookupResultFlags flags;
/// Create a details object. The application has no use for this.
details (AvahiIfIndex i, AvahiProtocol p) : interface (i), protocol (p) {}
/// Create a details object. The application has no use for this.
details (AvahiIfIndex i, AvahiProtocol p, Glib::ustring a, AvahiLookupResultFlags f) : interface (i), protocol (p), address (a), flags (f) {}
/// Create a details object. The application has no use for this.
details () {}
/// Allow sorting so details can be put in a std::set.
bool operator< (details const &that) const { return interface == that.interface ? protocol < that.protocol : interface < that.interface; }
};
/// Container class for a list of details.
typedef std::set <details> details_list;
/// Information about a discovered server.
struct owner
{
/// Hostname or ip address of the server.
Glib::ustring host;
/// Port that is served by the server.
int port;
/// Create an owner object. The application has no use for this.
owner (Glib::ustring const &h, int p) : host (h), port (p) {}
/// Create an owner object. The application has no use for this.
owner () : port (-1) {}
/// Allow sorting so owners can be put in a std::map.
bool operator< (owner const &that) const { return host == that.host ? port < that.port : host < that.host; }
/// Services provided by this host.
details_list details;
};
/// Container class for a list of owners.
typedef std::map <Glib::ustring, owner> list;
/// Access the list of owners.
list const &get_list () { return m_list; }
/// Signal to be notified when the list changes.
sigc::signal1 <void, Glib::ustring const &> signal_changed () { return m_changed; }
/// The destructor cleans everything up.
~browser ();
/// Create a browser class without an existing avahi object. Don't use this if you have an avahi object; use avahi::create_browser instead.
static Glib::RefPtr <browser> create (Glib::ustring const &protocol) { return Glib::RefPtr <browser> (new browser (avahi::create (), protocol)); }
/// Synchronously get a list of owners. When using this, the servers are not monitored, so you will not be notified of any changes.
static list get_list_block (Glib::ustring const &protocol, Glib::ustring const &name = Glib::ustring ());
private:
Glib::RefPtr <avahi> m_parent;
list m_list;
AvahiServiceBrowser *m_sb;
sigc::signal1 <void, Glib::ustring const &> m_changed;
Glib::ustring m_filter;
friend class avahi;
browser (Glib::RefPtr <avahi> parent, Glib::ustring const &protocol);
static void resolve_callback (AvahiServiceResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, char const *name, char const *type, char const *domain, char const *host_name, AvahiAddress const *address, uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags flags, void * userdata);
static void browse_callback (AvahiServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, char const *name, char const *type, char const *domain, AvahiLookupResultFlags flags, void *userdata);
};
Glib::RefPtr <avahi::browser> avahi::create_browser (Glib::ustring const &protocol)
{
return Glib::RefPtr <browser> (new browser (refptr_this <avahi> (), protocol));
}
}
#endif
|