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