server/MDnsSdListener.cpp

   1 /*
   2  * Copyright (C) 2010 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <arpa/inet.h>
  18 #include <dirent.h>
  19 #include <errno.h>
  20 #include <linux/if.h>
  21 #include <netdb.h>
  22 #include <netinet/in.h>
  23 #include <pthread.h>
  24 #include <stdlib.h>
  25 #include <sys/poll.h>
  26 #include <sys/socket.h>
  27 #include <sys/types.h>
  28 #include <string.h>
  29 #include <resolv.h>
  30
  31 #define LOG_TAG "MDnsDS"
  32 #define DBG 1
  33 #define VDBG 1
  34
  35 #include <cutils/log.h>
  36 #include <cutils/properties.h>
  37 #include <sysutils/SocketClient.h>
  38
  39 #include "MDnsSdListener.h"
  40 #include "ResponseCode.h"
  41
  42 #define MDNS_SERVICE_NAME "mdnsd"
  43 #define MDNS_SERVICE_STATUS "init.svc.mdnsd"
  44
  45 #define CEIL(x, y) (((x) + (y) - 1) / (y))
  46
  47 MDnsSdListener::MDnsSdListener() :
  48                  FrameworkListener("mdns", true) {
  49     Monitor *m = new Monitor();
  50     registerCmd(new Handler(m, this));
  51 }
  52
  53 MDnsSdListener::Handler::Handler(Monitor *m, MDnsSdListener *listener) :
  54    NetdCommand("mdnssd") {
  55    if (DBG) ALOGD("MDnsSdListener::Hander starting up");
  56    mMonitor = m;
  57    mListener = listener;
  58 }
  59
  60 MDnsSdListener::Handler::~Handler() {}
  61
  62 void MDnsSdListener::Handler::discover(SocketClient *cli,
  63         const char *iface,
  64         const char *regType,
  65         const char *domain,
  66         const int requestId,
  67         const int requestFlags) {
  68     if (VDBG) {
  69         ALOGD("discover(%s, %s, %s, %d, %d)", iface, regType, domain, requestId,
  70                 requestFlags);
  71     }
  72     Context *context = new Context(requestId, mListener);
  73     DNSServiceRef *ref = mMonitor->allocateServiceRef(requestId, context);
  74     if (ref == NULL) {
  75         ALOGE("requestId %d already in use during discover call", requestId);
  76         cli->sendMsg(ResponseCode::CommandParameterError,
  77                 "RequestId already in use during discover call", false);
  78         return;
  79     }
  80     if (VDBG) ALOGD("using ref %p", ref);
  81     DNSServiceFlags nativeFlags = iToFlags(requestFlags);
  82     int interfaceInt = ifaceNameToI(iface);
  83
  84     DNSServiceErrorType result = DNSServiceBrowse(ref, nativeFlags, interfaceInt, regType,
  85             domain, &MDnsSdListenerDiscoverCallback, context);
  86     if (result != kDNSServiceErr_NoError) {
  87         ALOGE("Discover request %d got an error from DNSServiceBrowse %d", requestId, result);
  88         mMonitor->freeServiceRef(requestId);
  89         cli->sendMsg(ResponseCode::CommandParameterError,
  90                 "Discover request got an error from DNSServiceBrowse", false);
  91         return;
  92     }
  93     mMonitor->startMonitoring(requestId);
  94     if (VDBG) ALOGD("discover successful");
  95     cli->sendMsg(ResponseCode::CommandOkay, "Discover operation started", false);
  96     return;
  97 }
  98
  99 void MDnsSdListenerDiscoverCallback(DNSServiceRef /* sdRef */, DNSServiceFlags flags,
 100         uint32_t /* interfaceIndex */, DNSServiceErrorType errorCode, const char *serviceName,
 101         const char *regType, const char *replyDomain, void *inContext) {
 102     MDnsSdListener::Context *context = reinterpret_cast<MDnsSdListener::Context *>(inContext);
 103     char *msg;
 104     int refNumber = context->mRefNumber;
 105
 106     if (errorCode != kDNSServiceErr_NoError) {
 107         asprintf(&msg, "%d %d", refNumber, errorCode);
 108         context->mListener->sendBroadcast(ResponseCode::ServiceDiscoveryFailed, msg, false);
 109         if (DBG) ALOGE("discover failure for %d, error= %d", refNumber, errorCode);
 110     } else {
 111         int respCode;
 112         char *quotedServiceName = SocketClient::quoteArg(serviceName);
 113         if (flags & kDNSServiceFlagsAdd) {
 114             if (VDBG) {
 115                 ALOGD("Discover found new serviceName %s, regType %s and domain %s for %d",
 116                         serviceName, regType, replyDomain, refNumber);
 117             }
 118             respCode = ResponseCode::ServiceDiscoveryServiceAdded;
 119         } else {
 120             if (VDBG) {
 121                 ALOGD("Discover lost serviceName %s, regType %s and domain %s for %d",
 122                         serviceName, regType, replyDomain, refNumber);
 123             }
 124             respCode = ResponseCode::ServiceDiscoveryServiceRemoved;
 125         }
 126         asprintf(&msg, "%d %s %s %s", refNumber, quotedServiceName, regType, replyDomain);
 127         free(quotedServiceName);
 128         context->mListener->sendBroadcast(respCode, msg, false);
 129     }
 130     free(msg);
 131 }
 132
 133 void MDnsSdListener::Handler::stop(SocketClient *cli, int argc, char **argv, const char *str) {
 134     if (argc != 3) {
 135         char *msg;
 136         asprintf(&msg, "Invalid number of arguments to %s", str);
 137         cli->sendMsg(ResponseCode::CommandParameterError, msg, false);
 138         free(msg);
 139         return;
 140     }
 141     int requestId = atoi(argv[2]);
 142     DNSServiceRef *ref = mMonitor->lookupServiceRef(requestId);
 143     if (ref == NULL) {
 144         if (DBG) ALOGE("%s stop used unknown requestId %d", str, requestId);
 145         cli->sendMsg(ResponseCode::CommandParameterError, "Unknown requestId", false);
 146         return;
 147     }
 148     if (VDBG) ALOGD("Stopping %s with ref %p", str, ref);
 149     DNSServiceRefDeallocate(*ref);
 150     mMonitor->freeServiceRef(requestId);
 151     char *msg;
 152     asprintf(&msg, "%s stopped", str);
 153     cli->sendMsg(ResponseCode::CommandOkay, msg, false);
 154     free(msg);
 155 }
 156
 157 void MDnsSdListener::Handler::serviceRegister(SocketClient *cli, int requestId,
 158         const char *interfaceName, const char *serviceName, const char *serviceType,
 159         const char *domain, const char *host, int port, int txtLen, void *txtRecord) {
 160     if (VDBG) {
 161         ALOGD("serviceRegister(%d, %s, %s, %s, %s, %s, %d, %d, <binary>)", requestId,
 162                 interfaceName, serviceName, serviceType, domain, host, port, txtLen);
 163     }
 164     Context *context = new Context(requestId, mListener);
 165     DNSServiceRef *ref = mMonitor->allocateServiceRef(requestId, context);
 166     port = htons(port);
 167     if (ref == NULL) {
 168         ALOGE("requestId %d already in use during register call", requestId);
 169         cli->sendMsg(ResponseCode::CommandParameterError,
 170                 "RequestId already in use during register call", false);
 171         return;
 172     }
 173     DNSServiceFlags nativeFlags = 0;
 174     int interfaceInt = ifaceNameToI(interfaceName);
 175     DNSServiceErrorType result = DNSServiceRegister(ref, interfaceInt, nativeFlags, serviceName,
 176             serviceType, domain, host, port, txtLen, txtRecord, &MDnsSdListenerRegisterCallback,
 177             context);
 178     if (result != kDNSServiceErr_NoError) {
 179         ALOGE("service register request %d got an error from DNSServiceRegister %d", requestId,
 180                 result);
 181         mMonitor->freeServiceRef(requestId);
 182         cli->sendMsg(ResponseCode::CommandParameterError,
 183                 "serviceRegister request got an error from DNSServiceRegister", false);
 184         return;
 185     }
 186     mMonitor->startMonitoring(requestId);
 187     if (VDBG) ALOGD("serviceRegister successful");
 188     cli->sendMsg(ResponseCode::CommandOkay, "serviceRegister started", false);
 189     return;
 190 }
 191
 192 void MDnsSdListenerRegisterCallback(DNSServiceRef /* sdRef */, DNSServiceFlags /* flags */,
 193         DNSServiceErrorType errorCode, const char *serviceName, const char * /* regType */,
 194         const char * /* domain */, void *inContext) {
 195     MDnsSdListener::Context *context = reinterpret_cast<MDnsSdListener::Context *>(inContext);
 196     char *msg;
 197     int refNumber = context->mRefNumber;
 198     if (errorCode != kDNSServiceErr_NoError) {
 199         asprintf(&msg, "%d %d", refNumber, errorCode);
 200         context->mListener->sendBroadcast(ResponseCode::ServiceRegistrationFailed, msg, false);
 201         if (DBG) ALOGE("register failure for %d, error= %d", refNumber, errorCode);
 202     } else {
 203         char *quotedServiceName = SocketClient::quoteArg(serviceName);
 204         asprintf(&msg, "%d %s", refNumber, quotedServiceName);
 205         free(quotedServiceName);
 206         context->mListener->sendBroadcast(ResponseCode::ServiceRegistrationSucceeded, msg, false);
 207         if (VDBG) ALOGD("register succeeded for %d as %s", refNumber, serviceName);
 208     }
 209     free(msg);
 210 }
 211
 212
 213 void MDnsSdListener::Handler::resolveService(SocketClient *cli, int requestId,
 214         const char *interfaceName, const char *serviceName, const char *regType,
 215         const char *domain) {
 216     if (VDBG) {
 217         ALOGD("resolveService(%d, %s, %s, %s, %s)", requestId, interfaceName,
 218                 serviceName, regType, domain);
 219     }
 220     Context *context = new Context(requestId, mListener);
 221     DNSServiceRef *ref = mMonitor->allocateServiceRef(requestId, context);
 222     if (ref == NULL) {
 223         ALOGE("request Id %d already in use during resolve call", requestId);
 224         cli->sendMsg(ResponseCode::CommandParameterError,
 225                 "RequestId already in use during resolve call", false);
 226         return;
 227     }
 228     DNSServiceFlags nativeFlags = 0;
 229     int interfaceInt = ifaceNameToI(interfaceName);
 230     DNSServiceErrorType result = DNSServiceResolve(ref, nativeFlags, interfaceInt, serviceName,
 231             regType, domain, &MDnsSdListenerResolveCallback, context);
 232     if (result != kDNSServiceErr_NoError) {
 233         ALOGE("service resolve request %d got an error from DNSServiceResolve %d", requestId,
 234                 result);
 235         mMonitor->freeServiceRef(requestId);
 236         cli->sendMsg(ResponseCode::CommandParameterError,
 237                 "resolveService got an error from DNSServiceResolve", false);
 238         return;
 239     }
 240     mMonitor->startMonitoring(requestId);
 241     if (VDBG) ALOGD("resolveService successful");
 242     cli->sendMsg(ResponseCode::CommandOkay, "resolveService started", false);
 243     return;
 244 }
 245
 246 void MDnsSdListenerResolveCallback(DNSServiceRef /* sdRef */, DNSServiceFlags /* flags */,
 247         uint32_t /* interface */, DNSServiceErrorType errorCode, const char *fullname,
 248         const char *hosttarget, uint16_t port, uint16_t txtLen,
 249         const unsigned char *txtRecord , void *inContext) {
 250     MDnsSdListener::Context *context = reinterpret_cast<MDnsSdListener::Context *>(inContext);
 251     char *msg;
 252     int refNumber = context->mRefNumber;
 253     port = ntohs(port);
 254     if (errorCode != kDNSServiceErr_NoError) {
 255         asprintf(&msg, "%d %d", refNumber, errorCode);
 256         context->mListener->sendBroadcast(ResponseCode::ServiceResolveFailed, msg, false);
 257         if (DBG) ALOGE("resolve failure for %d, error= %d", refNumber, errorCode);
 258     } else {
 259         char *quotedFullName = SocketClient::quoteArg(fullname);
 260         char *quotedHostTarget = SocketClient::quoteArg(hosttarget);
 261
 262         // Base 64 encodes every 3 bytes into 4 characters, but then adds padding to the next
 263         // multiple of 4 and a \0
 264         size_t dstLength = CEIL(CEIL(txtLen * 4, 3), 4) * 4 + 1;
 265
 266         char *dst = (char *)malloc(dstLength);
 267         b64_ntop(txtRecord, txtLen, dst, dstLength);
 268
 269         asprintf(&msg, "%d %s %s %d %d \"%s\"", refNumber, quotedFullName, quotedHostTarget, port,
 270                  txtLen, dst);
 271         free(quotedFullName);
 272         free(quotedHostTarget);
 273         free(dst);
 274         context->mListener->sendBroadcast(ResponseCode::ServiceResolveSuccess, msg, false);
 275         if (VDBG) {
 276             ALOGD("resolve succeeded for %d finding %s at %s:%d with txtLen %d",
 277                     refNumber, fullname, hosttarget, port, txtLen);
 278         }
 279     }
 280     free(msg);
 281 }
 282
 283 void MDnsSdListener::Handler::getAddrInfo(SocketClient *cli, int requestId,
 284         const char *interfaceName, uint32_t protocol, const char *hostname) {
 285     if (VDBG) ALOGD("getAddrInfo(%d, %s %d, %s)", requestId, interfaceName, protocol, hostname);
 286     Context *context = new Context(requestId, mListener);
 287     DNSServiceRef *ref = mMonitor->allocateServiceRef(requestId, context);
 288     if (ref == NULL) {
 289         ALOGE("request ID %d already in use during getAddrInfo call", requestId);
 290         cli->sendMsg(ResponseCode::CommandParameterError,
 291                 "RequestId already in use during getAddrInfo call", false);
 292         return;
 293     }
 294     DNSServiceFlags nativeFlags = 0;
 295     int interfaceInt = ifaceNameToI(interfaceName);
 296     DNSServiceErrorType result = DNSServiceGetAddrInfo(ref, nativeFlags, interfaceInt, protocol,
 297             hostname, &MDnsSdListenerGetAddrInfoCallback, context);
 298     if (result != kDNSServiceErr_NoError) {
 299         ALOGE("getAddrInfo request %d got an error from DNSServiceGetAddrInfo %d", requestId,
 300                 result);
 301         mMonitor->freeServiceRef(requestId);
 302         cli->sendMsg(ResponseCode::CommandParameterError,
 303                 "getAddrInfo request got an error from DNSServiceGetAddrInfo", false);
 304         return;
 305     }
 306     mMonitor->startMonitoring(requestId);
 307     if (VDBG) ALOGD("getAddrInfo successful");
 308     cli->sendMsg(ResponseCode::CommandOkay, "getAddrInfo started", false);
 309     return;
 310 }
 311
 312 void MDnsSdListenerGetAddrInfoCallback(DNSServiceRef /* sdRef */, DNSServiceFlags /* flags */,
 313         uint32_t /* interface */, DNSServiceErrorType errorCode, const char *hostname,
 314         const struct sockaddr *const sa, uint32_t ttl, void *inContext) {
 315     MDnsSdListener::Context *context = reinterpret_cast<MDnsSdListener::Context *>(inContext);
 316     int refNumber = context->mRefNumber;
 317
 318     if (errorCode != kDNSServiceErr_NoError) {
 319         char *msg;
 320         asprintf(&msg, "%d %d", refNumber, errorCode);
 321         context->mListener->sendBroadcast(ResponseCode::ServiceGetAddrInfoFailed, msg, false);
 322         if (DBG) ALOGE("getAddrInfo failure for %d, error= %d", refNumber, errorCode);
 323         free(msg);
 324     } else {
 325         char addr[INET6_ADDRSTRLEN];
 326         char *msg;
 327         char *quotedHostname = SocketClient::quoteArg(hostname);
 328         if (sa->sa_family == AF_INET) {
 329             inet_ntop(sa->sa_family, &(((struct sockaddr_in *)sa)->sin_addr), addr, sizeof(addr));
 330         } else {
 331             inet_ntop(sa->sa_family, &(((struct sockaddr_in6 *)sa)->sin6_addr), addr, sizeof(addr));
 332         }
 333         asprintf(&msg, "%d %s %d %s", refNumber, quotedHostname, ttl, addr);
 334         free(quotedHostname);
 335         context->mListener->sendBroadcast(ResponseCode::ServiceGetAddrInfoSuccess, msg, false);
 336         if (VDBG) {
 337             ALOGD("getAddrInfo succeeded for %d: %s", refNumber, msg);
 338         }
 339         free(msg);
 340     }
 341 }
 342
 343 void MDnsSdListener::Handler::setHostname(SocketClient *cli, int requestId,
 344         const char *hostname) {
 345     if (VDBG) ALOGD("setHostname(%d, %s)", requestId, hostname);
 346     Context *context = new Context(requestId, mListener);
 347     DNSServiceRef *ref = mMonitor->allocateServiceRef(requestId, context);
 348     if (ref == NULL) {
 349         ALOGE("request Id %d already in use during setHostname call", requestId);
 350         cli->sendMsg(ResponseCode::CommandParameterError,
 351                 "RequestId already in use during setHostname call", false);
 352         return;
 353     }
 354     DNSServiceFlags nativeFlags = 0;
 355     DNSServiceErrorType result = DNSSetHostname(ref, nativeFlags, hostname,
 356             &MDnsSdListenerSetHostnameCallback, context);
 357     if (result != kDNSServiceErr_NoError) {
 358         ALOGE("setHostname request %d got an error from DNSSetHostname %d", requestId, result);
 359         mMonitor->freeServiceRef(requestId);
 360         cli->sendMsg(ResponseCode::CommandParameterError,
 361                 "setHostname got an error from DNSSetHostname", false);
 362         return;
 363     }
 364     mMonitor->startMonitoring(requestId);
 365     if (VDBG) ALOGD("setHostname successful");
 366     cli->sendMsg(ResponseCode::CommandOkay, "setHostname started", false);
 367     return;
 368 }
 369
 370 void MDnsSdListenerSetHostnameCallback(DNSServiceRef /* sdRef */, DNSServiceFlags /* flags */,
 371         DNSServiceErrorType errorCode, const char *hostname, void *inContext) {
 372     MDnsSdListener::Context *context = reinterpret_cast<MDnsSdListener::Context *>(inContext);
 373     char *msg;
 374     int refNumber = context->mRefNumber;
 375     if (errorCode != kDNSServiceErr_NoError) {
 376         asprintf(&msg, "%d %d", refNumber, errorCode);
 377         context->mListener->sendBroadcast(ResponseCode::ServiceSetHostnameFailed, msg, false);
 378         if (DBG) ALOGE("setHostname failure for %d, error= %d", refNumber, errorCode);
 379     } else {
 380         char *quotedHostname = SocketClient::quoteArg(hostname);
 381         asprintf(&msg, "%d %s", refNumber, quotedHostname);
 382         free(quotedHostname);
 383         context->mListener->sendBroadcast(ResponseCode::ServiceSetHostnameSuccess, msg, false);
 384         if (VDBG) ALOGD("setHostname succeeded for %d.  Set to %s", refNumber, hostname);
 385     }
 386     free(msg);
 387 }
 388
 389
 390 int MDnsSdListener::Handler::ifaceNameToI(const char * /* iface */) {
 391     return 0;
 392 }
 393
 394 const char *MDnsSdListener::Handler::iToIfaceName(int /* i */) {
 395     return NULL;
 396 }
 397
 398 DNSServiceFlags MDnsSdListener::Handler::iToFlags(int /* i */) {
 399     return 0;
 400 }
 401
 402 int MDnsSdListener::Handler::flagsToI(DNSServiceFlags /* flags */) {
 403     return 0;
 404 }
 405
 406 int MDnsSdListener::Handler::runCommand(SocketClient *cli,
 407                                         int argc, char **argv) {
 408     if (argc < 2) {
 409         char* msg = NULL;
 410         asprintf( &msg, "Invalid number of arguments to mdnssd: %i", argc);
 411         ALOGW("%s", msg);
 412         cli->sendMsg(ResponseCode::CommandParameterError, msg, false);
 413         free(msg);
 414         return -1;
 415     }
 416
 417     char* cmd = argv[1];
 418
 419     if (strcmp(cmd, "discover") == 0) {
 420         if (argc != 4) {
 421             cli->sendMsg(ResponseCode::CommandParameterError,
 422                     "Invalid number of arguments to mdnssd discover", false);
 423             return 0;
 424         }
 425         int requestId = atoi(argv[2]);
 426         char *serviceType = argv[3];
 427
 428         discover(cli, NULL, serviceType, NULL, requestId, 0);
 429     } else if (strcmp(cmd, "stop-discover") == 0) {
 430         stop(cli, argc, argv, "discover");
 431     } else if (strcmp(cmd, "register") == 0) {
 432         if (argc != 7) {
 433             cli->sendMsg(ResponseCode::CommandParameterError,
 434                     "Invalid number of arguments to mdnssd register", false);
 435             return 0;
 436         }
 437         int requestId = atoi(argv[2]);
 438         char *serviceName = argv[3];
 439         char *serviceType = argv[4];
 440         int port = atoi(argv[5]);
 441         char *interfaceName = NULL; // will use all
 442         char *domain = NULL;        // will use default
 443         char *host = NULL;          // will use default hostname
 444
 445         // TXT record length is <= 1300, see NsdServiceInfo.setAttribute
 446         char dst[1300];
 447
 448         int length = b64_pton(argv[6], (u_char *)dst, 1300);
 449
 450         if (length < 0) {
 451            cli->sendMsg(ResponseCode::CommandParameterError,
 452                     "Could not decode txtRecord", false);
 453            return 0;
 454         }
 455
 456         serviceRegister(cli, requestId, interfaceName, serviceName,
 457                 serviceType, domain, host, port, length, dst);
 458     } else if (strcmp(cmd, "stop-register") == 0) {
 459         stop(cli, argc, argv, "register");
 460     } else if (strcmp(cmd, "resolve") == 0) {
 461         if (argc != 6) {
 462             cli->sendMsg(ResponseCode::CommandParameterError,
 463                     "Invalid number of arguments to mdnssd resolve", false);
 464             return 0;
 465         }
 466         int requestId = atoi(argv[2]);
 467         char *interfaceName = NULL;  // will use all
 468         char *serviceName = argv[3];
 469         char *regType = argv[4];
 470         char *domain = argv[5];
 471         resolveService(cli, requestId, interfaceName, serviceName, regType, domain);
 472     } else if (strcmp(cmd, "stop-resolve") == 0) {
 473         stop(cli, argc, argv, "resolve");
 474     } else if (strcmp(cmd, "start-service") == 0) {
 475         if (mMonitor->startService()) {
 476             cli->sendMsg(ResponseCode::CommandOkay, "Service Started", false);
 477         } else {
 478             cli->sendMsg(ResponseCode::ServiceStartFailed, "Service already running", false);
 479         }
 480     } else if (strcmp(cmd, "stop-service") == 0) {
 481         if (mMonitor->stopService()) {
 482             cli->sendMsg(ResponseCode::CommandOkay, "Service Stopped", false);
 483         } else {
 484             cli->sendMsg(ResponseCode::ServiceStopFailed, "Service still in use", false);
 485         }
 486     } else if (strcmp(cmd, "sethostname") == 0) {
 487         if (argc != 4) {
 488             cli->sendMsg(ResponseCode::CommandParameterError,
 489                     "Invalid number of arguments to mdnssd sethostname", false);
 490             return 0;
 491         }
 492         int requestId = atoi(argv[2]);
 493         char *hostname = argv[3];
 494         setHostname(cli, requestId, hostname);
 495     } else if (strcmp(cmd, "stop-sethostname") == 0) {
 496         stop(cli, argc, argv, "sethostname");
 497     } else if (strcmp(cmd, "getaddrinfo") == 0) {
 498         if (argc != 4) {
 499             cli->sendMsg(ResponseCode::CommandParameterError,
 500                     "Invalid number of arguments to mdnssd getaddrinfo", false);
 501             return 0;
 502         }
 503         int requestId = atoi(argv[2]);
 504         char *hostname = argv[3];
 505         char *interfaceName = NULL;  // default
 506         int protocol = 0;            // intelligient heuristic (both v4 + v6)
 507         getAddrInfo(cli, requestId, interfaceName, protocol, hostname);
 508     } else if (strcmp(cmd, "stop-getaddrinfo") == 0) {
 509         stop(cli, argc, argv, "getaddrinfo");
 510     } else {
 511         if (VDBG) ALOGE("Unknown cmd %s", cmd);
 512         cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown mdnssd cmd", false);
 513         return 0;
 514     }
 515     return 0;
 516 }
 517
 518 MDnsSdListener::Monitor::Monitor() {
 519     mHead = NULL;
 520     mLiveCount = 0;
 521     mPollFds = NULL;
 522     mPollRefs = NULL;
 523     mPollSize = 10;
 524     socketpair(AF_LOCAL, SOCK_STREAM, 0, mCtrlSocketPair);
 525     pthread_mutex_init(&mHeadMutex, NULL);
 526
 527     pthread_create(&mThread, NULL, MDnsSdListener::Monitor::threadStart, this);
 528     pthread_detach(mThread);
 529 }
 530
 531 void *MDnsSdListener::Monitor::threadStart(void *obj) {
 532     Monitor *monitor = reinterpret_cast<Monitor *>(obj);
 533
 534     monitor->run();
 535     delete monitor;
 536     pthread_exit(NULL);
 537     return NULL;
 538 }
 539
 540 #define NAP_TIME 200  // 200 ms between polls
 541 static int wait_for_property(const char *name, const char *desired_value, int maxwait)
 542 {
 543     char value[PROPERTY_VALUE_MAX] = {'\0'};
 544     int maxnaps = (maxwait * 1000) / NAP_TIME;
 545
 546     if (maxnaps < 1) {
 547         maxnaps = 1;
 548     }
 549
 550     while (maxnaps-- > 0) {
 551         usleep(NAP_TIME * 1000);
 552         if (property_get(name, value, NULL)) {
 553             if (desired_value == NULL || strcmp(value, desired_value) == 0) {
 554                 return 0;
 555             }
 556         }
 557     }
 558     return -1; /* failure */
 559 }
 560
 561 int MDnsSdListener::Monitor::startService() {
 562     int result = 0;
 563     char property_value[PROPERTY_VALUE_MAX];
 564     pthread_mutex_lock(&mHeadMutex);
 565     property_get(MDNS_SERVICE_STATUS, property_value, "");
 566     if (strcmp("running", property_value) != 0) {
 567         ALOGD("Starting MDNSD");
 568         property_set("ctl.start", MDNS_SERVICE_NAME);
 569         wait_for_property(MDNS_SERVICE_STATUS, "running", 5);
 570         result = -1;
 571     } else {
 572         result = 0;
 573     }
 574     pthread_mutex_unlock(&mHeadMutex);
 575     return result;
 576 }
 577
 578 int MDnsSdListener::Monitor::stopService() {
 579     int result = 0;
 580     pthread_mutex_lock(&mHeadMutex);
 581     if (mHead == NULL) {
 582         ALOGD("Stopping MDNSD");
 583         property_set("ctl.stop", MDNS_SERVICE_NAME);
 584         wait_for_property(MDNS_SERVICE_STATUS, "stopped", 5);
 585         result = -1;
 586     } else {
 587         result = 0;
 588     }
 589     pthread_mutex_unlock(&mHeadMutex);
 590     return result;
 591 }
 592
 593 void MDnsSdListener::Monitor::run() {
 594     int pollCount = 1;
 595
 596     mPollFds = (struct pollfd *)calloc(sizeof(struct pollfd), mPollSize);
 597     mPollRefs = (DNSServiceRef **)calloc(sizeof(DNSServiceRef *), mPollSize);
 598     LOG_ALWAYS_FATAL_IF((mPollFds == NULL), "initial calloc failed on mPollFds with a size of %d",
 599             ((int)sizeof(struct pollfd)) * mPollSize);
 600     LOG_ALWAYS_FATAL_IF((mPollRefs == NULL), "initial calloc failed on mPollRefs with a size of %d",
 601             ((int)sizeof(DNSServiceRef *)) * mPollSize);
 602
 603     mPollFds[0].fd = mCtrlSocketPair[0];
 604     mPollFds[0].events = POLLIN;
 605
 606     if (VDBG) ALOGD("MDnsSdListener starting to monitor");
 607     while (1) {
 608         if (VDBG) ALOGD("Going to poll with pollCount %d", pollCount);
 609         int pollResults = poll(mPollFds, pollCount, 10000000);
 610         if (pollResults < 0) {
 611             ALOGE("Error in poll - got %d", errno);
 612         } else if (pollResults > 0) {
 613             if (VDBG) ALOGD("Monitor poll got data pollCount = %d, %d", pollCount, pollResults);
 614             for(int i = 1; i < pollCount; i++) {
 615                 if (mPollFds[i].revents != 0) {
 616                     if (VDBG) {
 617                         ALOGD("Monitor found [%d].revents = %d - calling ProcessResults",
 618                                 i, mPollFds[i].revents);
 619                     }
 620                     DNSServiceProcessResult(*(mPollRefs[i]));
 621                     mPollFds[i].revents = 0;
 622                 }
 623             }
 624             if (VDBG) ALOGD("controlSocket shows revent= %d", mPollFds[0].revents);
 625             switch (mPollFds[0].revents) {
 626                 case POLLIN: {
 627                     char readBuf[2];
 628                     read(mCtrlSocketPair[0], &readBuf, 1);
 629                     if (DBG) ALOGD("MDnsSdListener::Monitor got %c", readBuf[0]);
 630                     if (memcmp(RESCAN, readBuf, 1) == 0) {
 631                         pollCount = rescan();
 632                     }
 633                 }
 634             }
 635             mPollFds[0].revents = 0;
 636         } else {
 637             if (VDBG) ALOGD("MDnsSdListener::Monitor poll timed out");
 638         }
 639     }
 640     free(mPollFds);
 641     free(mPollRefs);
 642 }
 643
 644 #define DBG_RESCAN 0
 645
 646 int MDnsSdListener::Monitor::rescan() {
 647 // rescan the list from mHead and make new pollfds and serviceRefs
 648     if (VDBG) {
 649         ALOGD("MDnsSdListener::Monitor poll rescanning - size=%d, live=%d", mPollSize, mLiveCount);
 650     }
 651     pthread_mutex_lock(&mHeadMutex);
 652     Element **prevPtr = &mHead;
 653     int i = 1;
 654     if (mPollSize <= mLiveCount) {
 655         mPollSize = mLiveCount + 5;
 656         free(mPollFds);
 657         free(mPollRefs);
 658         mPollFds = (struct pollfd *)calloc(sizeof(struct pollfd), mPollSize);
 659         mPollRefs = (DNSServiceRef **)calloc(sizeof(DNSServiceRef *), mPollSize);
 660         LOG_ALWAYS_FATAL_IF((mPollFds == NULL), "calloc failed on mPollFds with a size of %d",
 661                 ((int)sizeof(struct pollfd)) * mPollSize);
 662         LOG_ALWAYS_FATAL_IF((mPollRefs == NULL), "calloc failed on mPollRefs with a size of %d",
 663                 ((int)sizeof(DNSServiceRef *)) * mPollSize);
 664     } else {
 665         memset(mPollFds, 0, sizeof(struct pollfd) * mPollSize);
 666         memset(mPollRefs, 0, sizeof(DNSServiceRef *) * mPollSize);
 667     }
 668     mPollFds[0].fd = mCtrlSocketPair[0];
 669     mPollFds[0].events = POLLIN;
 670     if (DBG_RESCAN) ALOGD("mHead = %p", mHead);
 671     while (*prevPtr != NULL) {
 672         if (DBG_RESCAN) ALOGD("checking %p, mReady = %d", *prevPtr, (*prevPtr)->mReady);
 673         if ((*prevPtr)->mReady == 1) {
 674             int fd = DNSServiceRefSockFD((*prevPtr)->mRef);
 675             if (fd != -1) {
 676                 if (DBG_RESCAN) ALOGD("  adding FD %d", fd);
 677                 mPollFds[i].fd = fd;
 678                 mPollFds[i].events = POLLIN;
 679                 mPollRefs[i] = &((*prevPtr)->mRef);
 680                 i++;
 681             } else {
 682                 ALOGE("Error retreving socket FD for live ServiceRef");
 683             }
 684             prevPtr = &((*prevPtr)->mNext); // advance to the next element
 685         } else if ((*prevPtr)->mReady == -1) {
 686             if (DBG_RESCAN) ALOGD("  removing %p from  play", *prevPtr);
 687             Element *cur = *prevPtr;
 688             *prevPtr = (cur)->mNext; // change our notion of this element and don't advance
 689             delete cur;
 690         } else if ((*prevPtr)->mReady == 0) {
 691             // Not ready so just skip this node and continue on
 692             if (DBG_RESCAN) ALOGD("%p not ready.  Continuing.", *prevPtr);
 693             prevPtr = &((*prevPtr)->mNext);
 694         }
 695     }
 696     pthread_mutex_unlock(&mHeadMutex);
 697     return i;
 698 }
 699
 700 DNSServiceRef *MDnsSdListener::Monitor::allocateServiceRef(int id, Context *context) {
 701     if (lookupServiceRef(id) != NULL) {
 702         delete(context);
 703         return NULL;
 704     }
 705     Element *e = new Element(id, context);
 706     pthread_mutex_lock(&mHeadMutex);
 707     e->mNext = mHead;
 708     mHead = e;
 709     pthread_mutex_unlock(&mHeadMutex);
 710     return &(e->mRef);
 711 }
 712
 713 DNSServiceRef *MDnsSdListener::Monitor::lookupServiceRef(int id) {
 714     pthread_mutex_lock(&mHeadMutex);
 715     Element *cur = mHead;
 716     while (cur != NULL) {
 717         if (cur->mId == id) {
 718             DNSServiceRef *result = &(cur->mRef);
 719             pthread_mutex_unlock(&mHeadMutex);
 720             return result;
 721         }
 722         cur = cur->mNext;
 723     }
 724     pthread_mutex_unlock(&mHeadMutex);
 725     return NULL;
 726 }
 727
 728 void MDnsSdListener::Monitor::startMonitoring(int id) {
 729     if (VDBG) ALOGD("startMonitoring %d", id);
 730     pthread_mutex_lock(&mHeadMutex);
 731     Element *cur = mHead;
 732     while (cur != NULL) {
 733         if (cur->mId == id) {
 734             if (DBG_RESCAN) ALOGD("marking %p as ready to be added", cur);
 735             mLiveCount++;
 736             cur->mReady = 1;
 737             pthread_mutex_unlock(&mHeadMutex);
 738             write(mCtrlSocketPair[1], RESCAN, 1);  // trigger a rescan for a fresh poll
 739             if (VDBG) ALOGD("triggering rescan");
 740             return;
 741         }
 742         cur = cur->mNext;
 743     }
 744     pthread_mutex_unlock(&mHeadMutex);
 745 }
 746
 747 void MDnsSdListener::Monitor::freeServiceRef(int id) {
 748     if (VDBG) ALOGD("freeServiceRef %d", id);
 749     pthread_mutex_lock(&mHeadMutex);
 750     Element **prevPtr = &mHead;
 751     Element *cur;
 752     while (*prevPtr != NULL) {
 753         cur = *prevPtr;
 754         if (cur->mId == id) {
 755             if (DBG_RESCAN) ALOGD("marking %p as ready to be removed", cur);
 756             mLiveCount--;
 757             if (cur->mReady == 1) {
 758                 cur->mReady = -1; // tell poll thread to delete
 759                 write(mCtrlSocketPair[1], RESCAN, 1); // trigger a rescan for a fresh poll
 760                 if (VDBG) ALOGD("triggering rescan");
 761             } else {
 762                 *prevPtr = cur->mNext;
 763                 delete cur;
 764             }
 765             pthread_mutex_unlock(&mHeadMutex);
 766             return;
 767         }
 768         prevPtr = &(cur->mNext);
 769     }
 770     pthread_mutex_unlock(&mHeadMutex);
 771 }