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.");
}
}
}
const char *addAvahiGroup(AvahiThreadedPoll *threaded_poll, AvahiClient *client,
AvahiEntryGroup **group, const char *service_name, unsigned short port, AvahiStringList *txt) {
*group = avahi_entry_group_new(client, handleGroupStateChange, (void *)service_name);
if (!*group) {
return avahi_strerror(avahi_client_errno(client));
}
int error = avahi_entry_group_add_service_strlst(
*group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, 0, service_name,
SERVICE_TYPE, NULL, NULL, port, txt);
if (AVAHI_OK != error) {
avahi_entry_group_free(*group);
return avahi_strerror(error);
}
error = avahi_entry_group_add_service_subtype(*group, AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC, 0, service_name, SERVICE_TYPE, NULL, SERVICE_SUBTYPE);
if (AVAHI_OK != error) {
avahi_entry_group_free(*group);
return avahi_strerror(error);
}
error = avahi_entry_group_commit(*group);
if (AVAHI_OK != error) {
avahi_entry_group_free(*group);
return avahi_strerror(error);
}
return NULL;
}
static void
create_services (AvahiClient *c)
{
int ret;
struct utsname uts;
gchar *name;
g_return_if_fail (c);
if (uname (&uts) != 0) {
printf ("failed to run uname()\n");
name = g_strdup ("xmms2");
} else {
name = g_strdup (uts.nodename);
}
if (!group) {
if (!(group = avahi_entry_group_new (c, group_callback, NULL))) {
printf ("couldn't create new group!\n");
g_free (name);
g_main_loop_quit (ml);
return;
}
}
if ((ret = avahi_entry_group_add_service (group, AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC,
0, name, "_xmms2._tcp",
NULL, NULL, port, NULL)) < 0)
{
printf ("couldn't add entry to group: %s\n", avahi_strerror (ret));
g_free (name);
g_main_loop_quit (ml);
avahi_entry_group_free (group);
return;
}
g_free (name);
if ((ret = avahi_entry_group_commit (group)) < 0) {
printf ("couldn't commit group: %s\n", avahi_strerror (ret));
g_main_loop_quit (ml);
avahi_entry_group_free (group);
return;
}
return;
}
static void main_entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
struct userdata *u = userdata;
pa_assert(u);
switch (state) {
case AVAHI_ENTRY_GROUP_ESTABLISHED:
pa_log_info("Successfully established main service.");
break;
case AVAHI_ENTRY_GROUP_COLLISION: {
char *t;
t = avahi_alternative_service_name(u->service_name);
pa_log_info("Name collision: renaming main service %s to %s.", u->service_name, t);
pa_xfree(u->service_name);
u->service_name = t;
publish_main_service(u);
break;
}
case AVAHI_ENTRY_GROUP_FAILURE: {
pa_log("Failed to register main service: %s", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g))));
avahi_entry_group_free(g);
u->main_entry_group = NULL;
break;
}
case AVAHI_ENTRY_GROUP_UNCOMMITED:
case AVAHI_ENTRY_GROUP_REGISTERING:
break;
}
}
void avahi_unregister_game(void)
{
#ifdef HAVE_AVAHI
/* Cleanup things */
if (group) {
avahi_entry_group_free(group);
group = NULL;
}
if (client) {
avahi_client_free(client);
client = NULL;
}
if (glib_poll) {
avahi_glib_poll_free(glib_poll);
glib_poll = NULL;
}
if (name) {
avahi_free(name);
name = NULL;
}
log_message(MSG_INFO, _("Unregistering Avahi.\n"));
#endif // HAVE_AVAHI
}
void avahi_cleanup_dead_entries(AvahiServer *s) {
assert(s);
if (s->need_group_cleanup) {
AvahiSEntryGroup *g, *next;
for (g = s->groups; g; g = next) {
next = g->groups_next;
if (g->dead)
avahi_entry_group_free(s, g);
}
s->need_group_cleanup = 0;
}
if (s->need_entry_cleanup) {
AvahiEntry *e, *next;
for (e = s->entries; e; e = next) {
next = e->entries_next;
if (e->dead)
avahi_entry_free(s, e);
}
s->need_entry_cleanup = 0;
}
if (s->need_browser_cleanup)
avahi_browser_cleanup(s);
}
bool CZeroconfAvahi::doRemoveService(const std::string& fcr_ident)
{
CLog::Log(LOGDEBUG, "CZeroconfAvahi::doRemoveService named: %s", fcr_ident.c_str());
ScopedEventLoopBlock l_block(mp_poll);
tServiceMap::iterator it = m_services.find(fcr_ident);
if (it == m_services.end())
{
return false;
}
if (it->second->mp_group)
{
avahi_entry_group_free(it->second->mp_group);
it->second->mp_group = 0;
}
if(it->second->mp_txt)
{
avahi_string_list_free(it->second->mp_txt);
it->second->mp_txt = NULL;
}
m_services.erase(it);
return true;
}
announcer::~announcer()
{
if (ptr)
{
avahi_entry_group_free(ptr);
}
}
const char *removeAvahiGroup(AvahiThreadedPoll *threaded_poll, AvahiEntryGroup *group) {
int error = avahi_entry_group_free(group);
if (AVAHI_OK != error) {
return avahi_strerror(error);
}
return NULL;
}
void dns_service_publisher_cleanup( void )
{
if( group )
{
avahi_entry_group_free( group );
group = NULL;
}
if( client)
{
avahi_client_free( client );
client = NULL;
}
if( threaded_poll )
{
avahi_threaded_poll_free( threaded_poll );
threaded_poll = NULL;
}
if( sd_name_copy )
{
avahi_free( sd_name_copy );
sd_name_copy = NULL;
}
if( sd_service_copy )
{
avahi_free( sd_service_copy );
sd_service_copy = NULL;
}
}
static void
dmap_mdns_publisher_finalize (GObject * object)
{
DMAPMdnsPublisher *publisher;
g_return_if_fail (object != NULL);
g_return_if_fail (IS_DMAP_MDNS_PUBLISHER (object));
publisher = DMAP_MDNS_PUBLISHER (object);
g_return_if_fail (publisher->priv != NULL);
if (publisher->priv->entry_group) {
avahi_entry_group_free (publisher->priv->entry_group);
publisher->priv->entry_group = NULL;
}
/* FIXME: dmap_mdns_avahi_get_client() ensures that a client is initialized only
* once during the lifetime of a program. This needs to be changed so that the
* following call works. Otherwise, an application like Rhythmbox will crash if
* a user deactivates and then activates the DAAP plugin. In this case,
* publisher->priv->client will be free'd but will not be allocated in a
* successive call to dmap_mdns_avahi_get_client().
*
* avahi_client_free (publisher->priv->client);
*/
g_slist_foreach (publisher->priv->service, (GFunc) free_service,
NULL);
g_slist_free (publisher->priv->service);
publisher_object = NULL;
G_OBJECT_CLASS (dmap_mdns_publisher_parent_class)->finalize (object);
}
static void
dnssdDeregisterInstance(
cupsd_srv_t *srv, /* I - Service */
int from_callback) /* I - Called from callback? */
{
if (!srv || !*srv)
return;
# ifdef HAVE_DNSSD
(void)from_callback;
DNSServiceRefDeallocate(*srv);
# else /* HAVE_AVAHI */
if (!from_callback)
avahi_threaded_poll_lock(DNSSDMaster);
avahi_entry_group_free(*srv);
if (!from_callback)
avahi_threaded_poll_unlock(DNSSDMaster);
# endif /* HAVE_DNSSD */
*srv = NULL;
}
static void client_callback(AvahiClient *c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata) {
Config *config = userdata;
client = c;
switch (state) {
case AVAHI_CLIENT_FAILURE:
if (config->no_fail && avahi_client_errno(c) == AVAHI_ERR_DISCONNECTED) {
int error;
/* We have been disconnected, so let reconnect */
fprintf(stderr, "Disconnected, reconnecting ...\n");
avahi_client_free(client);
client = NULL;
entry_group = NULL;
if (!(client = avahi_client_new(avahi_simple_poll_get(simple_poll), AVAHI_CLIENT_NO_FAIL, client_callback, config, &error))) {
fprintf(stderr, "Failed to create client object: %s\n", avahi_strerror(error));
avahi_simple_poll_quit(simple_poll);
}
} else {
fprintf(stderr, "Client failure, exiting: %s\n", avahi_strerror(avahi_client_errno(c)));
avahi_simple_poll_quit(simple_poll);
}
break;
case AVAHI_CLIENT_S_RUNNING:
if (register_stuff(config) < 0)
avahi_simple_poll_quit(simple_poll);
break;
case AVAHI_CLIENT_S_COLLISION:
if (config->verbose)
fprintf(stderr, "Host name conflict\n");
if (entry_group) {
avahi_entry_group_free(entry_group);
entry_group = NULL;
}
break;
case AVAHI_CLIENT_CONNECTING:
if (config->verbose)
fprintf(stderr, "Waiting for daemon ...\n");
break;
case AVAHI_CLIENT_S_REGISTERING:
;
}
}
void
dnssd_unregister()
{
if (g_options.dnssd_data->ipp_ref) {
avahi_entry_group_free(g_options.dnssd_data->ipp_ref);
g_options.dnssd_data->ipp_ref = NULL;
}
}
void
Avahi::PresencePublisher::remove_services ()
{
if (group != NULL) {
avahi_entry_group_free (group);
group = NULL;
}
}
static void
aur_avahi_finalize (GObject * object)
{
AurAvahi *avahi = (AurAvahi *) (object);
if (avahi->priv->group)
avahi_entry_group_free (avahi->priv->group);
if (avahi->priv->client)
avahi_client_free (avahi->priv->client);
avahi_glib_poll_free (avahi->priv->glib_poll);
}
static void service_free(struct service *s) {
pa_assert(s);
pa_hashmap_remove(s->userdata->services, s->device);
if (s->entry_group) {
pa_log_debug("Removing entry group for %s.", s->service_name);
avahi_entry_group_free(s->entry_group);
}
pa_xfree(s->service_name);
pa_xfree(s);
}
static void
epc_service_suspend (EpcService *self)
{
if (self->commit_handler)
{
g_source_remove (self->commit_handler);
self->commit_handler = 0;
}
if (self->group)
{
avahi_entry_group_free (self->group);
self->group = NULL;
}
}
/*
* 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);
}
void avahi_client_free(AvahiClient *client) {
assert(client);
if (client->bus)
/* Disconnect in advance, so that the free() functions won't
* issue needless server calls */
#ifdef HAVE_DBUS_CONNECTION_CLOSE
dbus_connection_close(client->bus);
#else
dbus_connection_disconnect(client->bus);
#endif
while (client->groups)
avahi_entry_group_free(client->groups);
while (client->domain_browsers)
avahi_domain_browser_free(client->domain_browsers);
while (client->service_browsers)
avahi_service_browser_free(client->service_browsers);
while (client->service_type_browsers)
avahi_service_type_browser_free(client->service_type_browsers);
while (client->service_resolvers)
avahi_service_resolver_free(client->service_resolvers);
while (client->host_name_resolvers)
avahi_host_name_resolver_free(client->host_name_resolvers);
while (client->address_resolvers)
avahi_address_resolver_free(client->address_resolvers);
while (client->record_browsers)
avahi_record_browser_free(client->record_browsers);
if (client->bus)
dbus_connection_unref(client->bus);
avahi_free(client->version_string);
avahi_free(client->host_name);
avahi_free(client->host_name_fqdn);
avahi_free(client->domain_name);
avahi_free(client);
}
JNIEXPORT jint JNICALL Java_avahi4j_EntryGroup_release(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;
// free avahi group
result = avahi_entry_group_free(group->group);
// delete global ref
(*e)->DeleteGlobalRef(e, group->groupObject);
// free avahi4j group struct
XFREE(group);
CHECK_N_RET(avahi_entry_group_release, result);
}
static void free_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_free(j->group);
j->group = NULL;
}
if (j->pool)
apr_pool_clear(j->pool);
j->chosen_name = NULL;
}
}
void pa__done(pa_module*m) {
struct userdata*u;
pa_assert(m);
if (!(u = m->userdata))
return;
if (u->services) {
struct service *s;
while ((s = pa_hashmap_first(u->services)))
service_free(s);
pa_hashmap_free(u->services, NULL, NULL);
}
if (u->sink_new_slot)
pa_hook_slot_free(u->sink_new_slot);
if (u->source_new_slot)
pa_hook_slot_free(u->source_new_slot);
if (u->sink_changed_slot)
pa_hook_slot_free(u->sink_changed_slot);
if (u->source_changed_slot)
pa_hook_slot_free(u->source_changed_slot);
if (u->sink_unlink_slot)
pa_hook_slot_free(u->sink_unlink_slot);
if (u->source_unlink_slot)
pa_hook_slot_free(u->source_unlink_slot);
if (u->main_entry_group)
avahi_entry_group_free(u->main_entry_group);
if (u->client)
avahi_client_free(u->client);
if (u->avahi_poll)
pa_avahi_poll_free(u->avahi_poll);
if (u->native)
pa_native_protocol_unref(u->native);
pa_xfree(u->service_name);
pa_xfree(u);
}
void CZeroconfAvahi::doStop()
{
ScopedEventLoopBlock l_block(mp_poll);
for(tServiceMap::const_iterator it = m_services.begin(); it != m_services.end(); ++it)
{
if (it->second->mp_group)
{
avahi_entry_group_free(it->second->mp_group);
it->second->mp_group = 0;
}
if(it->second->mp_txt)
{
avahi_string_list_free(it->second->mp_txt);
it->second->mp_txt = NULL;
}
}
m_services.clear();
}
static void avahi_client_reset_all()
{
for (AvahiServiceEntryList::iterator it = avahi_services.begin();
it != avahi_services.end(); ++it)
{
if (it->group)
{
avahi_entry_group_free(it->group);
it->group = NULL;
}
}
for (AvahiBrowserEntryList::iterator it = avahi_browsers.begin();
it != avahi_browsers.end(); ++it)
{
if (it->browser)
{
avahi_service_browser_free(it->browser);
it->browser = NULL;
}
}
}
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;
}
gboolean _mdns_set_buddy_icon_data(BonjourDnsSd *data, gconstpointer avatar_data, gsize avatar_len) {
AvahiSessionImplData *idata = data->mdns_impl_data;
if (idata == NULL || idata->client == NULL)
return FALSE;
if (avatar_data != NULL) {
gboolean new_group = FALSE;
gchar *svc_name;
int ret;
AvahiPublishFlags flags = 0;
if (idata->buddy_icon_group == NULL) {
purple_debug_info("bonjour", "Setting new buddy icon.\n");
new_group = TRUE;
idata->buddy_icon_group = avahi_entry_group_new(idata->client,
_buddy_icon_group_cb, data);
} else {
purple_debug_info("bonjour", "Updating existing buddy icon.\n");
flags |= AVAHI_PUBLISH_UPDATE;
}
if (idata->buddy_icon_group == NULL) {
purple_debug_error("bonjour",
"Unable to initialize the buddy icon group (%s).\n",
avahi_strerror(avahi_client_errno(idata->client)));
return FALSE;
}
svc_name = g_strdup_printf("%s." ICHAT_SERVICE "local",
purple_account_get_username(data->account));
ret = avahi_entry_group_add_record(idata->buddy_icon_group, AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC, flags, svc_name,
AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_NULL, 120, avatar_data, avatar_len);
g_free(svc_name);
if (ret < 0) {
purple_debug_error("bonjour",
"Failed to register buddy icon. Error: %s\n", avahi_strerror(ret));
if (new_group) {
avahi_entry_group_free(idata->buddy_icon_group);
idata->buddy_icon_group = NULL;
}
return FALSE;
}
if (new_group && (ret = avahi_entry_group_commit(idata->buddy_icon_group)) < 0) {
purple_debug_error("bonjour",
"Failed to commit buddy icon group. Error: %s\n", avahi_strerror(ret));
if (new_group) {
avahi_entry_group_free(idata->buddy_icon_group);
idata->buddy_icon_group = NULL;
}
return FALSE;
}
} else if (idata->buddy_icon_group != NULL) {
purple_debug_info("bonjour", "Removing existing buddy icon.\n");
avahi_entry_group_free(idata->buddy_icon_group);
idata->buddy_icon_group = NULL;
}
return TRUE;
}
AvahiEntryGroup* avahi_entry_group_new (AvahiClient *client, AvahiEntryGroupCallback callback, void *userdata) {
AvahiEntryGroup *group = NULL;
DBusMessage *message = NULL, *reply = NULL;
DBusError error;
char *path;
int state;
assert(client);
dbus_error_init (&error);
if (!avahi_client_is_connected(client)) {
avahi_client_set_errno(client, AVAHI_ERR_BAD_STATE);
goto fail;
}
if (!(group = avahi_new(AvahiEntryGroup, 1))) {
avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
goto fail;
}
group->client = client;
group->callback = callback;
group->userdata = userdata;
group->state_valid = 0;
group->path = NULL;
AVAHI_LLIST_PREPEND(AvahiEntryGroup, groups, client->groups, group);
if (!(message = dbus_message_new_method_call(
AVAHI_DBUS_NAME,
AVAHI_DBUS_PATH_SERVER,
AVAHI_DBUS_INTERFACE_SERVER,
"EntryGroupNew"))) {
avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
goto fail;
}
if (!(reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error)) ||
dbus_error_is_set (&error)) {
avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
goto fail;
}
if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) ||
dbus_error_is_set (&error)) {
avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
goto fail;
}
if (!(group->path = avahi_strdup (path))) {
/* FIXME: We don't remove the object on the server side */
avahi_client_set_errno(client, AVAHI_ERR_NO_MEMORY);
goto fail;
}
if ((state = retrieve_state(group)) < 0) {
avahi_client_set_errno(client, state);
goto fail;
}
avahi_entry_group_set_state(group, (AvahiEntryGroupState) state);
dbus_message_unref(message);
dbus_message_unref(reply);
return group;
fail:
if (dbus_error_is_set(&error)) {
avahi_client_set_dbus_error(client, &error);
dbus_error_free(&error);
}
if (group)
avahi_entry_group_free(group);
if (message)
dbus_message_unref(message);
if (reply)
dbus_message_unref(reply);
return NULL;
}
void CZeroconfAvahi::groupCallback(AvahiEntryGroup *fp_group, AvahiEntryGroupState 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_ENTRY_GROUP_ESTABLISHED :
// The entry group has been established successfully
CLog::Log(LOGDEBUG, "CZeroconfAvahi::groupCallback: Service successfully established");
break;
case AVAHI_ENTRY_GROUP_COLLISION :
{
//need to find the ServiceInfo struct for this group
tServiceMap::iterator it = p_instance->m_services.begin();
for(; it != p_instance->m_services.end(); ++it)
{
if (it->second->mp_group == fp_group)
break;
}
if( it != p_instance->m_services.end() ) {
char* alt_name = avahi_alternative_service_name( it->second->m_name.c_str() );
it->second->m_name = alt_name;
avahi_free(alt_name);
CLog::Log(LOGNOTICE, "CZeroconfAvahi::groupCallback: Service name collision. Renamed to: %s", it->second->m_name.c_str());
p_instance->addService(it->second, p_instance->mp_client);
}
break;
}
case AVAHI_ENTRY_GROUP_FAILURE:
CLog::Log(LOGERROR, "CZeroconfAvahi::groupCallback: Entry group failure: %s ",
(fp_group) ?
avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(fp_group)))
: "Unknown");
//free the group and set to 0 so it may be added later
if (fp_group)
{
//need to find the ServiceInfo struct for this group
tServiceMap::iterator it = p_instance->m_services.begin();
for (; it != p_instance->m_services.end(); ++it)
{
if (it->second->mp_group == fp_group)
{
avahi_entry_group_free(it->second->mp_group);
it->second->mp_group = 0;
if (it->second->mp_txt)
{
avahi_string_list_free(it->second->mp_txt);
it->second->mp_txt = NULL;
}
break;
}
}
}
break;
case AVAHI_ENTRY_GROUP_UNCOMMITED:
case AVAHI_ENTRY_GROUP_REGISTERING:
default:
break;
}
}
static void create_service(struct service_data *j) {
apr_pool_t *t;
const char *n;
char *p;
struct runtime_data *r = j->runtime;
char **type, **txt_record;
AvahiStringList *strlist = NULL;
if (!j->group)
if (!(j->group = avahi_entry_group_new(r->client, service_callback, j))) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->main_server, "avahi_entry_group_new() failed: %s", avahi_strerror(avahi_client_errno(r->client)));
return;
}
ap_assert(j->group);
ap_assert(avahi_entry_group_is_empty(j->group));
apr_pool_create(&t, r->pool);
/* ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->main_server, "Service <%s>, host <%s>, port <%u>, location <%s>", j->name, j->host_name, j->port, j->location); */
if (j->chosen_name)
n = j->chosen_name;
else if (!j->name)
n = avahi_client_get_host_name(r->client);
else if (j->append_host_name)
n = apr_pstrcat(t, j->name, avahi_client_get_host_name(r->client), NULL);
else
n = j->name;
if (!j->pool)
apr_pool_create(&j->pool, r->pool);
if (n != j->chosen_name) {
apr_pool_clear(j->pool);
j->chosen_name = apr_pstrdup(j->pool, n);
}
p = j->location ? apr_pstrcat(t, "path=", j->location, NULL) : NULL;
/* ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->main_server, "%s, %s", p, n); */
txt_record = (char **) j->txt_record->elts;
for ( ; *txt_record ; txt_record++)
strlist = avahi_string_list_add(strlist, *txt_record);
if (p)
strlist = avahi_string_list_add(strlist, p);
if (apr_is_empty_array(j->types)) {
if (avahi_entry_group_add_service_strlst(
j->group,
AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC,
0,
n,
j->port == 443 ? "_https._tcp" : "_http._tcp",
NULL,
j->host_name,
j->port,
strlist) < 0) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->main_server, "avahi_entry_group_add_service_strlst(\"%s\") failed: %s", n, avahi_strerror(avahi_client_errno(r->client)));
}
const char * cnames = {j->host_name, NULL};
PublishAvahiCNames(cnames);
} else {
for (type = (char**) j->types->elts; *type; type++) {
if (avahi_entry_group_add_service_strlst(
j->group,
AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC,
0,
n,
*type,
NULL,
j->host_name,
j->port,
strlist) < 0) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->main_server, "avahi_entry_group_add_service_strlst(\"%s\") failed: %s", n, avahi_strerror(avahi_client_errno(r->client)));
}
const char * cnames = {j->host_name, NULL};
PublishAvahiCNames(cnames);
}
}
avahi_string_list_free(strlist);
if (avahi_entry_group_is_empty(j->group)) {
avahi_entry_group_free(j->group);
j->group = NULL;
} else
avahi_entry_group_commit(j->group);
apr_pool_destroy(t);
}
