static void
client_callback(AvahiClient *c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata)
{
struct mdns_browser *mb;
AvahiServiceBrowser *b;
int error;
switch (state)
{
case AVAHI_CLIENT_S_RUNNING:
DPRINTF(E_LOG, L_MDNS, "Avahi state change: Client running\n");
if (!mdns_group)
create_all_group_entries();
for (mb = browser_list; mb; mb = mb->next)
{
b = avahi_service_browser_new(mdns_client, AVAHI_IF_UNSPEC, mb->protocol, mb->type, NULL, 0, browse_callback, mb);
if (!b)
DPRINTF(E_LOG, L_MDNS, "Failed to recreate service browser (service type %s): %s\n", mb->type, MDNSERR);
}
break;
case AVAHI_CLIENT_S_COLLISION:
DPRINTF(E_LOG, L_MDNS, "Avahi state change: Client collision\n");
if(mdns_group)
avahi_entry_group_reset(mdns_group);
break;
case AVAHI_CLIENT_FAILURE:
DPRINTF(E_LOG, L_MDNS, "Avahi state change: Client failure\n");
error = avahi_client_errno(c);
if (error == AVAHI_ERR_DISCONNECTED)
{
DPRINTF(E_LOG, L_MDNS, "Avahi Server disconnected, reconnecting\n");
avahi_client_free(mdns_client);
mdns_group = NULL;
mdns_client = avahi_client_new(&ev_poll_api, AVAHI_CLIENT_NO_FAIL, client_callback, NULL, &error);
if (!mdns_client)
DPRINTF(E_LOG, L_MDNS, "Failed to create new Avahi client: %s\n", avahi_strerror(error));
}
else
{
DPRINTF(E_LOG, L_MDNS, "Avahi client failure: %s\n", avahi_strerror(error));
}
break;
case AVAHI_CLIENT_S_REGISTERING:
DPRINTF(E_LOG, L_MDNS, "Avahi state change: Client registering\n");
if (mdns_group)
avahi_entry_group_reset(mdns_group);
break;
case AVAHI_CLIENT_CONNECTING:
DPRINTF(E_LOG, L_MDNS, "Avahi state change: Client connecting\n");
break;
}
}
static void unpublish_all_services(struct userdata *u, pa_bool_t rem) {
void *state = NULL;
struct service *s;
pa_assert(u);
pa_log_debug("Unpublishing services in Zeroconf");
while ((s = pa_hashmap_iterate(u->services, &state, NULL))) {
if (s->entry_group) {
if (rem) {
pa_log_debug("Removing entry group for %s.", s->service_name);
avahi_entry_group_free(s->entry_group);
s->entry_group = NULL;
} else {
avahi_entry_group_reset(s->entry_group);
pa_log_debug("Resetting entry group for %s.", s->service_name);
}
}
}
if (u->main_entry_group) {
if (rem) {
pa_log_debug("Removing main entry group.");
avahi_entry_group_free(u->main_entry_group);
u->main_entry_group = NULL;
} else {
avahi_entry_group_reset(u->main_entry_group);
pa_log_debug("Resetting main entry group.");
}
}
}
static void client_callback(AvahiClient *c, AvahiClientState state,
AVAHI_GCC_UNUSED void *userdata) {
switch (state) {
case AVAHI_CLIENT_S_REGISTERING:
if (group)
avahi_entry_group_reset(group);
break;
case AVAHI_CLIENT_S_RUNNING:
register_service(c);
break;
case AVAHI_CLIENT_FAILURE:
debug(1,"avahi: client failure");
break;
case AVAHI_CLIENT_S_COLLISION:
debug(2, "avahi: state is AVAHI_CLIENT_S_COLLISION...needs a rename: %s", name );
break;
case AVAHI_CLIENT_CONNECTING:
debug(2, "avahi: received AVAHI_CLIENT_CONNECTING" );
break;
default:
debug(1,"avahi: unexpected and unhandled avahi client state: %d", state );
break;
}
}
static void
avahi_client_callback (AVAHI_GCC_UNUSED AvahiClient * client,
AvahiClientState state, void *userdata)
{
AurAvahi *avahi = (AurAvahi *) (userdata);
switch (state) {
case AVAHI_CLIENT_S_RUNNING:
/* Create services now */
avahi->priv->client = client;
create_service (avahi);
break;
case AVAHI_CLIENT_FAILURE:
g_error ("Client failure: %s\n",
avahi_strerror (avahi_client_errno (client)));
break;
case AVAHI_CLIENT_S_COLLISION:
/* Let's drop our registered services. When the server is back
* in AVAHI_SERVER_RUNNING state we will register them
* again with the new host name. */
case AVAHI_CLIENT_S_REGISTERING:
/* The server records are now being established. This
* might be caused by a host name change. We need to wait
* to records to register until the host name is
* properly established - so clear out any pending
* registration group. */
if (avahi->priv->group)
avahi_entry_group_reset (avahi->priv->group);
break;
default:
break;
}
}
static void
create_all_group_entries(void)
{
struct mdns_group_entry *ge;
int ret;
if (!group_entries)
{
DPRINTF(E_DBG, L_MDNS, "No entries yet... skipping service create\n");
return;
}
if (mdns_group)
avahi_entry_group_reset(mdns_group);
DPRINTF(E_INFO, L_MDNS, "Re-registering mDNS groups (services and records)\n");
for (ge = group_entries; ge; ge = ge->next)
{
create_group_entry(ge, 0);
if (!mdns_group)
return;
}
ret = avahi_entry_group_commit(mdns_group);
if (ret < 0)
DPRINTF(E_WARN, L_MDNS, "Could not commit mDNS services: %s\n", MDNSERR);
}
static void client_cnames_callback(AvahiClient *c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata)
{
struct runtime_data r;
/* Called whenever the client or server state changes */
switch (state)
{
case AVAHI_CLIENT_S_RUNNING:
create_cnames(c);
break;
case AVAHI_CLIENT_FAILURE:
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r.main_server, "Client failure: %s", avahi_strerror(avahi_client_errno(c)));
avahi_simple_poll_quit(_poll);
break;
case AVAHI_CLIENT_S_COLLISION:
case AVAHI_CLIENT_S_REGISTERING:
if (_group) avahi_entry_group_reset(_group);
break;
case AVAHI_CLIENT_CONNECTING:
/* do nothing */
break;
}
}
static void client_callback(AvahiClient * c,
AvahiClientState state, AVAHI_GCC_UNUSED void
*userdata)
{
Game *game = (Game *) userdata;
g_assert(c != NULL);
/* Called whenever the client or server state changes */
switch (state) {
case AVAHI_CLIENT_S_RUNNING:
/* The server has startup successfully and registered its host
* name on the network, so it's time to create our services */
if (!group)
create_services(c, game);
break;
case AVAHI_CLIENT_S_COLLISION:
/* Let's drop our registered services. When the server is back
* in AVAHI_SERVER_RUNNING state we will register them
* again with the new host name. */
if (group)
avahi_entry_group_reset(group);
break;
case AVAHI_CLIENT_FAILURE:
log_message(MSG_ERROR,
_("Avahi error: %s, %s\n"), "Client failure",
avahi_strerror(avahi_client_errno(c)));
avahi_glib_poll_free(glib_poll);
break;
case AVAHI_CLIENT_CONNECTING:
case AVAHI_CLIENT_S_REGISTERING:
;
}
}
JNIEXPORT jint JNICALL Java_avahi4j_EntryGroup_reset_1group(JNIEnv *e, jobject t, jlong ptr){
dprint("[LOG] Entering %s\n", __PRETTY_FUNCTION__);
struct avahi4j_entry_group *group = (struct avahi4j_entry_group *) (uintptr_t) ptr;
int result = avahi_entry_group_reset(group->group);
CHECK_N_RET(avahi_entry_group_reset, result);
}
void Publisher::createServices(AvahiClient *client) {
int error;
const char* name = info.getServiceName().c_str();
int port = info.getPort();
if (group == NULL) {
group = avahi_entry_group_new(client, &Publisher::entryGroupCallback, this);
if (group == NULL) {
std::cerr << "Could not create avahi group ("
<< avahi_strerror(avahi_client_errno(client))
<< ")." << std::endl;
return;
}
}
if (avahi_entry_group_is_empty(group)) {
// new group or after reset
error = avahi_entry_group_add_service(group, // group
AVAHI_IF_UNSPEC, // interface
AVAHI_PROTO_UNSPEC, // protocol to announce service with
AVAHI_PUBLISH_USE_MULTICAST, // flags
name, // service name
serviceType, // service type
NULL, // domain
NULL, // host
port, // port
txtDataDeviceName.c_str(),
txtDataProviderClassName.c_str(),
txtDataSerialNumber.c_str(),
NULL); // list of txt records
if (error < 0) {
// error
if (error == AVAHI_ERR_COLLISION) {
// collision with local service name
nextName();
avahi_entry_group_reset(group);
// retry
createServices(client);
} else {
std::cerr << "Could not add service '"
<< name << "' (" << serviceType << ") to avahi group ("
<< avahi_strerror(error) << ")" << std::endl;
return;
}
}
// start registering the service
error = avahi_entry_group_commit(group);
if (error < 0) {
std::cerr << "Could not commit avahi group "
<< "'" << name << "'"
<< " (" << avahi_strerror(error) << ")" << std::endl;
}
}
}
static void
dnssd_client_cb(AvahiClient *c, /* I - Client */
AvahiClientState state, /* I - Current state */
void *userdata) /* I - User data (unused) */
{
(void)userdata;
int error; /* Error code, if any */
if (!c)
return;
switch (state) {
default :
NOTE("Ignore Avahi state %d.", state);
break;
case AVAHI_CLIENT_CONNECTING:
NOTE("Waiting for Avahi server.");
break;
case AVAHI_CLIENT_S_RUNNING:
NOTE("Avahi server connection got available, registering printer.");
dnssd_register(c);
break;
case AVAHI_CLIENT_S_REGISTERING:
case AVAHI_CLIENT_S_COLLISION:
NOTE("Dropping printer registration because of possible host name change.");
if (g_options.dnssd_data->ipp_ref)
avahi_entry_group_reset(g_options.dnssd_data->ipp_ref);
break;
case AVAHI_CLIENT_FAILURE:
if (avahi_client_errno(c) == AVAHI_ERR_DISCONNECTED) {
NOTE("Avahi server disappeared, unregistering printer");
dnssd_unregister();
/* Renewing client */
if (g_options.dnssd_data->DNSSDClient)
avahi_client_free(g_options.dnssd_data->DNSSDClient);
if ((g_options.dnssd_data->DNSSDClient =
avahi_client_new(avahi_threaded_poll_get
(g_options.dnssd_data->DNSSDMaster),
AVAHI_CLIENT_NO_FAIL,
dnssd_client_cb, NULL, &error)) == NULL) {
ERR("Error: Unable to initialize DNS-SD client.");
g_options.terminate = 1;
}
} else {
ERR("Avahi server connection failure: %s",
avahi_strerror(avahi_client_errno(c)));
g_options.terminate = 1;
}
break;
}
}
static void client_callback(AvahiClient *client,
AvahiClientState state,
void *userdata)
{
ctx->client = client;
switch (state) {
case AVAHI_CLIENT_S_RUNNING:
/* The server has startup successfully and registered its host
* name on the network, so it's time to create our services */
if (!ctx->group)
register_stuff();
break;
case AVAHI_CLIENT_S_COLLISION:
if (ctx->group)
avahi_entry_group_reset(ctx->group);
break;
case AVAHI_CLIENT_FAILURE: {
if (avahi_client_errno(client) == AVAHI_ERR_DISCONNECTED) {
int error;
avahi_client_free(ctx->client);
ctx->client = NULL;
ctx->group = NULL;
/* Reconnect to the server */
if (!(ctx->client = avahi_client_new(avahi_threaded_poll_get(ctx->threaded_poll),
AVAHI_CLIENT_NO_FAIL,
client_callback,
ctx,
&error))) {
LOG(log_error, logtype_afpd, "Failed to contact server: %s",
avahi_strerror(error));
avahi_threaded_poll_quit(ctx->threaded_poll);
}
} else {
LOG(log_error, logtype_afpd, "Client failure: %s",
avahi_strerror(avahi_client_errno(client)));
avahi_threaded_poll_quit(ctx->threaded_poll);
}
break;
}
case AVAHI_CLIENT_S_REGISTERING:
break;
case AVAHI_CLIENT_CONNECTING:
break;
}
}
static void client_callback(AvahiClient *client, AvahiClientState state, void *userdata) {
struct context *ctx = userdata;
ctx->client = client;
switch (state) {
case AVAHI_CLIENT_S_RUNNING:
register_stuff(ctx);
break;
case AVAHI_CLIENT_S_COLLISION:
case AVAHI_CLIENT_S_REGISTERING:
if (ctx->group)
avahi_entry_group_reset(ctx->group);
break;
case AVAHI_CLIENT_FAILURE:
if (avahi_client_errno(client) == AVAHI_ERR_DISCONNECTED) {
int error;
avahi_client_free(ctx->client);
ctx->client = NULL;
ctx->group = NULL;
/* Reconnect to the server */
if (!(ctx->client = avahi_client_new(
avahi_threaded_poll_get(ctx->threaded_poll),
AVAHI_CLIENT_NO_FAIL,
client_callback,
ctx,
&error))) {
rs_log_crit("Failed to contact server: %s", avahi_strerror(error));
avahi_threaded_poll_quit(ctx->threaded_poll);
}
} else {
rs_log_crit("Client failure: %s", avahi_strerror(avahi_client_errno(client)));
avahi_threaded_poll_quit(ctx->threaded_poll);
}
break;
case AVAHI_CLIENT_CONNECTING:
;
}
}
static void client_callback(AvahiClient *client,
AvahiClientState state,
void *userdata)
{
ctx.client = client;
switch (state) {
case AVAHI_CLIENT_S_RUNNING:
/* The server has started up successfully and registered its host
* name on the network, so it's time to create our services */
register_stuff();
break;
case AVAHI_CLIENT_S_COLLISION:
case AVAHI_CLIENT_S_REGISTERING:
if (ctx.group)
avahi_entry_group_reset(ctx.group);
break;
case AVAHI_CLIENT_FAILURE:
if (avahi_client_errno(client) == AVAHI_ERR_DISCONNECTED)
{
int error;
avahi_client_free(ctx.client);
ctx.client = NULL;
ctx.group = NULL;
/* Reconnect to the server */
ctx.client = avahi_client_new(
avahi_threaded_poll_get(ctx.threaded_poll),
AVAHI_CLIENT_NO_FAIL, client_callback,
&ctx, &error);
if (!ctx.client)
{
DPRINTF(E_ERROR, L_SSDP,
"Failed to contact server: %s\n",
avahi_strerror(error));
avahi_threaded_poll_quit(ctx.threaded_poll);
}
}
else
{
DPRINTF(E_ERROR, L_SSDP, "Client failure: %s\n",
avahi_strerror(avahi_client_errno(client)));
avahi_threaded_poll_quit(ctx.threaded_poll);
}
break;
case AVAHI_CLIENT_CONNECTING:
default:
break;
}
}
void AvahiSession::CreateServices(AvahiClient* client)
{
int err;
if (mGroup) {
avahi_entry_group_reset(mGroup);
} else {
mGroup = avahi_entry_group_new(client, group_cb, this);
if (!mGroup) {
scprintf("Zeroconf: failed to create entry group: %s\n",
avahi_strerror(avahi_client_errno(client)));
return;
}
}
mMutex.lock();
AvahiEntry* entry = mEntries;
while (entry) {
const char* type = SCRendezvousProtocolString(entry->mProto);
err = avahi_entry_group_add_service(
mGroup, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
(AvahiPublishFlags)0, mServiceName, type,
NULL, NULL, entry->mPort,
NULL);
if (err == AVAHI_ERR_COLLISION) {
// BUG: shouldn't this actually be triggered in the entry
// group callback?
RenameService();
err = avahi_entry_group_add_service(
mGroup, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
(AvahiPublishFlags)0, mServiceName, type,
NULL, NULL, entry->mPort,
NULL);
}
if (err < 0) {
scprintf("Zeroconf: failed to register service '%s': %s\n",
mServiceName, avahi_strerror(err));
}
entry = entry->mNext;
}
mMutex.unlock();
if (!avahi_entry_group_is_empty(mGroup)) {
err = avahi_entry_group_commit(mGroup);
if (err < 0) {
scprintf("Zeroconf: failed to commit entry group: %s\n",
avahi_strerror(err));
return;
}
}
}
static void
epc_service_reset (EpcService *self)
{
if (self->group)
{
if (EPC_DEBUG_LEVEL (1))
g_debug ("%s: Resetting `%s' for `%s'...",
G_STRLOC, self->type, self->dispatcher->priv->name);
avahi_entry_group_reset (self->group);
}
else
epc_service_run (self);
}
void create_services(AvahiClient *c) {
char r[128];
int ret;
assert(c);
/* If this is the first time we're called, let's create a new
* entry group if necessary */
if (!group)
if (!(group = avahi_entry_group_new(c, entry_group_callback, NULL))) {
std::cerr << "avahi_entry_group_new() failed: " << avahi_strerror(avahi_client_errno(c)) << std::endl;
}
/* If the group is empty (either because it was just created, or
* because it was reset previously, add our entries. */
if (avahi_entry_group_is_empty(group)) {
std::cerr << "Adding service '" << name << "'" << std::endl;
/* Create some random TXT data */
snprintf(r, sizeof(r), "random=%i", rand());
/* We will now add two services and one subtype to the entry
* group. The two services have the same name, but differ in
* the service type (IPP vs. BSD LPR). Only services with the
* same name should be put in the same entry group. */
if ((ret = avahi_entry_group_add_service(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, (AvahiPublishFlags)0, name.c_str(), "_heatSync._tcp", NULL, NULL, PORTINT, "version=0.1", NULL, NULL )) < 0) { //todo: magically put in version no.
if (ret == AVAHI_ERR_COLLISION) {
name = avahi_alternative_service_name(name.c_str());
std::cerr << "Service name collision, renaming service to '" << name << "'" << std::endl;
avahi_entry_group_reset(group);
create_services(c);
return;
}
std::cerr << "Failed to add " << name << " service: " << avahi_strerror(ret) << std::endl;
}
/* Tell the server to register the service */
if ((ret = avahi_entry_group_commit(group)) < 0) {
std::cerr << "Failed to commit entry group: " << avahi_strerror(ret) << std::endl;
}
}
avahi_simple_poll_quit(simple_publish_poll);
}
static void reset_services(struct runtime_data *r) {
struct service_data *j;
ap_assert(r);
for (j = r->services; j; j = j->next) {
if (j->group)
avahi_entry_group_reset(j->group);
if (j->pool)
apr_pool_clear(j->pool);
j->chosen_name = NULL;
}
}
void CZeroconfAvahi::clientCallback(AvahiClient* fp_client, AvahiClientState f_state, void* fp_data)
{
CZeroconfAvahi* p_instance = static_cast<CZeroconfAvahi*>(fp_data);
//store our thread ID and check for shutdown -> check details in destructor
p_instance->m_thread_id = pthread_self();
if (p_instance->m_shutdown)
{
avahi_threaded_poll_quit(p_instance->mp_poll);
return;
}
switch(f_state)
{
case AVAHI_CLIENT_S_RUNNING:
CLog::Log(LOGDEBUG, "CZeroconfAvahi::clientCallback: client is up and running");
p_instance->updateServices(fp_client);
break;
case AVAHI_CLIENT_FAILURE:
CLog::Log(LOGINFO, "CZeroconfAvahi::clientCallback: client failure. avahi-daemon stopped? Recreating client...");
//We were forced to disconnect from server. now free and recreate the client object
avahi_client_free(fp_client);
p_instance->mp_client = 0;
//freeing the client also frees all groups and browsers, pointers are undefined afterwards, so fix that now
for(tServiceMap::const_iterator it = p_instance->m_services.begin(); it != p_instance->m_services.end(); ++it)
{
it->second->mp_group = 0;
}
p_instance->createClient();
break;
case AVAHI_CLIENT_S_COLLISION:
case AVAHI_CLIENT_S_REGISTERING:
//HERE WE SHOULD REMOVE ALL OF OUR SERVICES AND "RESCHEDULE" them for later addition
CLog::Log(LOGDEBUG, "CZeroconfAvahi::clientCallback: uiuui; coll or reg, anyways, resetting groups");
for(tServiceMap::const_iterator it = p_instance->m_services.begin(); it != p_instance->m_services.end(); ++it)
{
if (it->second->mp_group)
avahi_entry_group_reset(it->second->mp_group);
}
break;
case AVAHI_CLIENT_CONNECTING:
CLog::Log(LOGINFO, "CZeroconfAvahi::clientCallback: avahi server not available. But may become later...");
break;
}
}
static void client_callback(AvahiClient *c, AvahiClientState state,
AVAHI_GCC_UNUSED void *userdata) {
int err;
switch (state) {
case AVAHI_CLIENT_S_REGISTERING:
if (group)
avahi_entry_group_reset(group);
break;
case AVAHI_CLIENT_S_RUNNING:
register_service(c);
break;
case AVAHI_CLIENT_FAILURE:
err = avahi_client_errno(c);
debug(1, "avahi: client failure: %s", avahi_strerror(err));
if (err == AVAHI_ERR_DISCONNECTED) {
/* We have been disconnected, so lets reconnect */
avahi_client_free(c);
c = NULL;
group = NULL;
if (!(client = avahi_client_new(avahi_threaded_poll_get(tpoll), AVAHI_CLIENT_NO_FAIL,
client_callback, userdata, &err))) {
warn("avahi: failed to create client object: %s", avahi_strerror(err));
avahi_threaded_poll_quit(tpoll);
}
} else {
warn("avahi: client failure: %s", avahi_strerror(err));
avahi_threaded_poll_quit(tpoll);
}
break;
case AVAHI_CLIENT_S_COLLISION:
debug(2, "avahi: state is AVAHI_CLIENT_S_COLLISION...needs a rename: %s", service_name);
break;
case AVAHI_CLIENT_CONNECTING:
debug(2, "avahi: received AVAHI_CLIENT_CONNECTING");
break;
default:
debug(1, "avahi: unexpected and unhandled avahi client state: %d", state);
break;
}
}
static gboolean
create_services (DMAPMdnsPublisher * publisher, GError ** error)
{
GSList *ptr;
int ret;
if (publisher->priv->entry_group == NULL) {
publisher->priv->entry_group =
avahi_entry_group_new (publisher->priv->client,
(AvahiEntryGroupCallback)
entry_group_cb, publisher);
dmap_mdns_avahi_set_entry_group (publisher->
priv->entry_group);
} else {
avahi_entry_group_reset (publisher->priv->entry_group);
}
if (publisher->priv->entry_group == NULL) {
g_warning ("Could not create AvahiEntryGroup for publishing");
g_set_error (error,
DMAP_MDNS_PUBLISHER_ERROR,
DMAP_MDNS_PUBLISHER_ERROR_FAILED,
"%s",
_
("Could not create AvahiEntryGroup for publishing"));
return FALSE;
}
for (ptr = publisher->priv->service; ptr; ptr = g_slist_next (ptr)) {
if (!create_service (ptr->data, publisher, error)) {
return FALSE;
}
}
ret = avahi_entry_group_commit (publisher->priv->entry_group);
if (ret < 0) {
g_set_error (error,
DMAP_MDNS_PUBLISHER_ERROR,
DMAP_MDNS_PUBLISHER_ERROR_FAILED,
"%s: %s",
_("Could not commit service"),
avahi_strerror (ret));
return FALSE;
}
return TRUE;
}
/*
* Tries to shutdown this loop impl.
* Call this function from inside this thread.
*/
void tivo_bonjour_unregister(void)
{
DPRINTF(E_DEBUG, L_SSDP, "tivo_bonjour_unregister\n");
if (ctx.group)
{
avahi_entry_group_reset(ctx.group);
avahi_entry_group_free(ctx.group);
}
if (ctx.threaded_poll)
avahi_threaded_poll_stop(ctx.threaded_poll);
if (ctx.client)
avahi_client_free(ctx.client);
if (ctx.threaded_poll)
avahi_threaded_poll_free(ctx.threaded_poll);
}
/*
* Tries to setup the Zeroconf thread and any
* neccessary config setting.
*/
void av_zeroconf_register(const AFPObj *obj) {
int error;
/* initialize the struct that holds our config settings. */
if (ctx) {
LOG(log_debug, logtype_afpd, "Resetting zeroconf records");
avahi_entry_group_reset(ctx->group);
} else {
ctx = calloc(1, sizeof(struct context));
ctx->obj = obj;
assert(ctx);
}
/* first of all we need to initialize our threading env */
if (!(ctx->threaded_poll = avahi_threaded_poll_new())) {
goto fail;
}
/* now we need to acquire a client */
if (!(ctx->client = avahi_client_new(avahi_threaded_poll_get(ctx->threaded_poll),
AVAHI_CLIENT_NO_FAIL,
client_callback,
NULL,
&error))) {
LOG(log_error, logtype_afpd, "Failed to create client object: %s",
avahi_strerror(error));
goto fail;
}
if (avahi_threaded_poll_start(ctx->threaded_poll) < 0) {
LOG(log_error, logtype_afpd, "Failed to create thread: %s",
avahi_strerror(avahi_client_errno(ctx->client)));
goto fail;
} else {
LOG(log_info, logtype_afpd, "Successfully started avahi loop.");
}
ctx->thread_running = 1;
return;
fail:
av_zeroconf_unregister();
return;
}
void PublishAvahi::client_callback(AvahiClient *c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata)
{
assert(c);
/* Called whenever the client or server state changes */
switch (state)
{
case AVAHI_CLIENT_S_RUNNING:
/* The server has startup successfully and registered its host
* name on the network, so it's time to create our services */
static_cast<PublishAvahi*>(userdata)->create_services(c);
break;
case AVAHI_CLIENT_FAILURE:
logE << "Client failure: " << avahi_strerror(avahi_client_errno(c)) << "\n";
avahi_simple_poll_quit(simple_poll);
break;
case AVAHI_CLIENT_S_COLLISION:
/* Let's drop our registered services. When the server is back
* in AVAHI_SERVER_RUNNING state we will register them
* again with the new host name. */
case AVAHI_CLIENT_S_REGISTERING:
/* The server records are now being established. This
* might be caused by a host name change. We need to wait
* for our own records to register until the host name is
* properly esatblished. */
if (group)
avahi_entry_group_reset(group);
break;
case AVAHI_CLIENT_CONNECTING:
;
}
}
static int publish_main_service(struct userdata *u) {
AvahiStringList *txt = NULL;
int r = -1;
pa_assert(u);
if (!u->main_entry_group) {
if (!(u->main_entry_group = avahi_entry_group_new(u->client, main_entry_group_callback, u))) {
pa_log("avahi_entry_group_new() failed: %s", avahi_strerror(avahi_client_errno(u->client)));
goto fail;
}
} else
avahi_entry_group_reset(u->main_entry_group);
txt = txt_record_server_data(u->core, txt);
if (avahi_entry_group_add_service_strlst(
u->main_entry_group,
AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
0,
u->service_name,
SERVICE_TYPE_SERVER,
NULL,
NULL,
compute_port(u),
txt) < 0) {
pa_log("avahi_entry_group_add_service_strlst() failed: %s", avahi_strerror(avahi_client_errno(u->client)));
goto fail;
}
if (avahi_entry_group_commit(u->main_entry_group) < 0) {
pa_log("avahi_entry_group_commit() failed: %s", avahi_strerror(avahi_client_errno(u->client)));
goto fail;
}
r = 0;
fail:
avahi_string_list_free(txt);
return r;
}
static void modify_callback(AVAHI_GCC_UNUSED AvahiTimeout *e, void *userdata) {
AvahiClient *client = userdata;
fprintf(stderr, "Doing some weird modification\n");
avahi_free(name);
name = avahi_strdup("Modified MegaPrinter");
/* If the server is currently running, we need to remove our
* service and create it anew */
if (avahi_client_get_state(client) == AVAHI_CLIENT_S_RUNNING) {
/* Remove the old services */
if (group)
avahi_entry_group_reset(group);
/* And create them again with the new name */
create_services(client);
}
}
static void
client_cb (AvahiClient *client,
AvahiClientState state,
gpointer data)
{
/* FIXME
* check to make sure we're in the _RUNNING state before we publish
* check for COLLISION state and remove published information
*/
/* Called whenever the client or server state changes */
switch (state) {
case AVAHI_CLIENT_S_RUNNING:
/* The server has startup successfully and registered its host
* name on the network, so it's time to create our services
*/
break;
case AVAHI_CLIENT_S_COLLISION:
/* Let's drop our registered services. When the server is back
* in AVAHI_SERVER_RUNNING state we will register them
* again with the new host name.
*/
if (entry_group) {
avahi_entry_group_reset (entry_group);
}
break;
case AVAHI_CLIENT_FAILURE:
g_warning ("Client failure: %s\n", avahi_strerror (avahi_client_errno (client)));
break;
case AVAHI_CLIENT_CONNECTING:
case AVAHI_CLIENT_S_REGISTERING:
default:
break;
}
}
int
mdns_register(char *name, char *type, int port, char **txt)
{
struct mdns_group_entry *ge;
AvahiStringList *txt_sl;
int i;
DPRINTF(E_DBG, L_MDNS, "Adding mDNS service %s/%s\n", name, type);
ge = (struct mdns_group_entry *)malloc(sizeof(struct mdns_group_entry));
if (!ge)
return -1;
ge->name = strdup(name);
ge->type = strdup(type);
ge->port = port;
txt_sl = NULL;
for (i = 0; txt[i]; i++)
{
txt_sl = avahi_string_list_add(txt_sl, txt[i]);
DPRINTF(E_DBG, L_MDNS, "Added key %s\n", txt[i]);
}
ge->txt = txt_sl;
ge->next = group_entries;
group_entries = ge;
if (mdns_group)
{
DPRINTF(E_DBG, L_MDNS, "Resetting mDNS group\n");
avahi_entry_group_reset(mdns_group);
}
DPRINTF(E_DBG, L_MDNS, "Creating service group\n");
_create_services();
return 0;
}
static void
mdns_register_task(void *arg)
{
struct mdns_group_entry *ge;
ge = (struct mdns_group_entry *)arg;
DPRINTF(E_DBG, L_MDNS, "[ASYNC] Adding mDNS service %s/%s\n", ge->name, ge->type);
ge->next = group_entries;
group_entries = ge;
if (mdns_group)
{
DPRINTF(E_DBG, L_MDNS, "Resetting mDNS group\n");
avahi_entry_group_reset(mdns_group);
}
DPRINTF(E_DBG, L_MDNS, "Creating service group\n");
_create_services();
}
void avahi_reset(void) {
int i;
if (db) fprintf(stderr, "in avahi_reset\n");
for (i=0; i<NREG; i++) {
if (registered[i].name) {
free(registered[i].name);
registered[i].name = NULL;
}
if (registered[i].host) {
free(registered[i].host);
registered[i].host = NULL;
}
}
if (!_client || !_group) {
if (db) fprintf(stderr, " avahi_reset client/group null\n");
return;
}
avahi_entry_group_reset(_group);
rfbLog("Avahi resetting group.\n");
if (db) fprintf(stderr, "out avahi_reset\n");
}
gboolean
dmap_mdns_publisher_withdraw (DMAPMdnsPublisher * publisher,
guint port, GError ** error)
{
struct DMAPMdnsPublisherService *ptr;
if (publisher->priv->client == NULL) {
g_set_error (error,
DMAP_MDNS_PUBLISHER_ERROR,
DMAP_MDNS_PUBLISHER_ERROR_NOT_RUNNING,
"%s",
_("The avahi MDNS service is not running"));
return FALSE;
}
if (publisher->priv->entry_group == NULL
|| !(ptr =
find_service_by_port (publisher->priv->service, port))) {
g_set_error (error, DMAP_MDNS_PUBLISHER_ERROR,
DMAP_MDNS_PUBLISHER_ERROR_FAILED, "%s",
_("The MDNS service is not published"));
return FALSE;
}
free_service (ptr, NULL);
publisher->priv->service =
g_slist_remove (publisher->priv->service, ptr);
if (publisher->priv->service == NULL) {
avahi_entry_group_reset (publisher->priv->entry_group);
avahi_entry_group_free (publisher->priv->entry_group);
publisher->priv->entry_group = NULL;
} else {
create_services (publisher, error);
if (error != NULL)
return FALSE;
}
return TRUE;
}
