git.samba.org / nivanova / samba-autobuild / .git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
s3/smbd: update some more DEBUG macros in smbd_smb2_create_send
[nivanova/samba-autobuild/.git] / source3 / smbd / avahi_register.c
diff --git a/source3/smbd/avahi_register.c b/source3/smbd/avahi_register.c
index 1903b0ef9642bfc39b6b45526d5290aa0d363f81..91e8a439b84cb4dd4d46f1f920ee433184d18df4 100644 (file)
--- a/source3/smbd/avahi_register.c
+++ b/source3/smbd/avahi_register.c
@@ -19,10 +19,13 @@
  */
 
 #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;
@@ -31,6 +34,39 @@ struct avahi_state_struct {
        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)
@@ -41,27 +77,22 @@ static void avahi_entry_group_callback(AvahiEntryGroup *g,
 
        switch (status) {
        case AVAHI_ENTRY_GROUP_ESTABLISHED:
-               DEBUG(10, ("avahi_entry_group_callback: "
-                          "AVAHI_ENTRY_GROUP_ESTABLISHED\n"));
+               DBG_DEBUG("AVAHI_ENTRY_GROUP_ESTABLISHED\n");
                break;
        case AVAHI_ENTRY_GROUP_FAILURE:
                error = avahi_client_errno(state->client);
 
-               DEBUG(10, ("avahi_entry_group_callback: "
-                          "AVAHI_ENTRY_GROUP_FAILURE: %s\n",
-                          avahi_strerror(error)));
+               DBG_DEBUG("AVAHI_ENTRY_GROUP_FAILURE: %s\n",
+                         avahi_strerror(error));
                break;
        case AVAHI_ENTRY_GROUP_COLLISION:
-               DEBUG(10, ("avahi_entry_group_callback: "
-                          "AVAHI_ENTRY_GROUP_COLLISION\n"));
+               DBG_DEBUG("AVAHI_ENTRY_GROUP_COLLISION\n");
                break;
        case AVAHI_ENTRY_GROUP_UNCOMMITED:
-               DEBUG(10, ("avahi_entry_group_callback: "
-                           "AVAHI_ENTRY_GROUP_UNCOMMITED\n"));
+               DBG_DEBUG("AVAHI_ENTRY_GROUP_UNCOMMITED\n");
                break;
        case AVAHI_ENTRY_GROUP_REGISTERING:
-               DEBUG(10, ("avahi_entry_group_callback: "
-                           "AVAHI_ENTRY_GROUP_REGISTERING\n"));
+               DBG_DEBUG("AVAHI_ENTRY_GROUP_REGISTERING\n");
                break;
        }
 }
@@ -74,42 +105,97 @@ static void avahi_client_callback(AvahiClient *c, AvahiClientState status,
        int error;
 
        switch (status) {
-       case AVAHI_CLIENT_S_RUNNING:
-               DEBUG(10, ("avahi_client_callback: AVAHI_CLIENT_S_RUNNING\n"));
+       case AVAHI_CLIENT_S_RUNNING: {
+               int snum;
+               int num_services = lp_numservices();
+               int dk = 0;
+               AvahiStringList *adisk = NULL;
+               AvahiStringList *adisk2 = NULL;
+
+               DBG_DEBUG("AVAHI_CLIENT_S_RUNNING\n");
 
                state->entry_group = avahi_entry_group_new(
                        c, avahi_entry_group_callback, state);
                if (state->entry_group == NULL) {
                        error = avahi_client_errno(c);
-                       DEBUG(10, ("avahi_entry_group_new failed: %s\n",
-                                  avahi_strerror(error)));
+                       DBG_DEBUG("avahi_entry_group_new failed: %s\n",
+                                 avahi_strerror(error));
                        break;
                }
-               if (avahi_entry_group_add_service(
+
+               error = avahi_entry_group_add_service(
                            state->entry_group, AVAHI_IF_UNSPEC,
-                           AVAHI_PROTO_UNSPEC, 0, global_myname(),
-                           "_smb._tcp", NULL, NULL, state->port, NULL) < 0) {
-                       error = avahi_client_errno(c);
-                       DEBUG(10, ("avahi_entry_group_add_service failed: "
-                                  "%s\n", avahi_strerror(error)));
+                           AVAHI_PROTO_UNSPEC, 0, lp_netbios_name(),
+                           "_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;
                }
-               if (avahi_entry_group_commit(state->entry_group) < 0) {
-                       error = avahi_client_errno(c);
-                       DEBUG(10, ("avahi_entry_group_commit failed: "
-                                  "%s\n", avahi_strerror(error)));
+
+               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%d=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, lp_netbios_name(),
+                                   "_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;
+                       }
+               }
+
+               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);
 
-               DEBUG(10, ("avahi_client_callback: AVAHI_CLIENT_FAILURE: %s\n",
-                          avahi_strerror(error)));
+               DBG_DEBUG("AVAHI_CLIENT_FAILURE: %s\n", avahi_strerror(error));
 
                if (error != AVAHI_ERR_DISCONNECTED) {
                        break;
@@ -119,22 +205,19 @@ static void avahi_client_callback(AvahiClient *c, AvahiClientState status,
                                                 avahi_client_callback, state,
                                                 &error);
                if (state->client == NULL) {
-                       DEBUG(10, ("avahi_client_new failed: %s\n",
-                                  avahi_strerror(error)));
+                       DBG_DEBUG("avahi_client_new failed: %s\n",
+                                 avahi_strerror(error));
                        break;
                }
                break;
        case AVAHI_CLIENT_S_COLLISION:
-               DEBUG(10, ("avahi_client_callback: "
-                          "AVAHI_CLIENT_S_COLLISION\n"));
+               DBG_DEBUG("AVAHI_CLIENT_S_COLLISION\n");
                break;
        case AVAHI_CLIENT_S_REGISTERING:
-               DEBUG(10, ("avahi_client_callback: "
-                          "AVAHI_CLIENT_S_REGISTERING\n"));
+               DBG_DEBUG("AVAHI_CLIENT_S_REGISTERING\n");
                break;
        case AVAHI_CLIENT_CONNECTING:
-               DEBUG(10, ("avahi_client_callback: "
-                          "AVAHI_CLIENT_CONNECTING\n"));
+               DBG_DEBUG("AVAHI_CLIENT_CONNECTING\n");
                break;
        }
 }
@@ -145,6 +228,12 @@ void *avahi_start_register(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
        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;
@@ -158,8 +247,8 @@ void *avahi_start_register(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                                         avahi_client_callback, state,
                                         &error);
        if (state->client == NULL) {
-               DEBUG(10, ("avahi_client_new failed: %s\n",
-                          avahi_strerror(error)));
+               DBG_DEBUG("avahi_client_new failed: %s\n",
+                         avahi_strerror(error));
                goto fail;
        }
        return state;
Unnamed repository; edit this file 'description' to name the repository.