source3/client/dnsbrowse.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    DNS-SD browse client
   4    Copyright (C) Rishi Srivatsavai 2007
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "client/client_proto.h"
  22
  23 #ifdef WITH_DNSSD_SUPPORT
  24
  25 #include <dns_sd.h>
  26 #include "system/select.h"
  27
  28 /* Holds service instances found during DNS browse */
  29 struct mdns_smbsrv_result
  30 {
  31         char *serviceName;
  32         char *regType;
  33         char *domain;
  34         uint32_t ifIndex;
  35         struct mdns_smbsrv_result *nextResult;
  36 };
  37
  38 /* Maintains state during DNS browse */
  39 struct mdns_browse_state
  40 {
  41         struct mdns_smbsrv_result *listhead; /* Browse result list head */
  42         int browseDone;
  43
  44 };
  45
  46
  47 static void
  48 do_smb_resolve_reply (DNSServiceRef sdRef, DNSServiceFlags flags,
  49                 uint32_t interfaceIndex, DNSServiceErrorType errorCode,
  50                 const char *fullname, const char *hosttarget, uint16_t port,
  51                 uint16_t txtLen, const unsigned char *txtRecord, void *context)
  52 {
  53         printf("SMB service available on %s port %u\n",
  54                 hosttarget, ntohs(port));
  55 }
  56
  57
  58 static void do_smb_resolve(struct mdns_smbsrv_result *browsesrv)
  59 {
  60         DNSServiceRef mdns_conn_sdref = NULL;
  61         int mdnsfd;
  62         int fdsetsz;
  63         int ret;
  64         fd_set *fdset = NULL;
  65         struct timeval tv;
  66         DNSServiceErrorType err;
  67
  68         TALLOC_CTX * ctx = talloc_tos();
  69
  70         err = DNSServiceResolve(&mdns_conn_sdref, 0 /* flags */,
  71                 browsesrv->ifIndex,
  72                 browsesrv->serviceName, browsesrv->regType, browsesrv->domain,
  73                 do_smb_resolve_reply, NULL);
  74
  75         if (err != kDNSServiceErr_NoError) {
  76                 return;
  77         }
  78
  79         mdnsfd = DNSServiceRefSockFD(mdns_conn_sdref);
  80         for (;;)  {
  81                 if (fdset != NULL) {
  82                         TALLOC_FREE(fdset);
  83                 }
  84
  85                 fdsetsz = howmany(mdnsfd + 1, NFDBITS) * sizeof(fd_mask);
  86                 fdset = TALLOC_ZERO(ctx, fdsetsz);
  87                 FD_SET(mdnsfd, fdset);
  88
  89                 tv.tv_sec = 1;
  90                 tv.tv_usec = 0;
  91
  92                 /* Wait until response received from mDNS daemon */
  93                 ret = sys_select(mdnsfd + 1, fdset, NULL, NULL, &tv);
  94                 if (ret <= 0 && errno != EINTR) {
  95                         break;
  96                 }
  97
  98                 if (FD_ISSET(mdnsfd, fdset)) {
  99                         /* Invoke callback function */
 100                         DNSServiceProcessResult(mdns_conn_sdref);
 101                         break;
 102                 }
 103         }
 104
 105         TALLOC_FREE(fdset);
 106         DNSServiceRefDeallocate(mdns_conn_sdref);
 107 }
 108
 109
 110 static void
 111 do_smb_browse_reply(DNSServiceRef sdRef, DNSServiceFlags flags,
 112         uint32_t interfaceIndex, DNSServiceErrorType errorCode,
 113         const char  *serviceName, const char *regtype,
 114         const char  *replyDomain, void  *context)
 115 {
 116         struct mdns_browse_state *bstatep = (struct mdns_browse_state *)context;
 117         struct mdns_smbsrv_result *bresult;
 118
 119         if (bstatep == NULL) {
 120                 return;
 121         }
 122
 123         if (errorCode != kDNSServiceErr_NoError) {
 124                 bstatep->browseDone = 1;
 125                 return;
 126         }
 127
 128         if (flags & kDNSServiceFlagsMoreComing) {
 129                 bstatep->browseDone = 0;
 130         } else {
 131                 bstatep->browseDone = 1;
 132         }
 133
 134         if (!(flags & kDNSServiceFlagsAdd)) {
 135                 return;
 136         }
 137
 138         bresult = TALLOC_ARRAY(talloc_tos(), struct mdns_smbsrv_result, 1);
 139         if (bresult == NULL) {
 140                 return;
 141         }
 142
 143         if (bstatep->listhead != NULL) {
 144                 bresult->nextResult = bstatep->listhead;
 145         }
 146
 147         bresult->serviceName = talloc_strdup(talloc_tos(), serviceName);
 148         bresult->regType = talloc_strdup(talloc_tos(), regtype);
 149         bresult->domain = talloc_strdup(talloc_tos(), replyDomain);
 150         bresult->ifIndex = interfaceIndex;
 151         bstatep->listhead = bresult;
 152 }
 153
 154 int do_smb_browse(void)
 155 {
 156         int mdnsfd;
 157         int fdsetsz;
 158         int ret;
 159         struct mdns_browse_state bstate;
 160         struct mdns_smbsrv_result *resptr;
 161         struct timeval tv;
 162         DNSServiceRef mdns_conn_sdref = NULL;
 163         DNSServiceErrorType err;
 164
 165         TALLOC_CTX * ctx = talloc_stackframe();
 166
 167         ZERO_STRUCT(bstate);
 168
 169         err = DNSServiceBrowse(&mdns_conn_sdref, 0, 0, "_smb._tcp", "",
 170                         do_smb_browse_reply, &bstate);
 171
 172         if (err != kDNSServiceErr_NoError) {
 173                 d_printf("Error connecting to the Multicast DNS daemon\n");
 174                 TALLOC_FREE(ctx);
 175                 return 1;
 176         }
 177
 178         mdnsfd = DNSServiceRefSockFD(mdns_conn_sdref);
 179         for (;;)  {
 180                 int revents;
 181
 182                 ret = poll_one_fd(mdnsfd, POLLIN|POLLHUP, &revents, 1000);
 183                 if (ret <= 0 && errno != EINTR) {
 184                         break;
 185                 }
 186
 187                 if (revents & (POLLIN|POLLHUP|POLLERR)) {
 188                         /* Invoke callback function */
 189                         if (DNSServiceProcessResult(mdns_conn_sdref)) {
 190                                 break;
 191                         }
 192                         if (bstate.browseDone) {
 193                                 break;
 194                         }
 195                 }
 196         }
 197
 198         DNSServiceRefDeallocate(mdns_conn_sdref);
 199
 200         if (bstate.listhead != NULL) {
 201                 resptr = bstate.listhead;
 202                 while (resptr != NULL) {
 203                         struct mdns_smbsrv_result *oldresptr;
 204                         oldresptr = resptr;
 205
 206                         /* Resolve smb service instance */
 207                         do_smb_resolve(resptr);
 208
 209                         resptr = resptr->nextResult;
 210                 }
 211         }
 212
 213         TALLOC_FREE(ctx);
 214         return 0;
 215 }
 216
 217 #else /* WITH_DNSSD_SUPPORT */
 218
 219 int do_smb_browse(void)
 220 {
 221     d_printf("DNS-SD browsing is not supported on this platform\n");
 222     return 1;
 223 }
 224
 225 #endif /* WITH_DNSSD_SUPPORT */
 226
 227