+AvahiServer *avahi_server_new(const AvahiPoll *poll_api, const AvahiServerConfig *sc, AvahiServerCallback callback, void* userdata, int *error) {
+ AvahiServer *s;
+ int e;
+
+ if (sc && (e = valid_server_config(sc)) < 0) {
+ if (error)
+ *error = e;
+ return NULL;
+ }
+
+ if (!(s = avahi_new(AvahiServer, 1))) {
+ if (error)
+ *error = AVAHI_ERR_NO_MEMORY;
+
+ return NULL;
+ }
+
+ s->poll_api = poll_api;
+
+ if (sc)
+ avahi_server_config_copy(&s->config, sc);
+ else
+ avahi_server_config_init(&s->config);
+
+ if ((e = setup_sockets(s)) < 0) {
+ if (error)
+ *error = e;
+
+ avahi_server_config_free(&s->config);
+ avahi_free(s);
+
+ return NULL;
+ }
+
+ s->n_host_rr_pending = 0;
+ s->need_entry_cleanup = 0;
+ s->need_group_cleanup = 0;
+ s->need_browser_cleanup = 0;
+ s->cleanup_time_event = NULL;
+ s->hinfo_entry_group = NULL;
+ s->browse_domain_entry_group = NULL;
+ s->error = AVAHI_OK;
+ s->state = AVAHI_SERVER_INVALID;
+
+ s->callback = callback;
+ s->userdata = userdata;
+
+ s->time_event_queue = avahi_time_event_queue_new(poll_api);
+
+ s->entries_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, NULL, NULL);
+ AVAHI_LLIST_HEAD_INIT(AvahiEntry, s->entries);
+ AVAHI_LLIST_HEAD_INIT(AvahiGroup, s->groups);
+
+ s->record_browser_hashmap = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, NULL, NULL);
+ AVAHI_LLIST_HEAD_INIT(AvahiSRecordBrowser, s->record_browsers);
+ AVAHI_LLIST_HEAD_INIT(AvahiSHostNameResolver, s->host_name_resolvers);
+ AVAHI_LLIST_HEAD_INIT(AvahiSAddressResolver, s->address_resolvers);
+ AVAHI_LLIST_HEAD_INIT(AvahiSDomainBrowser, s->domain_browsers);
+ AVAHI_LLIST_HEAD_INIT(AvahiSServiceTypeBrowser, s->service_type_browsers);
+ AVAHI_LLIST_HEAD_INIT(AvahiSServiceBrowser, s->service_browsers);
+ AVAHI_LLIST_HEAD_INIT(AvahiSServiceResolver, s->service_resolvers);
+ AVAHI_LLIST_HEAD_INIT(AvahiSDNSServerBrowser, s->dns_server_browsers);
+
+ s->legacy_unicast_reflect_slots = NULL;
+ s->legacy_unicast_reflect_id = 0;
+
+ s->record_list = avahi_record_list_new();
+
+ /* Get host name */
+ s->host_name = s->config.host_name ? avahi_normalize_name_strdup(s->config.host_name) : avahi_get_host_name_strdup();
+ s->host_name[strcspn(s->host_name, ".")] = 0;
+ s->domain_name = s->config.domain_name ? avahi_normalize_name_strdup(s->config.domain_name) : avahi_strdup("local");
+ s->host_name_fqdn = NULL;
+ update_fqdn(s);
+
+ do {
+ s->local_service_cookie = (uint32_t) rand() * (uint32_t) rand();
+ } while (s->local_service_cookie == AVAHI_SERVICE_COOKIE_INVALID);
+
+ if (s->config.enable_wide_area) {
+ s->wide_area_lookup_engine = avahi_wide_area_engine_new(s);
+ avahi_wide_area_set_servers(s->wide_area_lookup_engine, s->config.wide_area_servers, s->config.n_wide_area_servers);
+ } else
+ s->wide_area_lookup_engine = NULL;
+
+ s->multicast_lookup_engine = avahi_multicast_lookup_engine_new(s);
+
+ s->monitor = avahi_interface_monitor_new(s);
+ avahi_interface_monitor_sync(s->monitor);
+
+ register_localhost(s);
+ register_stuff(s);
+
+ return s;
+}
+
+void avahi_server_free(AvahiServer* s) {
+ assert(s);
+
+ /* Remove all browsers */
+
+ while (s->dns_server_browsers)
+ avahi_s_dns_server_browser_free(s->dns_server_browsers);
+ while (s->host_name_resolvers)
+ avahi_s_host_name_resolver_free(s->host_name_resolvers);
+ while (s->address_resolvers)
+ avahi_s_address_resolver_free(s->address_resolvers);
+ while (s->domain_browsers)
+ avahi_s_domain_browser_free(s->domain_browsers);
+ while (s->service_type_browsers)
+ avahi_s_service_type_browser_free(s->service_type_browsers);
+ while (s->service_browsers)
+ avahi_s_service_browser_free(s->service_browsers);
+ while (s->service_resolvers)
+ avahi_s_service_resolver_free(s->service_resolvers);
+ while (s->record_browsers)
+ avahi_s_record_browser_destroy(s->record_browsers);
+
+ /* Remove all locally rgeistered stuff */
+
+ while(s->entries)
+ avahi_entry_free(s, s->entries);
+
+ avahi_interface_monitor_free(s->monitor);
+
+ while (s->groups)
+ avahi_entry_group_free(s, s->groups);
+
+ free_slots(s);
+
+ avahi_hashmap_free(s->entries_by_key);
+ avahi_record_list_free(s->record_list);
+ avahi_hashmap_free(s->record_browser_hashmap);
+
+ if (s->wide_area_lookup_engine)
+ avahi_wide_area_engine_free(s->wide_area_lookup_engine);
+ avahi_multicast_lookup_engine_free(s->multicast_lookup_engine);
+
+ if (s->cleanup_time_event)
+ avahi_time_event_free(s->cleanup_time_event);
+
+ avahi_time_event_queue_free(s->time_event_queue);
+
+ /* Free watches */
+
+ if (s->watch_ipv4)
+ s->poll_api->watch_free(s->watch_ipv4);
+ if (s->watch_ipv6)
+ s->poll_api->watch_free(s->watch_ipv6);
+
+ if (s->watch_legacy_unicast_ipv4)
+ s->poll_api->watch_free(s->watch_legacy_unicast_ipv4);
+ if (s->watch_legacy_unicast_ipv6)
+ s->poll_api->watch_free(s->watch_legacy_unicast_ipv6);
+
+ /* Free sockets */
+
+ if (s->fd_ipv4 >= 0)
+ close(s->fd_ipv4);
+ if (s->fd_ipv6 >= 0)
+ close(s->fd_ipv6);
+
+ if (s->fd_legacy_unicast_ipv4 >= 0)
+ close(s->fd_legacy_unicast_ipv4);
+ if (s->fd_legacy_unicast_ipv6 >= 0)
+ close(s->fd_legacy_unicast_ipv6);
+
+ /* Free other stuff */
+
+ avahi_free(s->host_name);
+ avahi_free(s->domain_name);
+ avahi_free(s->host_name_fqdn);
+
+ avahi_server_config_free(&s->config);
+
+ avahi_free(s);
+}
+
+const char* avahi_server_get_domain_name(AvahiServer *s) {
+ assert(s);
+
+ return s->domain_name;
+}
+
+const char* avahi_server_get_host_name(AvahiServer *s) {
+ assert(s);
+
+ return s->host_name;
+}
+
+const char* avahi_server_get_host_name_fqdn(AvahiServer *s) {
+ assert(s);
+
+ return s->host_name_fqdn;
+}
+
+void* avahi_server_get_data(AvahiServer *s) {
+ assert(s);
+
+ return s->userdata;
+}
+
+void avahi_server_set_data(AvahiServer *s, void* userdata) {
+ assert(s);
+
+ s->userdata = userdata;
+}
+
+AvahiServerState avahi_server_get_state(AvahiServer *s) {
+ assert(s);
+
+ return s->state;
+}
+
+AvahiServerConfig* avahi_server_config_init(AvahiServerConfig *c) {
+ assert(c);
+
+ memset(c, 0, sizeof(AvahiServerConfig));
+ c->use_ipv6 = 1;
+ c->use_ipv4 = 1;
+ c->allow_interfaces = NULL;
+ c->deny_interfaces = NULL;
+ c->host_name = NULL;
+ c->domain_name = NULL;
+ c->check_response_ttl = 0;
+ c->publish_hinfo = 1;
+ c->publish_addresses = 1;
+ c->publish_workstation = 1;
+ c->publish_domain = 1;
+ c->use_iff_running = 0;
+ c->enable_reflector = 0;
+ c->reflect_ipv = 0;
+ c->add_service_cookie = 0;
+ c->enable_wide_area = 0;
+ c->n_wide_area_servers = 0;
+ c->disallow_other_stacks = 0;
+ c->browse_domains = NULL;
+ c->disable_publishing = 0;
+ c->allow_point_to_point = 0;
+ c->publish_aaaa_on_ipv4 = 1;
+ c->publish_a_on_ipv6 = 0;
+ c->n_cache_entries_max = AVAHI_DEFAULT_CACHE_ENTRIES_MAX;
+ c->ratelimit_interval = 0;
+ c->ratelimit_burst = 0;
+
+ return c;
+}
+
+void avahi_server_config_free(AvahiServerConfig *c) {
+ assert(c);
+
+ avahi_free(c->host_name);
+ avahi_free(c->domain_name);
+ avahi_string_list_free(c->browse_domains);
+ avahi_string_list_free(c->allow_interfaces);
+ avahi_string_list_free(c->deny_interfaces);
+}
+
+AvahiServerConfig* avahi_server_config_copy(AvahiServerConfig *ret, const AvahiServerConfig *c) {
+ char *d = NULL, *h = NULL;
+ AvahiStringList *browse = NULL, *allow = NULL, *deny = NULL;
+ assert(ret);
+ assert(c);
+
+ if (c->host_name)
+ if (!(h = avahi_strdup(c->host_name)))
+ return NULL;
+
+ if (c->domain_name)
+ if (!(d = avahi_strdup(c->domain_name))) {
+ avahi_free(h);
+ return NULL;
+ }
+
+ if (!(browse = avahi_string_list_copy(c->browse_domains)) && c->browse_domains) {
+ avahi_free(h);
+ avahi_free(d);
+ return NULL;
+ }
+
+ if (!(allow = avahi_string_list_copy(c->allow_interfaces)) && c->allow_interfaces) {
+ avahi_string_list_free(browse);
+ avahi_free(h);
+ avahi_free(d);
+ return NULL;
+ }
+
+ if (!(deny = avahi_string_list_copy(c->deny_interfaces)) && c->deny_interfaces) {
+ avahi_string_list_free(allow);
+ avahi_string_list_free(browse);
+ avahi_free(h);
+ avahi_free(d);
+ return NULL;
+ }
+
+ *ret = *c;
+ ret->host_name = h;
+ ret->domain_name = d;
+ ret->browse_domains = browse;
+ ret->allow_interfaces = allow;
+ ret->deny_interfaces = deny;
+
+ return ret;
+}
+
+int avahi_server_errno(AvahiServer *s) {
+ assert(s);
+
+ return s->error;
+}
+
+/* Just for internal use */
+int avahi_server_set_errno(AvahiServer *s, int error) {
+ assert(s);
+
+ return s->error = error;
+}
+
+uint32_t avahi_server_get_local_service_cookie(AvahiServer *s) {
+ assert(s);
+
+ return s->local_service_cookie;
+}
+
+static AvahiEntry *find_entry(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiKey *key) {
+ AvahiEntry *e;
+
+ assert(s);
+ assert(key);
+
+ for (e = avahi_hashmap_lookup(s->entries_by_key, key); e; e = e->by_key_next)
+
+ if ((e->interface == interface || e->interface <= 0 || interface <= 0) &&
+ (e->protocol == protocol || e->protocol == AVAHI_PROTO_UNSPEC || protocol == AVAHI_PROTO_UNSPEC) &&
+ (!e->group || e->group->state == AVAHI_ENTRY_GROUP_ESTABLISHED || e->group->state == AVAHI_ENTRY_GROUP_REGISTERING))
+
+ return e;
+
+ return NULL;
+}
+
+int avahi_server_get_group_of_service(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, const char *name, const char *type, const char *domain, AvahiSEntryGroup** ret_group) {
+ AvahiKey *key = NULL;
+ AvahiEntry *e;
+ int ret;
+ char n[AVAHI_DOMAIN_NAME_MAX];
+
+ assert(s);
+ assert(name);
+ assert(type);
+ assert(ret_group);
+
+ AVAHI_CHECK_VALIDITY(s, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
+ AVAHI_CHECK_VALIDITY(s, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
+ AVAHI_CHECK_VALIDITY(s, avahi_is_valid_service_name(name), AVAHI_ERR_INVALID_SERVICE_NAME);
+ AVAHI_CHECK_VALIDITY(s, avahi_is_valid_service_type_strict(type), AVAHI_ERR_INVALID_SERVICE_TYPE);
+ AVAHI_CHECK_VALIDITY(s, !domain || avahi_is_valid_domain_name(domain), AVAHI_ERR_INVALID_DOMAIN_NAME);
+
+ if ((ret = avahi_service_name_join(n, sizeof(n), name, type, domain) < 0))
+ return avahi_server_set_errno(s, ret);
+
+ if (!(key = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV)))
+ return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
+
+ e = find_entry(s, interface, protocol, key);
+ avahi_key_unref(key);
+
+ if (e) {
+ *ret_group = e->group;
+ return AVAHI_OK;
+ }
+
+ return avahi_server_set_errno(s, AVAHI_ERR_NOT_FOUND);
+}
+
+int avahi_server_is_service_local(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, const char *name) {
+ AvahiKey *key = NULL;
+ AvahiEntry *e;
+
+ assert(s);
+ assert(name);
+
+ if (!s->host_name_fqdn)
+ return 0;
+
+ if (!(key = avahi_key_new(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV)))
+ return 0;
+
+ e = find_entry(s, interface, protocol, key);
+ avahi_key_unref(key);
+
+ if (!e)
+ return 0;
+
+ return avahi_domain_equal(s->host_name_fqdn, e->record->data.srv.name);
+}
+
+int avahi_server_is_record_local(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *record) {
+ AvahiEntry *e;
+
+ assert(s);
+ assert(record);
+
+ for (e = avahi_hashmap_lookup(s->entries_by_key, record->key); e; e = e->by_key_next)
+
+ if ((e->interface == interface || e->interface <= 0 || interface <= 0) &&
+ (e->protocol == protocol || e->protocol == AVAHI_PROTO_UNSPEC || protocol == AVAHI_PROTO_UNSPEC) &&
+ (!e->group || e->group->state == AVAHI_ENTRY_GROUP_ESTABLISHED || e->group->state == AVAHI_ENTRY_GROUP_REGISTERING) &&
+ avahi_record_equal_no_ttl(record, e->record))
+ return 1;
+
+ return 0;
+}
+
+/** Set the wide area DNS servers */
+int avahi_server_set_wide_area_servers(AvahiServer *s, const AvahiAddress *a, unsigned n) {
+ assert(s);
+
+ if (!s->wide_area_lookup_engine)
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_CONFIG);
+
+ avahi_wide_area_set_servers(s->wide_area_lookup_engine, a, n);
+ return AVAHI_OK;
+}
+
+const AvahiServerConfig* avahi_server_get_config(AvahiServer *s) {
+ assert(s);
+
+ return &s->config;
+}
+
+/** Set the browsing domains */
+int avahi_server_set_browse_domains(AvahiServer *s, AvahiStringList *domains) {
+ AvahiStringList *l;
+
+ assert(s);
+
+ for (l = s->config.browse_domains; l; l = l->next)
+ if (!avahi_is_valid_domain_name((char*) l->text))
+ return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME);
+
+ avahi_string_list_free(s->config.browse_domains);
+ s->config.browse_domains = avahi_string_list_copy(domains);