Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
300 lines (270 sloc) 7.78 KB
/*
* Unix SMB/CIFS implementation.
* Register _smb._tcp with avahi
*
* Copyright (C) Volker Lendecke 2009
*
* 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/>.
*/
#include "includes.h"
#include "smbd/smbd.h"
#include <avahi-client/client.h>
#include <avahi-client/publish.h>
#include <avahi-common/error.h>
#include <avahi-common/malloc.h>
#include <avahi-common/strlst.h>
struct avahi_state_struct {
struct AvahiPoll *poll;
AvahiClient *client;
AvahiEntryGroup *entry_group;
uint16_t port;
};
static void *avahi_allocator_ctx = NULL;
static void * avahi_allocator_malloc(size_t size)
{
return talloc_size(avahi_allocator_ctx, size);
}
static void avahi_allocator_free(void *p)
{
TALLOC_FREE(p);
}
static void * avahi_allocator_realloc(void *p, size_t size)
{
return talloc_realloc_size(avahi_allocator_ctx, p, size);
}
static void * avahi_allocator_calloc(size_t count, size_t size)
{
void *p = talloc_array_size(avahi_allocator_ctx, size, count);
if (p) {
memset(p, 0, size * count);
}
return p;
}
static const struct AvahiAllocator avahi_talloc_allocator = {
&avahi_allocator_malloc,
&avahi_allocator_free,
&avahi_allocator_realloc,
&avahi_allocator_calloc
};
static void avahi_entry_group_callback(AvahiEntryGroup *g,
AvahiEntryGroupState status,
void *userdata)
{
struct avahi_state_struct *state = talloc_get_type_abort(
userdata, struct avahi_state_struct);
int error;
switch (status) {
case AVAHI_ENTRY_GROUP_ESTABLISHED:
DBG_DEBUG("AVAHI_ENTRY_GROUP_ESTABLISHED\n");
break;
case AVAHI_ENTRY_GROUP_FAILURE:
error = avahi_client_errno(state->client);
DBG_DEBUG("AVAHI_ENTRY_GROUP_FAILURE: %s\n",
avahi_strerror(error));
break;
case AVAHI_ENTRY_GROUP_COLLISION:
DBG_DEBUG("AVAHI_ENTRY_GROUP_COLLISION\n");
break;
case AVAHI_ENTRY_GROUP_UNCOMMITED:
DBG_DEBUG("AVAHI_ENTRY_GROUP_UNCOMMITED\n");
break;
case AVAHI_ENTRY_GROUP_REGISTERING:
DBG_DEBUG("AVAHI_ENTRY_GROUP_REGISTERING\n");
break;
}
}
static void avahi_client_callback(AvahiClient *c, AvahiClientState status,
void *userdata)
{
struct avahi_state_struct *state = talloc_get_type_abort(
userdata, struct avahi_state_struct);
int error;
switch (status) {
case AVAHI_CLIENT_S_RUNNING: {
int snum;
int num_services = lp_numservices();
size_t dk = 0;
AvahiStringList *adisk = NULL;
AvahiStringList *adisk2 = NULL;
AvahiStringList *dinfo = NULL;
const char *hostname = NULL;
enum mdns_name_values mdns_name = lp_mdns_name();
const char *model = NULL;
DBG_DEBUG("AVAHI_CLIENT_S_RUNNING\n");
switch (mdns_name) {
case MDNS_NAME_MDNS:
hostname = avahi_client_get_host_name(c);
break;
case MDNS_NAME_NETBIOS:
hostname = lp_netbios_name();
break;
default:
DBG_ERR("Unhandled mdns_name %d\n", mdns_name);
return;
}
state->entry_group = avahi_entry_group_new(
c, avahi_entry_group_callback, state);
if (state->entry_group == NULL) {
error = avahi_client_errno(c);
DBG_DEBUG("avahi_entry_group_new failed: %s\n",
avahi_strerror(error));
break;
}
error = avahi_entry_group_add_service(
state->entry_group, AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC, 0, hostname,
"_smb._tcp", NULL, NULL, state->port, NULL);
if (error != AVAHI_OK) {
DBG_DEBUG("avahi_entry_group_add_service failed: %s\n",
avahi_strerror(error));
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
for (snum = 0; snum < num_services; snum++) {
if (lp_snum_ok(snum) &&
lp_parm_bool(snum, "fruit", "time machine", false))
{
adisk2 = avahi_string_list_add_printf(
adisk, "dk%zu=adVN=%s,adVF=0x82",
dk++, lp_const_servicename(snum));
if (adisk2 == NULL) {
DBG_DEBUG("avahi_string_list_add_printf"
"failed: returned NULL\n");
avahi_string_list_free(adisk);
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
adisk = adisk2;
adisk2 = NULL;
}
}
if (dk > 0) {
adisk2 = avahi_string_list_add(adisk, "sys=adVF=0x100");
if (adisk2 == NULL) {
DBG_DEBUG("avahi_string_list_add failed: "
"returned NULL\n");
avahi_string_list_free(adisk);
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
adisk = adisk2;
adisk2 = NULL;
error = avahi_entry_group_add_service_strlst(
state->entry_group, AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC, 0, hostname,
"_adisk._tcp", NULL, NULL, 0, adisk);
avahi_string_list_free(adisk);
adisk = NULL;
if (error != AVAHI_OK) {
DBG_DEBUG("avahi_entry_group_add_service_strlst "
"failed: %s\n", avahi_strerror(error));
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
}
model = lp_parm_const_string(-1, "fruit", "model", "MacSamba");
dinfo = avahi_string_list_add_printf(NULL, "model=%s", model);
if (dinfo == NULL) {
DBG_DEBUG("avahi_string_list_add_printf"
"failed: returned NULL\n");
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
error = avahi_entry_group_add_service_strlst(
state->entry_group, AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC, 0, hostname,
"_device-info._tcp", NULL, NULL, 0,
dinfo);
avahi_string_list_free(dinfo);
if (error != AVAHI_OK) {
DBG_DEBUG("avahi_entry_group_add_service failed: %s\n",
avahi_strerror(error));
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
error = avahi_entry_group_commit(state->entry_group);
if (error != AVAHI_OK) {
DBG_DEBUG("avahi_entry_group_commit failed: %s\n",
avahi_strerror(error));
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
break;
}
case AVAHI_CLIENT_FAILURE:
error = avahi_client_errno(c);
DBG_DEBUG("AVAHI_CLIENT_FAILURE: %s\n", avahi_strerror(error));
if (error != AVAHI_ERR_DISCONNECTED) {
break;
}
avahi_client_free(c);
state->client = avahi_client_new(state->poll, AVAHI_CLIENT_NO_FAIL,
avahi_client_callback, state,
&error);
if (state->client == NULL) {
DBG_DEBUG("avahi_client_new failed: %s\n",
avahi_strerror(error));
break;
}
break;
case AVAHI_CLIENT_S_COLLISION:
DBG_DEBUG("AVAHI_CLIENT_S_COLLISION\n");
break;
case AVAHI_CLIENT_S_REGISTERING:
DBG_DEBUG("AVAHI_CLIENT_S_REGISTERING\n");
break;
case AVAHI_CLIENT_CONNECTING:
DBG_DEBUG("AVAHI_CLIENT_CONNECTING\n");
break;
}
}
void *avahi_start_register(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
uint16_t port)
{
struct avahi_state_struct *state;
int error;
avahi_allocator_ctx = talloc_new(mem_ctx);
if (avahi_allocator_ctx == NULL) {
return NULL;
}
avahi_set_allocator(&avahi_talloc_allocator);
state = talloc(mem_ctx, struct avahi_state_struct);
if (state == NULL) {
return state;
}
state->port = port;
state->poll = tevent_avahi_poll(state, ev);
if (state->poll == NULL) {
goto fail;
}
state->client = avahi_client_new(state->poll, AVAHI_CLIENT_NO_FAIL,
avahi_client_callback, state,
&error);
if (state->client == NULL) {
DBG_DEBUG("avahi_client_new failed: %s\n",
avahi_strerror(error));
goto fail;
}
return state;
fail:
TALLOC_FREE(state);
return NULL;
}
You can’t perform that action at this time.