services/core/java/com/android/server/NsdService.java

   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 package com.android.server;
  18
  19 import android.content.Context;
  20 import android.content.ContentResolver;
  21 import android.content.Intent;
  22 import android.content.pm.PackageManager;
  23 import android.database.ContentObserver;
  24 import android.net.Uri;
  25 import android.net.nsd.NsdServiceInfo;
  26 import android.net.nsd.DnsSdTxtRecord;
  27 import android.net.nsd.INsdManager;
  28 import android.net.nsd.NsdManager;
  29 import android.os.Binder;
  30 import android.os.HandlerThread;
  31 import android.os.Handler;
  32 import android.os.Message;
  33 import android.os.Messenger;
  34 import android.os.UserHandle;
  35 import android.provider.Settings;
  36 import android.util.Base64;
  37 import android.util.Slog;
  38 import android.util.SparseArray;
  39 import android.util.SparseIntArray;
  40
  41 import java.io.FileDescriptor;
  42 import java.io.PrintWriter;
  43 import java.net.InetAddress;
  44 import java.util.Arrays;
  45 import java.util.HashMap;
  46 import java.util.concurrent.CountDownLatch;
  47
  48 import com.android.internal.annotations.VisibleForTesting;
  49 import com.android.internal.util.AsyncChannel;
  50 import com.android.internal.util.DumpUtils;
  51 import com.android.internal.util.Protocol;
  52 import com.android.internal.util.State;
  53 import com.android.internal.util.StateMachine;
  54
  55 /**
  56  * Network Service Discovery Service handles remote service discovery operation requests by
  57  * implementing the INsdManager interface.
  58  *
  59  * @hide
  60  */
  61 public class NsdService extends INsdManager.Stub {
  62     private static final String TAG = "NsdService";
  63     private static final String MDNS_TAG = "mDnsConnector";
  64
  65     private static final boolean DBG = true;
  66
  67     private final Context mContext;
  68     private final NsdSettings mNsdSettings;
  69     private final NsdStateMachine mNsdStateMachine;
  70     private final DaemonConnection mDaemon;
  71     private final NativeCallbackReceiver mDaemonCallback;
  72
  73     /**
  74      * Clients receiving asynchronous messages
  75      */
  76     private final HashMap<Messenger, ClientInfo> mClients = new HashMap<>();
  77
  78     /* A map from unique id to client info */
  79     private final SparseArray<ClientInfo> mIdToClientInfoMap= new SparseArray<>();
  80
  81     private final AsyncChannel mReplyChannel = new AsyncChannel();
  82
  83     private static final int INVALID_ID = 0;
  84     private int mUniqueId = 1;
  85
  86     private class NsdStateMachine extends StateMachine {
  87
  88         private final DefaultState mDefaultState = new DefaultState();
  89         private final DisabledState mDisabledState = new DisabledState();
  90         private final EnabledState mEnabledState = new EnabledState();
  91
  92         @Override
  93         protected String getWhatToString(int what) {
  94             return NsdManager.nameOf(what);
  95         }
  96
  97         /**
  98          * Observes the NSD on/off setting, and takes action when changed.
  99          */
 100         private void registerForNsdSetting() {
 101             final ContentObserver contentObserver = new ContentObserver(this.getHandler()) {
 102                 @Override
 103                 public void onChange(boolean selfChange) {
 104                     notifyEnabled(isNsdEnabled());
 105                 }
 106             };
 107
 108             final Uri uri = Settings.Global.getUriFor(Settings.Global.NSD_ON);
 109             mNsdSettings.registerContentObserver(uri, contentObserver);
 110         }
 111
 112         NsdStateMachine(String name, Handler handler) {
 113             super(name, handler);
 114             addState(mDefaultState);
 115                 addState(mDisabledState, mDefaultState);
 116                 addState(mEnabledState, mDefaultState);
 117             State initialState = isNsdEnabled() ? mEnabledState : mDisabledState;
 118             setInitialState(initialState);
 119             setLogRecSize(25);
 120             registerForNsdSetting();
 121         }
 122
 123         class DefaultState extends State {
 124             @Override
 125             public boolean processMessage(Message msg) {
 126                 ClientInfo cInfo = null;
 127                 switch (msg.what) {
 128                     case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED:
 129                         if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
 130                             AsyncChannel c = (AsyncChannel) msg.obj;
 131                             if (DBG) Slog.d(TAG, "New client listening to asynchronous messages");
 132                             c.sendMessage(AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED);
 133                             cInfo = new ClientInfo(c, msg.replyTo);
 134                             mClients.put(msg.replyTo, cInfo);
 135                         } else {
 136                             Slog.e(TAG, "Client connection failure, error=" + msg.arg1);
 137                         }
 138                         break;
 139                     case AsyncChannel.CMD_CHANNEL_DISCONNECTED:
 140                         switch (msg.arg1) {
 141                             case AsyncChannel.STATUS_SEND_UNSUCCESSFUL:
 142                                 Slog.e(TAG, "Send failed, client connection lost");
 143                                 break;
 144                             case AsyncChannel.STATUS_REMOTE_DISCONNECTION:
 145                                 if (DBG) Slog.d(TAG, "Client disconnected");
 146                                 break;
 147                             default:
 148                                 if (DBG) Slog.d(TAG, "Client connection lost with reason: " + msg.arg1);
 149                                 break;
 150                         }
 151                         cInfo = mClients.get(msg.replyTo);
 152                         if (cInfo != null) {
 153                             cInfo.expungeAllRequests();
 154                             mClients.remove(msg.replyTo);
 155                         }
 156                         //Last client
 157                         if (mClients.size() == 0) {
 158                             mDaemon.stop();
 159                         }
 160                         break;
 161                     case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION:
 162                         AsyncChannel ac = new AsyncChannel();
 163                         ac.connect(mContext, getHandler(), msg.replyTo);
 164                         break;
 165                     case NsdManager.DISCOVER_SERVICES:
 166                         replyToMessage(msg, NsdManager.DISCOVER_SERVICES_FAILED,
 167                                 NsdManager.FAILURE_INTERNAL_ERROR);
 168                        break;
 169                     case NsdManager.STOP_DISCOVERY:
 170                        replyToMessage(msg, NsdManager.STOP_DISCOVERY_FAILED,
 171                                NsdManager.FAILURE_INTERNAL_ERROR);
 172                         break;
 173                     case NsdManager.REGISTER_SERVICE:
 174                         replyToMessage(msg, NsdManager.REGISTER_SERVICE_FAILED,
 175                                 NsdManager.FAILURE_INTERNAL_ERROR);
 176                         break;
 177                     case NsdManager.UNREGISTER_SERVICE:
 178                         replyToMessage(msg, NsdManager.UNREGISTER_SERVICE_FAILED,
 179                                 NsdManager.FAILURE_INTERNAL_ERROR);
 180                         break;
 181                     case NsdManager.RESOLVE_SERVICE:
 182                         replyToMessage(msg, NsdManager.RESOLVE_SERVICE_FAILED,
 183                                 NsdManager.FAILURE_INTERNAL_ERROR);
 184                         break;
 185                     case NsdManager.NATIVE_DAEMON_EVENT:
 186                     default:
 187                         Slog.e(TAG, "Unhandled " + msg);
 188                         return NOT_HANDLED;
 189                 }
 190                 return HANDLED;
 191             }
 192         }
 193
 194         class DisabledState extends State {
 195             @Override
 196             public void enter() {
 197                 sendNsdStateChangeBroadcast(false);
 198             }
 199
 200             @Override
 201             public boolean processMessage(Message msg) {
 202                 switch (msg.what) {
 203                     case NsdManager.ENABLE:
 204                         transitionTo(mEnabledState);
 205                         break;
 206                     default:
 207                         return NOT_HANDLED;
 208                 }
 209                 return HANDLED;
 210             }
 211         }
 212
 213         class EnabledState extends State {
 214             @Override
 215             public void enter() {
 216                 sendNsdStateChangeBroadcast(true);
 217                 if (mClients.size() > 0) {
 218                     mDaemon.start();
 219                 }
 220             }
 221
 222             @Override
 223             public void exit() {
 224                 if (mClients.size() > 0) {
 225                     mDaemon.stop();
 226                 }
 227             }
 228
 229             private boolean requestLimitReached(ClientInfo clientInfo) {
 230                 if (clientInfo.mClientIds.size() >= ClientInfo.MAX_LIMIT) {
 231                     if (DBG) Slog.d(TAG, "Exceeded max outstanding requests " + clientInfo);
 232                     return true;
 233                 }
 234                 return false;
 235             }
 236
 237             private void storeRequestMap(int clientId, int globalId, ClientInfo clientInfo, int what) {
 238                 clientInfo.mClientIds.put(clientId, globalId);
 239                 clientInfo.mClientRequests.put(clientId, what);
 240                 mIdToClientInfoMap.put(globalId, clientInfo);
 241             }
 242
 243             private void removeRequestMap(int clientId, int globalId, ClientInfo clientInfo) {
 244                 clientInfo.mClientIds.delete(clientId);
 245                 clientInfo.mClientRequests.delete(clientId);
 246                 mIdToClientInfoMap.remove(globalId);
 247             }
 248
 249             @Override
 250             public boolean processMessage(Message msg) {
 251                 ClientInfo clientInfo;
 252                 NsdServiceInfo servInfo;
 253                 int id;
 254                 switch (msg.what) {
 255                     case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED:
 256                         //First client
 257                         if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL &&
 258                                 mClients.size() == 0) {
 259                             mDaemon.start();
 260                         }
 261                         return NOT_HANDLED;
 262                     case AsyncChannel.CMD_CHANNEL_DISCONNECTED:
 263                         return NOT_HANDLED;
 264                     case NsdManager.DISABLE:
 265                         //TODO: cleanup clients
 266                         transitionTo(mDisabledState);
 267                         break;
 268                     case NsdManager.DISCOVER_SERVICES:
 269                         if (DBG) Slog.d(TAG, "Discover services");
 270                         servInfo = (NsdServiceInfo) msg.obj;
 271                         clientInfo = mClients.get(msg.replyTo);
 272
 273                         if (requestLimitReached(clientInfo)) {
 274                             replyToMessage(msg, NsdManager.DISCOVER_SERVICES_FAILED,
 275                                     NsdManager.FAILURE_MAX_LIMIT);
 276                             break;
 277                         }
 278
 279                         id = getUniqueId();
 280                         if (discoverServices(id, servInfo.getServiceType())) {
 281                             if (DBG) {
 282                                 Slog.d(TAG, "Discover " + msg.arg2 + " " + id +
 283                                         servInfo.getServiceType());
 284                             }
 285                             storeRequestMap(msg.arg2, id, clientInfo, msg.what);
 286                             replyToMessage(msg, NsdManager.DISCOVER_SERVICES_STARTED, servInfo);
 287                         } else {
 288                             stopServiceDiscovery(id);
 289                             replyToMessage(msg, NsdManager.DISCOVER_SERVICES_FAILED,
 290                                     NsdManager.FAILURE_INTERNAL_ERROR);
 291                         }
 292                         break;
 293                     case NsdManager.STOP_DISCOVERY:
 294                         if (DBG) Slog.d(TAG, "Stop service discovery");
 295                         clientInfo = mClients.get(msg.replyTo);
 296
 297                         try {
 298                             id = clientInfo.mClientIds.get(msg.arg2);
 299                         } catch (NullPointerException e) {
 300                             replyToMessage(msg, NsdManager.STOP_DISCOVERY_FAILED,
 301                                     NsdManager.FAILURE_INTERNAL_ERROR);
 302                             break;
 303                         }
 304                         removeRequestMap(msg.arg2, id, clientInfo);
 305                         if (stopServiceDiscovery(id)) {
 306                             replyToMessage(msg, NsdManager.STOP_DISCOVERY_SUCCEEDED);
 307                         } else {
 308                             replyToMessage(msg, NsdManager.STOP_DISCOVERY_FAILED,
 309                                     NsdManager.FAILURE_INTERNAL_ERROR);
 310                         }
 311                         break;
 312                     case NsdManager.REGISTER_SERVICE:
 313                         if (DBG) Slog.d(TAG, "Register service");
 314                         clientInfo = mClients.get(msg.replyTo);
 315                         if (requestLimitReached(clientInfo)) {
 316                             replyToMessage(msg, NsdManager.REGISTER_SERVICE_FAILED,
 317                                     NsdManager.FAILURE_MAX_LIMIT);
 318                             break;
 319                         }
 320
 321                         id = getUniqueId();
 322                         if (registerService(id, (NsdServiceInfo) msg.obj)) {
 323                             if (DBG) Slog.d(TAG, "Register " + msg.arg2 + " " + id);
 324                             storeRequestMap(msg.arg2, id, clientInfo, msg.what);
 325                             // Return success after mDns reports success
 326                         } else {
 327                             unregisterService(id);
 328                             replyToMessage(msg, NsdManager.REGISTER_SERVICE_FAILED,
 329                                     NsdManager.FAILURE_INTERNAL_ERROR);
 330                         }
 331                         break;
 332                     case NsdManager.UNREGISTER_SERVICE:
 333                         if (DBG) Slog.d(TAG, "unregister service");
 334                         clientInfo = mClients.get(msg.replyTo);
 335                         try {
 336                             id = clientInfo.mClientIds.get(msg.arg2);
 337                         } catch (NullPointerException e) {
 338                             replyToMessage(msg, NsdManager.UNREGISTER_SERVICE_FAILED,
 339                                     NsdManager.FAILURE_INTERNAL_ERROR);
 340                             break;
 341                         }
 342                         removeRequestMap(msg.arg2, id, clientInfo);
 343                         if (unregisterService(id)) {
 344                             replyToMessage(msg, NsdManager.UNREGISTER_SERVICE_SUCCEEDED);
 345                         } else {
 346                             replyToMessage(msg, NsdManager.UNREGISTER_SERVICE_FAILED,
 347                                     NsdManager.FAILURE_INTERNAL_ERROR);
 348                         }
 349                         break;
 350                     case NsdManager.RESOLVE_SERVICE:
 351                         if (DBG) Slog.d(TAG, "Resolve service");
 352                         servInfo = (NsdServiceInfo) msg.obj;
 353                         clientInfo = mClients.get(msg.replyTo);
 354
 355
 356                         if (clientInfo.mResolvedService != null) {
 357                             replyToMessage(msg, NsdManager.RESOLVE_SERVICE_FAILED,
 358                                     NsdManager.FAILURE_ALREADY_ACTIVE);
 359                             break;
 360                         }
 361
 362                         id = getUniqueId();
 363                         if (resolveService(id, servInfo)) {
 364                             clientInfo.mResolvedService = new NsdServiceInfo();
 365                             storeRequestMap(msg.arg2, id, clientInfo, msg.what);
 366                         } else {
 367                             replyToMessage(msg, NsdManager.RESOLVE_SERVICE_FAILED,
 368                                     NsdManager.FAILURE_INTERNAL_ERROR);
 369                         }
 370                         break;
 371                     case NsdManager.NATIVE_DAEMON_EVENT:
 372                         NativeEvent event = (NativeEvent) msg.obj;
 373                         if (!handleNativeEvent(event.code, event.raw, event.cooked)) {
 374                             return NOT_HANDLED;
 375                         }
 376                         break;
 377                     default:
 378                         return NOT_HANDLED;
 379                 }
 380                 return HANDLED;
 381             }
 382
 383             private boolean handleNativeEvent(int code, String raw, String[] cooked) {
 384                 NsdServiceInfo servInfo;
 385                 int id = Integer.parseInt(cooked[1]);
 386                 ClientInfo clientInfo = mIdToClientInfoMap.get(id);
 387                 if (clientInfo == null) {
 388                     String name = NativeResponseCode.nameOf(code);
 389                     Slog.e(TAG, String.format("id %d for %s has no client mapping", id, name));
 390                     return false;
 391                 }
 392
 393                 /* This goes in response as msg.arg2 */
 394                 int clientId = clientInfo.getClientId(id);
 395                 if (clientId < 0) {
 396                     // This can happen because of race conditions. For example,
 397                     // SERVICE_FOUND may race with STOP_SERVICE_DISCOVERY,
 398                     // and we may get in this situation.
 399                     String name = NativeResponseCode.nameOf(code);
 400                     Slog.d(TAG, String.format(
 401                             "Notification %s for listener id %d that is no longer active",
 402                             name, id));
 403                     return false;
 404                 }
 405                 if (DBG) {
 406                     String name = NativeResponseCode.nameOf(code);
 407                     Slog.d(TAG, String.format("Native daemon message %s: %s", name, raw));
 408                 }
 409                 switch (code) {
 410                     case NativeResponseCode.SERVICE_FOUND:
 411                         /* NNN uniqueId serviceName regType domain */
 412                         servInfo = new NsdServiceInfo(cooked[2], cooked[3]);
 413                         clientInfo.mChannel.sendMessage(NsdManager.SERVICE_FOUND, 0,
 414                                 clientId, servInfo);
 415                         break;
 416                     case NativeResponseCode.SERVICE_LOST:
 417                         /* NNN uniqueId serviceName regType domain */
 418                         servInfo = new NsdServiceInfo(cooked[2], cooked[3]);
 419                         clientInfo.mChannel.sendMessage(NsdManager.SERVICE_LOST, 0,
 420                                 clientId, servInfo);
 421                         break;
 422                     case NativeResponseCode.SERVICE_DISCOVERY_FAILED:
 423                         /* NNN uniqueId errorCode */
 424                         clientInfo.mChannel.sendMessage(NsdManager.DISCOVER_SERVICES_FAILED,
 425                                 NsdManager.FAILURE_INTERNAL_ERROR, clientId);
 426                         break;
 427                     case NativeResponseCode.SERVICE_REGISTERED:
 428                         /* NNN regId serviceName regType */
 429                         servInfo = new NsdServiceInfo(cooked[2], null);
 430                         clientInfo.mChannel.sendMessage(NsdManager.REGISTER_SERVICE_SUCCEEDED,
 431                                 id, clientId, servInfo);
 432                         break;
 433                     case NativeResponseCode.SERVICE_REGISTRATION_FAILED:
 434                         /* NNN regId errorCode */
 435                         clientInfo.mChannel.sendMessage(NsdManager.REGISTER_SERVICE_FAILED,
 436                                NsdManager.FAILURE_INTERNAL_ERROR, clientId);
 437                         break;
 438                     case NativeResponseCode.SERVICE_UPDATED:
 439                         /* NNN regId */
 440                         break;
 441                     case NativeResponseCode.SERVICE_UPDATE_FAILED:
 442                         /* NNN regId errorCode */
 443                         break;
 444                     case NativeResponseCode.SERVICE_RESOLVED:
 445                         /* NNN resolveId fullName hostName port txtlen txtdata */
 446                         int index = 0;
 447                         while (index < cooked[2].length() && cooked[2].charAt(index) != '.') {
 448                             if (cooked[2].charAt(index) == '\\') {
 449                                 ++index;
 450                             }
 451                             ++index;
 452                         }
 453                         if (index >= cooked[2].length()) {
 454                             Slog.e(TAG, "Invalid service found " + raw);
 455                             break;
 456                         }
 457                         String name = cooked[2].substring(0, index);
 458                         String rest = cooked[2].substring(index);
 459                         String type = rest.replace(".local.", "");
 460
 461                         name = unescape(name);
 462
 463                         clientInfo.mResolvedService.setServiceName(name);
 464                         clientInfo.mResolvedService.setServiceType(type);
 465                         clientInfo.mResolvedService.setPort(Integer.parseInt(cooked[4]));
 466                         clientInfo.mResolvedService.setTxtRecords(cooked[6]);
 467
 468                         stopResolveService(id);
 469                         removeRequestMap(clientId, id, clientInfo);
 470
 471                         int id2 = getUniqueId();
 472                         if (getAddrInfo(id2, cooked[3])) {
 473                             storeRequestMap(clientId, id2, clientInfo, NsdManager.RESOLVE_SERVICE);
 474                         } else {
 475                             clientInfo.mChannel.sendMessage(NsdManager.RESOLVE_SERVICE_FAILED,
 476                                     NsdManager.FAILURE_INTERNAL_ERROR, clientId);
 477                             clientInfo.mResolvedService = null;
 478                         }
 479                         break;
 480                     case NativeResponseCode.SERVICE_RESOLUTION_FAILED:
 481                         /* NNN resolveId errorCode */
 482                         stopResolveService(id);
 483                         removeRequestMap(clientId, id, clientInfo);
 484                         clientInfo.mResolvedService = null;
 485                         clientInfo.mChannel.sendMessage(NsdManager.RESOLVE_SERVICE_FAILED,
 486                                 NsdManager.FAILURE_INTERNAL_ERROR, clientId);
 487                         break;
 488                     case NativeResponseCode.SERVICE_GET_ADDR_FAILED:
 489                         /* NNN resolveId errorCode */
 490                         stopGetAddrInfo(id);
 491                         removeRequestMap(clientId, id, clientInfo);
 492                         clientInfo.mResolvedService = null;
 493                         clientInfo.mChannel.sendMessage(NsdManager.RESOLVE_SERVICE_FAILED,
 494                                 NsdManager.FAILURE_INTERNAL_ERROR, clientId);
 495                         break;
 496                     case NativeResponseCode.SERVICE_GET_ADDR_SUCCESS:
 497                         /* NNN resolveId hostname ttl addr */
 498                         try {
 499                             clientInfo.mResolvedService.setHost(InetAddress.getByName(cooked[4]));
 500                             clientInfo.mChannel.sendMessage(NsdManager.RESOLVE_SERVICE_SUCCEEDED,
 501                                    0, clientId, clientInfo.mResolvedService);
 502                         } catch (java.net.UnknownHostException e) {
 503                             clientInfo.mChannel.sendMessage(NsdManager.RESOLVE_SERVICE_FAILED,
 504                                     NsdManager.FAILURE_INTERNAL_ERROR, clientId);
 505                         }
 506                         stopGetAddrInfo(id);
 507                         removeRequestMap(clientId, id, clientInfo);
 508                         clientInfo.mResolvedService = null;
 509                         break;
 510                     default:
 511                         return false;
 512                 }
 513                 return true;
 514             }
 515        }
 516     }
 517
 518     private String unescape(String s) {
 519         StringBuilder sb = new StringBuilder(s.length());
 520         for (int i = 0; i < s.length(); ++i) {
 521             char c = s.charAt(i);
 522             if (c == '\\') {
 523                 if (++i >= s.length()) {
 524                     Slog.e(TAG, "Unexpected end of escape sequence in: " + s);
 525                     break;
 526                 }
 527                 c = s.charAt(i);
 528                 if (c != '.' && c != '\\') {
 529                     if (i + 2 >= s.length()) {
 530                         Slog.e(TAG, "Unexpected end of escape sequence in: " + s);
 531                         break;
 532                     }
 533                     c = (char) ((c-'0') * 100 + (s.charAt(i+1)-'0') * 10 + (s.charAt(i+2)-'0'));
 534                     i += 2;
 535                 }
 536             }
 537             sb.append(c);
 538         }
 539         return sb.toString();
 540     }
 541
 542     @VisibleForTesting
 543     NsdService(Context ctx, NsdSettings settings, Handler handler, DaemonConnectionSupplier fn) {
 544         mContext = ctx;
 545         mNsdSettings = settings;
 546         mNsdStateMachine = new NsdStateMachine(TAG, handler);
 547         mNsdStateMachine.start();
 548         mDaemonCallback = new NativeCallbackReceiver();
 549         mDaemon = fn.get(mDaemonCallback);
 550     }
 551
 552     public static NsdService create(Context context) throws InterruptedException {
 553         NsdSettings settings = NsdSettings.makeDefault(context);
 554         HandlerThread thread = new HandlerThread(TAG);
 555         thread.start();
 556         Handler handler = new Handler(thread.getLooper());
 557         NsdService service = new NsdService(context, settings, handler, DaemonConnection::new);
 558         service.mDaemonCallback.awaitConnection();
 559         return service;
 560     }
 561
 562     public Messenger getMessenger() {
 563         mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INTERNET, "NsdService");
 564         return new Messenger(mNsdStateMachine.getHandler());
 565     }
 566
 567     public void setEnabled(boolean isEnabled) {
 568         mContext.enforceCallingOrSelfPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL,
 569                 "NsdService");
 570         mNsdSettings.putEnabledStatus(isEnabled);
 571         notifyEnabled(isEnabled);
 572     }
 573
 574     private void notifyEnabled(boolean isEnabled) {
 575         mNsdStateMachine.sendMessage(isEnabled ? NsdManager.ENABLE : NsdManager.DISABLE);
 576     }
 577
 578     private void sendNsdStateChangeBroadcast(boolean isEnabled) {
 579         final Intent intent = new Intent(NsdManager.ACTION_NSD_STATE_CHANGED);
 580         intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
 581         int nsdState = isEnabled ? NsdManager.NSD_STATE_ENABLED : NsdManager.NSD_STATE_DISABLED;
 582         intent.putExtra(NsdManager.EXTRA_NSD_STATE, nsdState);
 583         mContext.sendStickyBroadcastAsUser(intent, UserHandle.ALL);
 584     }
 585
 586     private boolean isNsdEnabled() {
 587         boolean ret = mNsdSettings.isEnabled();
 588         if (DBG) {
 589             Slog.d(TAG, "Network service discovery is " + (ret ? "enabled" : "disabled"));
 590         }
 591         return ret;
 592     }
 593
 594     private int getUniqueId() {
 595         if (++mUniqueId == INVALID_ID) return ++mUniqueId;
 596         return mUniqueId;
 597     }
 598
 599     /* These should be in sync with system/netd/server/ResponseCode.h */
 600     static final class NativeResponseCode {
 601         public static final int SERVICE_DISCOVERY_FAILED    =   602;
 602         public static final int SERVICE_FOUND               =   603;
 603         public static final int SERVICE_LOST                =   604;
 604
 605         public static final int SERVICE_REGISTRATION_FAILED =   605;
 606         public static final int SERVICE_REGISTERED          =   606;
 607
 608         public static final int SERVICE_RESOLUTION_FAILED   =   607;
 609         public static final int SERVICE_RESOLVED            =   608;
 610
 611         public static final int SERVICE_UPDATED             =   609;
 612         public static final int SERVICE_UPDATE_FAILED       =   610;
 613
 614         public static final int SERVICE_GET_ADDR_FAILED     =   611;
 615         public static final int SERVICE_GET_ADDR_SUCCESS    =   612;
 616
 617         private static final SparseArray<String> CODE_NAMES = new SparseArray<>();
 618         static {
 619             CODE_NAMES.put(SERVICE_DISCOVERY_FAILED, "SERVICE_DISCOVERY_FAILED");
 620             CODE_NAMES.put(SERVICE_FOUND, "SERVICE_FOUND");
 621             CODE_NAMES.put(SERVICE_LOST, "SERVICE_LOST");
 622             CODE_NAMES.put(SERVICE_REGISTRATION_FAILED, "SERVICE_REGISTRATION_FAILED");
 623             CODE_NAMES.put(SERVICE_REGISTERED, "SERVICE_REGISTERED");
 624             CODE_NAMES.put(SERVICE_RESOLUTION_FAILED, "SERVICE_RESOLUTION_FAILED");
 625             CODE_NAMES.put(SERVICE_RESOLVED, "SERVICE_RESOLVED");
 626             CODE_NAMES.put(SERVICE_UPDATED, "SERVICE_UPDATED");
 627             CODE_NAMES.put(SERVICE_UPDATE_FAILED, "SERVICE_UPDATE_FAILED");
 628             CODE_NAMES.put(SERVICE_GET_ADDR_FAILED, "SERVICE_GET_ADDR_FAILED");
 629             CODE_NAMES.put(SERVICE_GET_ADDR_SUCCESS, "SERVICE_GET_ADDR_SUCCESS");
 630         }
 631
 632         static String nameOf(int code) {
 633             String name = CODE_NAMES.get(code);
 634             if (name == null) {
 635                 return Integer.toString(code);
 636             }
 637             return name;
 638         }
 639     }
 640
 641     private class NativeEvent {
 642         final int code;
 643         final String raw;
 644         final String[] cooked;
 645
 646         NativeEvent(int code, String raw, String[] cooked) {
 647             this.code = code;
 648             this.raw = raw;
 649             this.cooked = cooked;
 650         }
 651     }
 652
 653     class NativeCallbackReceiver implements INativeDaemonConnectorCallbacks {
 654         private final CountDownLatch connected = new CountDownLatch(1);
 655
 656         public void awaitConnection() throws InterruptedException {
 657             connected.await();
 658         }
 659
 660         @Override
 661         public void onDaemonConnected() {
 662             connected.countDown();
 663         }
 664
 665         @Override
 666         public boolean onCheckHoldWakeLock(int code) {
 667             return false;
 668         }
 669
 670         @Override
 671         public boolean onEvent(int code, String raw, String[] cooked) {
 672             // TODO: NDC translates a message to a callback, we could enhance NDC to
 673             // directly interact with a state machine through messages
 674             NativeEvent event = new NativeEvent(code, raw, cooked);
 675             mNsdStateMachine.sendMessage(NsdManager.NATIVE_DAEMON_EVENT, event);
 676             return true;
 677         }
 678     }
 679
 680     interface DaemonConnectionSupplier {
 681         DaemonConnection get(NativeCallbackReceiver callback);
 682     }
 683
 684     @VisibleForTesting
 685     public static class DaemonConnection {
 686         final NativeDaemonConnector mNativeConnector;
 687
 688         DaemonConnection(NativeCallbackReceiver callback) {
 689             mNativeConnector = new NativeDaemonConnector(callback, "mdns", 10, MDNS_TAG, 25, null);
 690             new Thread(mNativeConnector, MDNS_TAG).start();
 691         }
 692
 693         public boolean execute(Object... args) {
 694             if (DBG) {
 695                 Slog.d(TAG, "mdnssd " + Arrays.toString(args));
 696             }
 697             try {
 698                 mNativeConnector.execute("mdnssd", args);
 699             } catch (NativeDaemonConnectorException e) {
 700                 Slog.e(TAG, "Failed to execute mdnssd " + Arrays.toString(args), e);
 701                 return false;
 702             }
 703             return true;
 704         }
 705
 706         public void start() {
 707             execute("start-service");
 708         }
 709
 710         public void stop() {
 711             execute("stop-service");
 712         }
 713     }
 714
 715     private boolean registerService(int regId, NsdServiceInfo service) {
 716         if (DBG) {
 717             Slog.d(TAG, "registerService: " + regId + " " + service);
 718         }
 719         String name = service.getServiceName();
 720         String type = service.getServiceType();
 721         int port = service.getPort();
 722         byte[] textRecord = service.getTxtRecord();
 723         String record = Base64.encodeToString(textRecord, Base64.DEFAULT).replace("\n", "");
 724         return mDaemon.execute("register", regId, name, type, port, record);
 725     }
 726
 727     private boolean unregisterService(int regId) {
 728         return mDaemon.execute("stop-register", regId);
 729     }
 730
 731     private boolean updateService(int regId, DnsSdTxtRecord t) {
 732         if (t == null) {
 733             return false;
 734         }
 735         return mDaemon.execute("update", regId, t.size(), t.getRawData());
 736     }
 737
 738     private boolean discoverServices(int discoveryId, String serviceType) {
 739         return mDaemon.execute("discover", discoveryId, serviceType);
 740     }
 741
 742     private boolean stopServiceDiscovery(int discoveryId) {
 743         return mDaemon.execute("stop-discover", discoveryId);
 744     }
 745
 746     private boolean resolveService(int resolveId, NsdServiceInfo service) {
 747         String name = service.getServiceName();
 748         String type = service.getServiceType();
 749         return mDaemon.execute("resolve", resolveId, name, type, "local.");
 750     }
 751
 752     private boolean stopResolveService(int resolveId) {
 753         return mDaemon.execute("stop-resolve", resolveId);
 754     }
 755
 756     private boolean getAddrInfo(int resolveId, String hostname) {
 757         return mDaemon.execute("getaddrinfo", resolveId, hostname);
 758     }
 759
 760     private boolean stopGetAddrInfo(int resolveId) {
 761         return mDaemon.execute("stop-getaddrinfo", resolveId);
 762     }
 763
 764     @Override
 765     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
 766         if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return;
 767
 768         for (ClientInfo client : mClients.values()) {
 769             pw.println("Client Info");
 770             pw.println(client);
 771         }
 772
 773         mNsdStateMachine.dump(fd, pw, args);
 774     }
 775
 776     /* arg2 on the source message has an id that needs to be retained in replies
 777      * see NsdManager for details */
 778     private Message obtainMessage(Message srcMsg) {
 779         Message msg = Message.obtain();
 780         msg.arg2 = srcMsg.arg2;
 781         return msg;
 782     }
 783
 784     private void replyToMessage(Message msg, int what) {
 785         if (msg.replyTo == null) return;
 786         Message dstMsg = obtainMessage(msg);
 787         dstMsg.what = what;
 788         mReplyChannel.replyToMessage(msg, dstMsg);
 789     }
 790
 791     private void replyToMessage(Message msg, int what, int arg1) {
 792         if (msg.replyTo == null) return;
 793         Message dstMsg = obtainMessage(msg);
 794         dstMsg.what = what;
 795         dstMsg.arg1 = arg1;
 796         mReplyChannel.replyToMessage(msg, dstMsg);
 797     }
 798
 799     private void replyToMessage(Message msg, int what, Object obj) {
 800         if (msg.replyTo == null) return;
 801         Message dstMsg = obtainMessage(msg);
 802         dstMsg.what = what;
 803         dstMsg.obj = obj;
 804         mReplyChannel.replyToMessage(msg, dstMsg);
 805     }
 806
 807     /* Information tracked per client */
 808     private class ClientInfo {
 809
 810         private static final int MAX_LIMIT = 10;
 811         private final AsyncChannel mChannel;
 812         private final Messenger mMessenger;
 813         /* Remembers a resolved service until getaddrinfo completes */
 814         private NsdServiceInfo mResolvedService;
 815
 816         /* A map from client id to unique id sent to mDns */
 817         private final SparseIntArray mClientIds = new SparseIntArray();
 818
 819         /* A map from client id to the type of the request we had received */
 820         private final SparseIntArray mClientRequests = new SparseIntArray();
 821
 822         private ClientInfo(AsyncChannel c, Messenger m) {
 823             mChannel = c;
 824             mMessenger = m;
 825             if (DBG) Slog.d(TAG, "New client, channel: " + c + " messenger: " + m);
 826         }
 827
 828         @Override
 829         public String toString() {
 830             StringBuffer sb = new StringBuffer();
 831             sb.append("mChannel ").append(mChannel).append("\n");
 832             sb.append("mMessenger ").append(mMessenger).append("\n");
 833             sb.append("mResolvedService ").append(mResolvedService).append("\n");
 834             for(int i = 0; i< mClientIds.size(); i++) {
 835                 int clientID = mClientIds.keyAt(i);
 836                 sb.append("clientId ").append(clientID).
 837                     append(" mDnsId ").append(mClientIds.valueAt(i)).
 838                     append(" type ").append(mClientRequests.get(clientID)).append("\n");
 839             }
 840             return sb.toString();
 841         }
 842
 843         // Remove any pending requests from the global map when we get rid of a client,
 844         // and send cancellations to the daemon.
 845         private void expungeAllRequests() {
 846             int globalId, clientId, i;
 847             // TODO: to keep handler responsive, do not clean all requests for that client at once.
 848             for (i = 0; i < mClientIds.size(); i++) {
 849                 clientId = mClientIds.keyAt(i);
 850                 globalId = mClientIds.valueAt(i);
 851                 mIdToClientInfoMap.remove(globalId);
 852                 if (DBG) Slog.d(TAG, "Terminating client-ID " + clientId +
 853                         " global-ID " + globalId + " type " + mClientRequests.get(clientId));
 854                 switch (mClientRequests.get(clientId)) {
 855                     case NsdManager.DISCOVER_SERVICES:
 856                         stopServiceDiscovery(globalId);
 857                         break;
 858                     case NsdManager.RESOLVE_SERVICE:
 859                         stopResolveService(globalId);
 860                         break;
 861                     case NsdManager.REGISTER_SERVICE:
 862                         unregisterService(globalId);
 863                         break;
 864                     default:
 865                         break;
 866                 }
 867             }
 868             mClientIds.clear();
 869             mClientRequests.clear();
 870         }
 871
 872         // mClientIds is a sparse array of listener id -> mDnsClient id.  For a given mDnsClient id,
 873         // return the corresponding listener id.  mDnsClient id is also called a global id.
 874         private int getClientId(final int globalId) {
 875             int idx = mClientIds.indexOfValue(globalId);
 876             if (idx < 0) {
 877                 return idx;
 878             }
 879             return mClientIds.keyAt(idx);
 880         }
 881     }
 882
 883     /**
 884      * Interface which encapsulates dependencies of NsdService that are hard to mock, hard to
 885      * override, or have side effects on global state in unit tests.
 886      */
 887     @VisibleForTesting
 888     public interface NsdSettings {
 889         boolean isEnabled();
 890         void putEnabledStatus(boolean isEnabled);
 891         void registerContentObserver(Uri uri, ContentObserver observer);
 892
 893         static NsdSettings makeDefault(Context context) {
 894             final ContentResolver resolver = context.getContentResolver();
 895             return new NsdSettings() {
 896                 @Override
 897                 public boolean isEnabled() {
 898                     return Settings.Global.getInt(resolver, Settings.Global.NSD_ON, 1) == 1;
 899                 }
 900
 901                 @Override
 902                 public void putEnabledStatus(boolean isEnabled) {
 903                     Settings.Global.putInt(resolver, Settings.Global.NSD_ON, isEnabled ? 1 : 0);
 904                 }
 905
 906                 @Override
 907                 public void registerContentObserver(Uri uri, ContentObserver observer) {
 908                     resolver.registerContentObserver(uri, false, observer);
 909                 }
 910             };
 911         }
 912     }
 913 }