1 /* 2 * Copyright (C) 2007 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 com.android.internal.app.IMediaContainerService; 20 import com.android.server.am.ActivityManagerService; 21 22 import android.content.BroadcastReceiver; 23 import android.content.ComponentName; 24 import android.content.Context; 25 import android.content.Intent; 26 import android.content.IntentFilter; 27 import android.content.ServiceConnection; 28 import android.content.pm.PackageManager; 29 import android.content.res.ObbInfo; 30 import android.net.Uri; 31 import android.os.Binder; 32 import android.os.Environment; 33 import android.os.Handler; 34 import android.os.HandlerThread; 35 import android.os.IBinder; 36 import android.os.Looper; 37 import android.os.Message; 38 import android.os.RemoteException; 39 import android.os.ServiceManager; 40 import android.os.SystemClock; 41 import android.os.SystemProperties; 42 import android.os.storage.IMountService; 43 import android.os.storage.IMountServiceListener; 44 import android.os.storage.IMountShutdownObserver; 45 import android.os.storage.IObbActionListener; 46 import android.os.storage.OnObbStateChangeListener; 47 import android.os.storage.StorageResultCode; 48 import android.util.Slog; 49 50 import java.io.FileDescriptor; 51 import java.io.IOException; 52 import java.io.PrintWriter; 53 import java.math.BigInteger; 54 import java.security.NoSuchAlgorithmException; 55 import java.security.spec.InvalidKeySpecException; 56 import java.security.spec.KeySpec; 57 import java.util.ArrayList; 58 import java.util.HashMap; 59 import java.util.HashSet; 60 import java.util.Iterator; 61 import java.util.LinkedList; 62 import java.util.List; 63 import java.util.Map; 64 import java.util.Map.Entry; 65 66 import javax.crypto.SecretKey; 67 import javax.crypto.SecretKeyFactory; 68 import javax.crypto.spec.PBEKeySpec; 69 70 /** 71 * MountService implements back-end services for platform storage 72 * management. 73 * @hide - Applications should use android.os.storage.StorageManager 74 * to access the MountService. 75 */ 76 class MountService extends IMountService.Stub 77 implements INativeDaemonConnectorCallbacks { 78 private static final boolean LOCAL_LOGD = false; 79 private static final boolean DEBUG_UNMOUNT = false; 80 private static final boolean DEBUG_EVENTS = false; 81 private static final boolean DEBUG_OBB = false; 82 83 private static final String TAG = "MountService"; 84 85 private static final String VOLD_TAG = "VoldConnector"; 86 87 /* 88 * Internal vold volume state constants 89 */ 90 class VolumeState { 91 public static final int Init = -1; 92 public static final int NoMedia = 0; 93 public static final int Idle = 1; 94 public static final int Pending = 2; 95 public static final int Checking = 3; 96 public static final int Mounted = 4; 97 public static final int Unmounting = 5; 98 public static final int Formatting = 6; 99 public static final int Shared = 7; 100 public static final int SharedMnt = 8; 101 } 102 103 /* 104 * Internal vold response code constants 105 */ 106 class VoldResponseCode { 107 /* 108 * 100 series - Requestion action was initiated; expect another reply 109 * before proceeding with a new command. 110 */ 111 public static final int VolumeListResult = 110; 112 public static final int AsecListResult = 111; 113 public static final int StorageUsersListResult = 112; 114 115 /* 116 * 200 series - Requestion action has been successfully completed. 117 */ 118 public static final int ShareStatusResult = 210; 119 public static final int AsecPathResult = 211; 120 public static final int ShareEnabledResult = 212; 121 122 /* 123 * 400 series - Command was accepted, but the requested action 124 * did not take place. 125 */ 126 public static final int OpFailedNoMedia = 401; 127 public static final int OpFailedMediaBlank = 402; 128 public static final int OpFailedMediaCorrupt = 403; 129 public static final int OpFailedVolNotMounted = 404; 130 public static final int OpFailedStorageBusy = 405; 131 public static final int OpFailedStorageNotFound = 406; 132 133 /* 134 * 600 series - Unsolicited broadcasts. 135 */ 136 public static final int VolumeStateChange = 605; 137 public static final int ShareAvailabilityChange = 620; 138 public static final int VolumeDiskInserted = 630; 139 public static final int VolumeDiskRemoved = 631; 140 public static final int VolumeBadRemoval = 632; 141 } 142 143 private Context mContext; 144 private NativeDaemonConnector mConnector; 145 private String mLegacyState = Environment.MEDIA_REMOVED; 146 private PackageManagerService mPms; 147 private boolean mUmsEnabling; 148 // Used as a lock for methods that register/unregister listeners. 149 final private ArrayList<MountServiceBinderListener> mListeners = 150 new ArrayList<MountServiceBinderListener>(); 151 private boolean mBooted = false; 152 private boolean mReady = false; 153 private boolean mSendUmsConnectedOnBoot = false; 154 155 /** 156 * Private hash of currently mounted secure containers. 157 * Used as a lock in methods to manipulate secure containers. 158 */ 159 final private HashSet<String> mAsecMountSet = new HashSet<String>(); 160 161 /** 162 * The size of the crypto algorithm key in bits for OBB files. Currently 163 * Twofish is used which takes 128-bit keys. 164 */ 165 private static final int CRYPTO_ALGORITHM_KEY_SIZE = 128; 166 167 /** 168 * The number of times to run SHA1 in the PBKDF2 function for OBB files. 169 * 1024 is reasonably secure and not too slow. 170 */ 171 private static final int PBKDF2_HASH_ROUNDS = 1024; 172 173 /** 174 * Mounted OBB tracking information. Used to track the current state of all 175 * OBBs. 176 */ 177 final private Map<IBinder, List<ObbState>> mObbMounts = new HashMap<IBinder, List<ObbState>>(); 178 final private Map<String, ObbState> mObbPathToStateMap = new HashMap<String, ObbState>(); 179 180 class ObbState implements IBinder.DeathRecipient { 181 public ObbState(String filename, int callerUid, IObbActionListener token, int nonce) 182 throws RemoteException { 183 this.filename = filename; 184 this.callerUid = callerUid; 185 this.token = token; 186 this.nonce = nonce; 187 } 188 189 // OBB source filename 190 String filename; 191 192 // Binder.callingUid() 193 final public int callerUid; 194 195 // Token of remote Binder caller 196 final IObbActionListener token; 197 198 // Identifier to pass back to the token 199 final int nonce; 200 201 public IBinder getBinder() { 202 return token.asBinder(); 203 } 204 205 @Override 206 public void binderDied() { 207 ObbAction action = new UnmountObbAction(this, true); 208 mObbActionHandler.sendMessage(mObbActionHandler.obtainMessage(OBB_RUN_ACTION, action)); 209 } 210 211 public void link() throws RemoteException { 212 getBinder().linkToDeath(this, 0); 213 } 214 215 public void unlink() { 216 getBinder().unlinkToDeath(this, 0); 217 } 218 219 @Override 220 public String toString() { 221 StringBuilder sb = new StringBuilder("ObbState{"); 222 sb.append("filename="); 223 sb.append(filename); 224 sb.append(",token="); 225 sb.append(token.toString()); 226 sb.append(",callerUid="); 227 sb.append(callerUid); 228 sb.append('}'); 229 return sb.toString(); 230 } 231 } 232 233 // OBB Action Handler 234 final private ObbActionHandler mObbActionHandler; 235 236 // OBB action handler messages 237 private static final int OBB_RUN_ACTION = 1; 238 private static final int OBB_MCS_BOUND = 2; 239 private static final int OBB_MCS_UNBIND = 3; 240 private static final int OBB_MCS_RECONNECT = 4; 241 private static final int OBB_FLUSH_MOUNT_STATE = 5; 242 243 /* 244 * Default Container Service information 245 */ 246 static final ComponentName DEFAULT_CONTAINER_COMPONENT = new ComponentName( 247 "com.android.defcontainer", "com.android.defcontainer.DefaultContainerService"); 248 249 final private DefaultContainerConnection mDefContainerConn = new DefaultContainerConnection(); 250 251 class DefaultContainerConnection implements ServiceConnection { 252 public void onServiceConnected(ComponentName name, IBinder service) { 253 if (DEBUG_OBB) 254 Slog.i(TAG, "onServiceConnected"); 255 IMediaContainerService imcs = IMediaContainerService.Stub.asInterface(service); 256 mObbActionHandler.sendMessage(mObbActionHandler.obtainMessage(OBB_MCS_BOUND, imcs)); 257 } 258 259 public void onServiceDisconnected(ComponentName name) { 260 if (DEBUG_OBB) 261 Slog.i(TAG, "onServiceDisconnected"); 262 } 263 }; 264 265 // Used in the ObbActionHandler 266 private IMediaContainerService mContainerService = null; 267 268 // Handler messages 269 private static final int H_UNMOUNT_PM_UPDATE = 1; 270 private static final int H_UNMOUNT_PM_DONE = 2; 271 private static final int H_UNMOUNT_MS = 3; 272 private static final int RETRY_UNMOUNT_DELAY = 30; // in ms 273 private static final int MAX_UNMOUNT_RETRIES = 4; 274 275 class UnmountCallBack { 276 final String path; 277 final boolean force; 278 int retries; 279 280 UnmountCallBack(String path, boolean force) { 281 retries = 0; 282 this.path = path; 283 this.force = force; 284 } 285 286 void handleFinished() { 287 if (DEBUG_UNMOUNT) Slog.i(TAG, "Unmounting " + path); 288 doUnmountVolume(path, true); 289 } 290 } 291 292 class UmsEnableCallBack extends UnmountCallBack { 293 final String method; 294 295 UmsEnableCallBack(String path, String method, boolean force) { 296 super(path, force); 297 this.method = method; 298 } 299 300 @Override 301 void handleFinished() { 302 super.handleFinished(); 303 doShareUnshareVolume(path, method, true); 304 } 305 } 306 307 class ShutdownCallBack extends UnmountCallBack { 308 IMountShutdownObserver observer; 309 ShutdownCallBack(String path, IMountShutdownObserver observer) { 310 super(path, true); 311 this.observer = observer; 312 } 313 314 @Override 315 void handleFinished() { 316 int ret = doUnmountVolume(path, true); 317 if (observer != null) { 318 try { 319 observer.onShutDownComplete(ret); 320 } catch (RemoteException e) { 321 Slog.w(TAG, "RemoteException when shutting down"); 322 } 323 } 324 } 325 } 326 327 class MountServiceHandler extends Handler { 328 ArrayList<UnmountCallBack> mForceUnmounts = new ArrayList<UnmountCallBack>(); 329 boolean mUpdatingStatus = false; 330 331 MountServiceHandler(Looper l) { 332 super(l); 333 } 334 335 public void handleMessage(Message msg) { 336 switch (msg.what) { 337 case H_UNMOUNT_PM_UPDATE: { 338 if (DEBUG_UNMOUNT) Slog.i(TAG, "H_UNMOUNT_PM_UPDATE"); 339 UnmountCallBack ucb = (UnmountCallBack) msg.obj; 340 mForceUnmounts.add(ucb); 341 if (DEBUG_UNMOUNT) Slog.i(TAG, " registered = " + mUpdatingStatus); 342 // Register only if needed. 343 if (!mUpdatingStatus) { 344 if (DEBUG_UNMOUNT) Slog.i(TAG, "Updating external media status on PackageManager"); 345 mUpdatingStatus = true; 346 mPms.updateExternalMediaStatus(false, true); 347 } 348 break; 349 } 350 case H_UNMOUNT_PM_DONE: { 351 if (DEBUG_UNMOUNT) Slog.i(TAG, "H_UNMOUNT_PM_DONE"); 352 if (DEBUG_UNMOUNT) Slog.i(TAG, "Updated status. Processing requests"); 353 mUpdatingStatus = false; 354 int size = mForceUnmounts.size(); 355 int sizeArr[] = new int[size]; 356 int sizeArrN = 0; 357 // Kill processes holding references first 358 ActivityManagerService ams = (ActivityManagerService) 359 ServiceManager.getService("activity"); 360 for (int i = 0; i < size; i++) { 361 UnmountCallBack ucb = mForceUnmounts.get(i); 362 String path = ucb.path; 363 boolean done = false; 364 if (!ucb.force) { 365 done = true; 366 } else { 367 int pids[] = getStorageUsers(path); 368 if (pids == null || pids.length == 0) { 369 done = true; 370 } else { 371 // Eliminate system process here? 372 ams.killPids(pids, "unmount media"); 373 // Confirm if file references have been freed. 374 pids = getStorageUsers(path); 375 if (pids == null || pids.length == 0) { 376 done = true; 377 } 378 } 379 } 380 if (!done && (ucb.retries < MAX_UNMOUNT_RETRIES)) { 381 // Retry again 382 Slog.i(TAG, "Retrying to kill storage users again"); 383 mHandler.sendMessageDelayed( 384 mHandler.obtainMessage(H_UNMOUNT_PM_DONE, 385 ucb.retries++), 386 RETRY_UNMOUNT_DELAY); 387 } else { 388 if (ucb.retries >= MAX_UNMOUNT_RETRIES) { 389 Slog.i(TAG, "Failed to unmount media inspite of " + 390 MAX_UNMOUNT_RETRIES + " retries. Forcibly killing processes now"); 391 } 392 sizeArr[sizeArrN++] = i; 393 mHandler.sendMessage(mHandler.obtainMessage(H_UNMOUNT_MS, 394 ucb)); 395 } 396 } 397 // Remove already processed elements from list. 398 for (int i = (sizeArrN-1); i >= 0; i--) { 399 mForceUnmounts.remove(sizeArr[i]); 400 } 401 break; 402 } 403 case H_UNMOUNT_MS : { 404 if (DEBUG_UNMOUNT) Slog.i(TAG, "H_UNMOUNT_MS"); 405 UnmountCallBack ucb = (UnmountCallBack) msg.obj; 406 ucb.handleFinished(); 407 break; 408 } 409 } 410 } 411 }; 412 final private HandlerThread mHandlerThread; 413 final private Handler mHandler; 414 415 private void waitForReady() { 416 while (mReady == false) { 417 for (int retries = 5; retries > 0; retries--) { 418 if (mReady) { 419 return; 420 } 421 SystemClock.sleep(1000); 422 } 423 Slog.w(TAG, "Waiting too long for mReady!"); 424 } 425 } 426 427 private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { 428 public void onReceive(Context context, Intent intent) { 429 String action = intent.getAction(); 430 431 if (action.equals(Intent.ACTION_BOOT_COMPLETED)) { 432 mBooted = true; 433 434 /* 435 * In the simulator, we need to broadcast a volume mounted event 436 * to make the media scanner run. 437 */ 438 if ("simulator".equals(SystemProperties.get("ro.product.device"))) { 439 notifyVolumeStateChange(null, "/sdcard", VolumeState.NoMedia, VolumeState.Mounted); 440 return; 441 } 442 new Thread() { 443 public void run() { 444 try { 445 String path = Environment.getExternalStorageDirectory().getPath(); 446 String state = getVolumeState(path); 447 448 if (state.equals(Environment.MEDIA_UNMOUNTED)) { 449 int rc = doMountVolume(path); 450 if (rc != StorageResultCode.OperationSucceeded) { 451 Slog.e(TAG, String.format("Boot-time mount failed (%d)", rc)); 452 } 453 } else if (state.equals(Environment.MEDIA_SHARED)) { 454 /* 455 * Bootstrap UMS enabled state since vold indicates 456 * the volume is shared (runtime restart while ums enabled) 457 */ 458 notifyVolumeStateChange(null, path, VolumeState.NoMedia, VolumeState.Shared); 459 } 460 461 /* 462 * If UMS was connected on boot, send the connected event 463 * now that we're up. 464 */ 465 if (mSendUmsConnectedOnBoot) { 466 sendUmsIntent(true); 467 mSendUmsConnectedOnBoot = false; 468 } 469 } catch (Exception ex) { 470 Slog.e(TAG, "Boot-time mount exception", ex); 471 } 472 } 473 }.start(); 474 } 475 } 476 }; 477 478 private final class MountServiceBinderListener implements IBinder.DeathRecipient { 479 final IMountServiceListener mListener; 480 481 MountServiceBinderListener(IMountServiceListener listener) { 482 mListener = listener; 483 484 } 485 486 public void binderDied() { 487 if (LOCAL_LOGD) Slog.d(TAG, "An IMountServiceListener has died!"); 488 synchronized (mListeners) { 489 mListeners.remove(this); 490 mListener.asBinder().unlinkToDeath(this, 0); 491 } 492 } 493 } 494 495 private void doShareUnshareVolume(String path, String method, boolean enable) { 496 // TODO: Add support for multiple share methods 497 if (!method.equals("ums")) { 498 throw new IllegalArgumentException(String.format("Method %s not supported", method)); 499 } 500 501 try { 502 mConnector.doCommand(String.format( 503 "volume %sshare %s %s", (enable ? "" : "un"), path, method)); 504 } catch (NativeDaemonConnectorException e) { 505 Slog.e(TAG, "Failed to share/unshare", e); 506 } 507 } 508 509 private void updatePublicVolumeState(String path, String state) { 510 if (!path.equals(Environment.getExternalStorageDirectory().getPath())) { 511 Slog.w(TAG, "Multiple volumes not currently supported"); 512 return; 513 } 514 515 if (mLegacyState.equals(state)) { 516 Slog.w(TAG, String.format("Duplicate state transition (%s -> %s)", mLegacyState, state)); 517 return; 518 } 519 520 if (Environment.MEDIA_UNMOUNTED.equals(state)) { 521 // Tell the package manager the media is gone. 522 mPms.updateExternalMediaStatus(false, false); 523 524 /* 525 * Some OBBs might have been unmounted when this volume was 526 * unmounted, so send a message to the handler to let it know to 527 * remove those from the list of mounted OBBS. 528 */ 529 mObbActionHandler.sendMessage(mObbActionHandler.obtainMessage(OBB_FLUSH_MOUNT_STATE, 530 path)); 531 } else if (Environment.MEDIA_MOUNTED.equals(state)) { 532 // Tell the package manager the media is available for use. 533 mPms.updateExternalMediaStatus(true, false); 534 } 535 536 String oldState = mLegacyState; 537 mLegacyState = state; 538 539 synchronized (mListeners) { 540 for (int i = mListeners.size() -1; i >= 0; i--) { 541 MountServiceBinderListener bl = mListeners.get(i); 542 try { 543 bl.mListener.onStorageStateChanged(path, oldState, state); 544 } catch (RemoteException rex) { 545 Slog.e(TAG, "Listener dead"); 546 mListeners.remove(i); 547 } catch (Exception ex) { 548 Slog.e(TAG, "Listener failed", ex); 549 } 550 } 551 } 552 } 553 554 /** 555 * 556 * Callback from NativeDaemonConnector 557 */ 558 public void onDaemonConnected() { 559 /* 560 * Since we'll be calling back into the NativeDaemonConnector, 561 * we need to do our work in a new thread. 562 */ 563 new Thread() { 564 public void run() { 565 /** 566 * Determine media state and UMS detection status 567 */ 568 String path = Environment.getExternalStorageDirectory().getPath(); 569 String state = Environment.MEDIA_REMOVED; 570 571 try { 572 String[] vols = mConnector.doListCommand( 573 "volume list", VoldResponseCode.VolumeListResult); 574 for (String volstr : vols) { 575 String[] tok = volstr.split(" "); 576 // FMT: <label> <mountpoint> <state> 577 if (!tok[1].equals(path)) { 578 Slog.w(TAG, String.format( 579 "Skipping unknown volume '%s'",tok[1])); 580 continue; 581 } 582 int st = Integer.parseInt(tok[2]); 583 if (st == VolumeState.NoMedia) { 584 state = Environment.MEDIA_REMOVED; 585 } else if (st == VolumeState.Idle) { 586 state = Environment.MEDIA_UNMOUNTED; 587 } else if (st == VolumeState.Mounted) { 588 state = Environment.MEDIA_MOUNTED; 589 Slog.i(TAG, "Media already mounted on daemon connection"); 590 } else if (st == VolumeState.Shared) { 591 state = Environment.MEDIA_SHARED; 592 Slog.i(TAG, "Media shared on daemon connection"); 593 } else { 594 throw new Exception(String.format("Unexpected state %d", st)); 595 } 596 } 597 if (state != null) { 598 if (DEBUG_EVENTS) Slog.i(TAG, "Updating valid state " + state); 599 updatePublicVolumeState(path, state); 600 } 601 } catch (Exception e) { 602 Slog.e(TAG, "Error processing initial volume state", e); 603 updatePublicVolumeState(path, Environment.MEDIA_REMOVED); 604 } 605 606 try { 607 boolean avail = doGetShareMethodAvailable("ums"); 608 notifyShareAvailabilityChange("ums", avail); 609 } catch (Exception ex) { 610 Slog.w(TAG, "Failed to get share availability"); 611 } 612 /* 613 * Now that we've done our initialization, release 614 * the hounds! 615 */ 616 mReady = true; 617 } 618 }.start(); 619 } 620 621 /** 622 * Callback from NativeDaemonConnector 623 */ 624 public boolean onEvent(int code, String raw, String[] cooked) { 625 Intent in = null; 626 627 if (DEBUG_EVENTS) { 628 StringBuilder builder = new StringBuilder(); 629 builder.append("onEvent::"); 630 builder.append(" raw= " + raw); 631 if (cooked != null) { 632 builder.append(" cooked = " ); 633 for (String str : cooked) { 634 builder.append(" " + str); 635 } 636 } 637 Slog.i(TAG, builder.toString()); 638 } 639 if (code == VoldResponseCode.VolumeStateChange) { 640 /* 641 * One of the volumes we're managing has changed state. 642 * Format: "NNN Volume <label> <path> state changed 643 * from <old_#> (<old_str>) to <new_#> (<new_str>)" 644 */ 645 notifyVolumeStateChange( 646 cooked[2], cooked[3], Integer.parseInt(cooked[7]), 647 Integer.parseInt(cooked[10])); 648 } else if (code == VoldResponseCode.ShareAvailabilityChange) { 649 // FMT: NNN Share method <method> now <available|unavailable> 650 boolean avail = false; 651 if (cooked[5].equals("available")) { 652 avail = true; 653 } 654 notifyShareAvailabilityChange(cooked[3], avail); 655 } else if ((code == VoldResponseCode.VolumeDiskInserted) || 656 (code == VoldResponseCode.VolumeDiskRemoved) || 657 (code == VoldResponseCode.VolumeBadRemoval)) { 658 // FMT: NNN Volume <label> <mountpoint> disk inserted (<major>:<minor>) 659 // FMT: NNN Volume <label> <mountpoint> disk removed (<major>:<minor>) 660 // FMT: NNN Volume <label> <mountpoint> bad removal (<major>:<minor>) 661 final String label = cooked[2]; 662 final String path = cooked[3]; 663 int major = -1; 664 int minor = -1; 665 666 try { 667 String devComp = cooked[6].substring(1, cooked[6].length() -1); 668 String[] devTok = devComp.split(":"); 669 major = Integer.parseInt(devTok[0]); 670 minor = Integer.parseInt(devTok[1]); 671 } catch (Exception ex) { 672 Slog.e(TAG, "Failed to parse major/minor", ex); 673 } 674 675 if (code == VoldResponseCode.VolumeDiskInserted) { 676 new Thread() { 677 public void run() { 678 try { 679 int rc; 680 if ((rc = doMountVolume(path)) != StorageResultCode.OperationSucceeded) { 681 Slog.w(TAG, String.format("Insertion mount failed (%d)", rc)); 682 } 683 } catch (Exception ex) { 684 Slog.w(TAG, "Failed to mount media on insertion", ex); 685 } 686 } 687 }.start(); 688 } else if (code == VoldResponseCode.VolumeDiskRemoved) { 689 /* 690 * This event gets trumped if we're already in BAD_REMOVAL state 691 */ 692 if (getVolumeState(path).equals(Environment.MEDIA_BAD_REMOVAL)) { 693 return true; 694 } 695 /* Send the media unmounted event first */ 696 if (DEBUG_EVENTS) Slog.i(TAG, "Sending unmounted event first"); 697 updatePublicVolumeState(path, Environment.MEDIA_UNMOUNTED); 698 in = new Intent(Intent.ACTION_MEDIA_UNMOUNTED, Uri.parse("file://" + path)); 699 mContext.sendBroadcast(in); 700 701 if (DEBUG_EVENTS) Slog.i(TAG, "Sending media removed"); 702 updatePublicVolumeState(path, Environment.MEDIA_REMOVED); 703 in = new Intent(Intent.ACTION_MEDIA_REMOVED, Uri.parse("file://" + path)); 704 } else if (code == VoldResponseCode.VolumeBadRemoval) { 705 if (DEBUG_EVENTS) Slog.i(TAG, "Sending unmounted event first"); 706 /* Send the media unmounted event first */ 707 updatePublicVolumeState(path, Environment.MEDIA_UNMOUNTED); 708 in = new Intent(Intent.ACTION_MEDIA_UNMOUNTED, Uri.parse("file://" + path)); 709 mContext.sendBroadcast(in); 710 711 if (DEBUG_EVENTS) Slog.i(TAG, "Sending media bad removal"); 712 updatePublicVolumeState(path, Environment.MEDIA_BAD_REMOVAL); 713 in = new Intent(Intent.ACTION_MEDIA_BAD_REMOVAL, Uri.parse("file://" + path)); 714 } else { 715 Slog.e(TAG, String.format("Unknown code {%d}", code)); 716 } 717 } else { 718 return false; 719 } 720 721 if (in != null) { 722 mContext.sendBroadcast(in); 723 } 724 return true; 725 } 726 727 private void notifyVolumeStateChange(String label, String path, int oldState, int newState) { 728 String vs = getVolumeState(path); 729 if (DEBUG_EVENTS) Slog.i(TAG, "notifyVolumeStateChanged::" + vs); 730 731 Intent in = null; 732 733 if (oldState == VolumeState.Shared && newState != oldState) { 734 if (LOCAL_LOGD) Slog.d(TAG, "Sending ACTION_MEDIA_UNSHARED intent"); 735 mContext.sendBroadcast(new Intent(Intent.ACTION_MEDIA_UNSHARED, 736 Uri.parse("file://" + path))); 737 } 738 739 if (newState == VolumeState.Init) { 740 } else if (newState == VolumeState.NoMedia) { 741 // NoMedia is handled via Disk Remove events 742 } else if (newState == VolumeState.Idle) { 743 /* 744 * Don't notify if we're in BAD_REMOVAL, NOFS, UNMOUNTABLE, or 745 * if we're in the process of enabling UMS 746 */ 747 if (!vs.equals( 748 Environment.MEDIA_BAD_REMOVAL) && !vs.equals( 749 Environment.MEDIA_NOFS) && !vs.equals( 750 Environment.MEDIA_UNMOUNTABLE) && !getUmsEnabling()) { 751 if (DEBUG_EVENTS) Slog.i(TAG, "updating volume state for media bad removal nofs and unmountable"); 752 updatePublicVolumeState(path, Environment.MEDIA_UNMOUNTED); 753 in = new Intent(Intent.ACTION_MEDIA_UNMOUNTED, Uri.parse("file://" + path)); 754 } 755 } else if (newState == VolumeState.Pending) { 756 } else if (newState == VolumeState.Checking) { 757 if (DEBUG_EVENTS) Slog.i(TAG, "updating volume state checking"); 758 updatePublicVolumeState(path, Environment.MEDIA_CHECKING); 759 in = new Intent(Intent.ACTION_MEDIA_CHECKING, Uri.parse("file://" + path)); 760 } else if (newState == VolumeState.Mounted) { 761 if (DEBUG_EVENTS) Slog.i(TAG, "updating volume state mounted"); 762 updatePublicVolumeState(path, Environment.MEDIA_MOUNTED); 763 in = new Intent(Intent.ACTION_MEDIA_MOUNTED, Uri.parse("file://" + path)); 764 in.putExtra("read-only", false); 765 } else if (newState == VolumeState.Unmounting) { 766 in = new Intent(Intent.ACTION_MEDIA_EJECT, Uri.parse("file://" + path)); 767 } else if (newState == VolumeState.Formatting) { 768 } else if (newState == VolumeState.Shared) { 769 if (DEBUG_EVENTS) Slog.i(TAG, "Updating volume state media mounted"); 770 /* Send the media unmounted event first */ 771 updatePublicVolumeState(path, Environment.MEDIA_UNMOUNTED); 772 in = new Intent(Intent.ACTION_MEDIA_UNMOUNTED, Uri.parse("file://" + path)); 773 mContext.sendBroadcast(in); 774 775 if (DEBUG_EVENTS) Slog.i(TAG, "Updating media shared"); 776 updatePublicVolumeState(path, Environment.MEDIA_SHARED); 777 in = new Intent(Intent.ACTION_MEDIA_SHARED, Uri.parse("file://" + path)); 778 if (LOCAL_LOGD) Slog.d(TAG, "Sending ACTION_MEDIA_SHARED intent"); 779 } else if (newState == VolumeState.SharedMnt) { 780 Slog.e(TAG, "Live shared mounts not supported yet!"); 781 return; 782 } else { 783 Slog.e(TAG, "Unhandled VolumeState {" + newState + "}"); 784 } 785 786 if (in != null) { 787 mContext.sendBroadcast(in); 788 } 789 } 790 791 private boolean doGetShareMethodAvailable(String method) { 792 ArrayList<String> rsp; 793 try { 794 rsp = mConnector.doCommand("share status " + method); 795 } catch (NativeDaemonConnectorException ex) { 796 Slog.e(TAG, "Failed to determine whether share method " + method + " is available."); 797 return false; 798 } 799 800 for (String line : rsp) { 801 String[] tok = line.split(" "); 802 if (tok.length < 3) { 803 Slog.e(TAG, "Malformed response to share status " + method); 804 return false; 805 } 806 807 int code; 808 try { 809 code = Integer.parseInt(tok[0]); 810 } catch (NumberFormatException nfe) { 811 Slog.e(TAG, String.format("Error parsing code %s", tok[0])); 812 return false; 813 } 814 if (code == VoldResponseCode.ShareStatusResult) { 815 if (tok[2].equals("available")) 816 return true; 817 return false; 818 } else { 819 Slog.e(TAG, String.format("Unexpected response code %d", code)); 820 return false; 821 } 822 } 823 Slog.e(TAG, "Got an empty response"); 824 return false; 825 } 826 827 private int doMountVolume(String path) { 828 int rc = StorageResultCode.OperationSucceeded; 829 830 if (DEBUG_EVENTS) Slog.i(TAG, "doMountVolume: Mouting " + path); 831 try { 832 mConnector.doCommand(String.format("volume mount %s", path)); 833 } catch (NativeDaemonConnectorException e) { 834 /* 835 * Mount failed for some reason 836 */ 837 Intent in = null; 838 int code = e.getCode(); 839 if (code == VoldResponseCode.OpFailedNoMedia) { 840 /* 841 * Attempt to mount but no media inserted 842 */ 843 rc = StorageResultCode.OperationFailedNoMedia; 844 } else if (code == VoldResponseCode.OpFailedMediaBlank) { 845 if (DEBUG_EVENTS) Slog.i(TAG, " updating volume state :: media nofs"); 846 /* 847 * Media is blank or does not contain a supported filesystem 848 */ 849 updatePublicVolumeState(path, Environment.MEDIA_NOFS); 850 in = new Intent(Intent.ACTION_MEDIA_NOFS, Uri.parse("file://" + path)); 851 rc = StorageResultCode.OperationFailedMediaBlank; 852 } else if (code == VoldResponseCode.OpFailedMediaCorrupt) { 853 if (DEBUG_EVENTS) Slog.i(TAG, "updating volume state media corrupt"); 854 /* 855 * Volume consistency check failed 856 */ 857 updatePublicVolumeState(path, Environment.MEDIA_UNMOUNTABLE); 858 in = new Intent(Intent.ACTION_MEDIA_UNMOUNTABLE, Uri.parse("file://" + path)); 859 rc = StorageResultCode.OperationFailedMediaCorrupt; 860 } else { 861 rc = StorageResultCode.OperationFailedInternalError; 862 } 863 864 /* 865 * Send broadcast intent (if required for the failure) 866 */ 867 if (in != null) { 868 mContext.sendBroadcast(in); 869 } 870 } 871 872 return rc; 873 } 874 875 /* 876 * If force is not set, we do not unmount if there are 877 * processes holding references to the volume about to be unmounted. 878 * If force is set, all the processes holding references need to be 879 * killed via the ActivityManager before actually unmounting the volume. 880 * This might even take a while and might be retried after timed delays 881 * to make sure we dont end up in an instable state and kill some core 882 * processes. 883 */ 884 private int doUnmountVolume(String path, boolean force) { 885 if (!getVolumeState(path).equals(Environment.MEDIA_MOUNTED)) { 886 return VoldResponseCode.OpFailedVolNotMounted; 887 } 888 889 /* 890 * Force a GC to make sure AssetManagers in other threads of the 891 * system_server are cleaned up. We have to do this since AssetManager 892 * instances are kept as a WeakReference and it's possible we have files 893 * open on the external storage. 894 */ 895 Runtime.getRuntime().gc(); 896 897 // Redundant probably. But no harm in updating state again. 898 mPms.updateExternalMediaStatus(false, false); 899 try { 900 mConnector.doCommand(String.format( 901 "volume unmount %s%s", path, (force ? " force" : ""))); 902 // We unmounted the volume. None of the asec containers are available now. 903 synchronized (mAsecMountSet) { 904 mAsecMountSet.clear(); 905 } 906 return StorageResultCode.OperationSucceeded; 907 } catch (NativeDaemonConnectorException e) { 908 // Don't worry about mismatch in PackageManager since the 909 // call back will handle the status changes any way. 910 int code = e.getCode(); 911 if (code == VoldResponseCode.OpFailedVolNotMounted) { 912 return StorageResultCode.OperationFailedStorageNotMounted; 913 } else if (code == VoldResponseCode.OpFailedStorageBusy) { 914 return StorageResultCode.OperationFailedStorageBusy; 915 } else { 916 return StorageResultCode.OperationFailedInternalError; 917 } 918 } 919 } 920 921 private int doFormatVolume(String path) { 922 try { 923 String cmd = String.format("volume format %s", path); 924 mConnector.doCommand(cmd); 925 return StorageResultCode.OperationSucceeded; 926 } catch (NativeDaemonConnectorException e) { 927 int code = e.getCode(); 928 if (code == VoldResponseCode.OpFailedNoMedia) { 929 return StorageResultCode.OperationFailedNoMedia; 930 } else if (code == VoldResponseCode.OpFailedMediaCorrupt) { 931 return StorageResultCode.OperationFailedMediaCorrupt; 932 } else { 933 return StorageResultCode.OperationFailedInternalError; 934 } 935 } 936 } 937 938 private boolean doGetVolumeShared(String path, String method) { 939 String cmd = String.format("volume shared %s %s", path, method); 940 ArrayList<String> rsp; 941 942 try { 943 rsp = mConnector.doCommand(cmd); 944 } catch (NativeDaemonConnectorException ex) { 945 Slog.e(TAG, "Failed to read response to volume shared " + path + " " + method); 946 return false; 947 } 948 949 for (String line : rsp) { 950 String[] tok = line.split(" "); 951 if (tok.length < 3) { 952 Slog.e(TAG, "Malformed response to volume shared " + path + " " + method + " command"); 953 return false; 954 } 955 956 int code; 957 try { 958 code = Integer.parseInt(tok[0]); 959 } catch (NumberFormatException nfe) { 960 Slog.e(TAG, String.format("Error parsing code %s", tok[0])); 961 return false; 962 } 963 if (code == VoldResponseCode.ShareEnabledResult) { 964 return "enabled".equals(tok[2]); 965 } else { 966 Slog.e(TAG, String.format("Unexpected response code %d", code)); 967 return false; 968 } 969 } 970 Slog.e(TAG, "Got an empty response"); 971 return false; 972 } 973 974 private void notifyShareAvailabilityChange(String method, final boolean avail) { 975 if (!method.equals("ums")) { 976 Slog.w(TAG, "Ignoring unsupported share method {" + method + "}"); 977 return; 978 } 979 980 synchronized (mListeners) { 981 for (int i = mListeners.size() -1; i >= 0; i--) { 982 MountServiceBinderListener bl = mListeners.get(i); 983 try { 984 bl.mListener.onUsbMassStorageConnectionChanged(avail); 985 } catch (RemoteException rex) { 986 Slog.e(TAG, "Listener dead"); 987 mListeners.remove(i); 988 } catch (Exception ex) { 989 Slog.e(TAG, "Listener failed", ex); 990 } 991 } 992 } 993 994 if (mBooted == true) { 995 sendUmsIntent(avail); 996 } else { 997 mSendUmsConnectedOnBoot = avail; 998 } 999 1000 final String path = Environment.getExternalStorageDirectory().getPath(); 1001 if (avail == false && getVolumeState(path).equals(Environment.MEDIA_SHARED)) { 1002 /* 1003 * USB mass storage disconnected while enabled 1004 */ 1005 new Thread() { 1006 public void run() { 1007 try { 1008 int rc; 1009 Slog.w(TAG, "Disabling UMS after cable disconnect"); 1010 doShareUnshareVolume(path, "ums", false); 1011 if ((rc = doMountVolume(path)) != StorageResultCode.OperationSucceeded) { 1012 Slog.e(TAG, String.format( 1013 "Failed to remount {%s} on UMS enabled-disconnect (%d)", 1014 path, rc)); 1015 } 1016 } catch (Exception ex) { 1017 Slog.w(TAG, "Failed to mount media on UMS enabled-disconnect", ex); 1018 } 1019 } 1020 }.start(); 1021 } 1022 } 1023 1024 private void sendUmsIntent(boolean c) { 1025 mContext.sendBroadcast( 1026 new Intent((c ? Intent.ACTION_UMS_CONNECTED : Intent.ACTION_UMS_DISCONNECTED))); 1027 } 1028 1029 private void validatePermission(String perm) { 1030 if (mContext.checkCallingOrSelfPermission(perm) != PackageManager.PERMISSION_GRANTED) { 1031 throw new SecurityException(String.format("Requires %s permission", perm)); 1032 } 1033 } 1034 1035 /** 1036 * Constructs a new MountService instance 1037 * 1038 * @param context Binder context for this service 1039 */ 1040 public MountService(Context context) { 1041 mContext = context; 1042 1043 // XXX: This will go away soon in favor of IMountServiceObserver 1044 mPms = (PackageManagerService) ServiceManager.getService("package"); 1045 1046 mContext.registerReceiver(mBroadcastReceiver, 1047 new IntentFilter(Intent.ACTION_BOOT_COMPLETED), null, null); 1048 1049 mHandlerThread = new HandlerThread("MountService"); 1050 mHandlerThread.start(); 1051 mHandler = new MountServiceHandler(mHandlerThread.getLooper()); 1052 1053 // Add OBB Action Handler to MountService thread. 1054 mObbActionHandler = new ObbActionHandler(mHandlerThread.getLooper()); 1055 1056 /* 1057 * Vold does not run in the simulator, so pretend the connector thread 1058 * ran and did its thing. 1059 */ 1060 if ("simulator".equals(SystemProperties.get("ro.product.device"))) { 1061 mReady = true; 1062 mUmsEnabling = true; 1063 return; 1064 } 1065 1066 /* 1067 * Create the connection to vold with a maximum queue of twice the 1068 * amount of containers we'd ever expect to have. This keeps an 1069 * "asec list" from blocking a thread repeatedly. 1070 */ 1071 mConnector = new NativeDaemonConnector(this, "vold", 1072 PackageManagerService.MAX_CONTAINERS * 2, VOLD_TAG); 1073 mReady = false; 1074 Thread thread = new Thread(mConnector, VOLD_TAG); 1075 thread.start(); 1076 } 1077 1078 /** 1079 * Exposed API calls below here 1080 */ 1081 1082 public void registerListener(IMountServiceListener listener) { 1083 synchronized (mListeners) { 1084 MountServiceBinderListener bl = new MountServiceBinderListener(listener); 1085 try { 1086 listener.asBinder().linkToDeath(bl, 0); 1087 mListeners.add(bl); 1088 } catch (RemoteException rex) { 1089 Slog.e(TAG, "Failed to link to listener death"); 1090 } 1091 } 1092 } 1093 1094 public void unregisterListener(IMountServiceListener listener) { 1095 synchronized (mListeners) { 1096 for(MountServiceBinderListener bl : mListeners) { 1097 if (bl.mListener == listener) { 1098 mListeners.remove(mListeners.indexOf(bl)); 1099 return; 1100 } 1101 } 1102 } 1103 } 1104 1105 public void shutdown(final IMountShutdownObserver observer) { 1106 validatePermission(android.Manifest.permission.SHUTDOWN); 1107 1108 Slog.i(TAG, "Shutting down"); 1109 1110 String path = Environment.getExternalStorageDirectory().getPath(); 1111 String state = getVolumeState(path); 1112 1113 if (state.equals(Environment.MEDIA_SHARED)) { 1114 /* 1115 * If the media is currently shared, unshare it. 1116 * XXX: This is still dangerous!. We should not 1117 * be rebooting at *all* if UMS is enabled, since 1118 * the UMS host could have dirty FAT cache entries 1119 * yet to flush. 1120 */ 1121 setUsbMassStorageEnabled(false); 1122 } else if (state.equals(Environment.MEDIA_CHECKING)) { 1123 /* 1124 * If the media is being checked, then we need to wait for 1125 * it to complete before being able to proceed. 1126 */ 1127 // XXX: @hackbod - Should we disable the ANR timer here? 1128 int retries = 30; 1129 while (state.equals(Environment.MEDIA_CHECKING) && (retries-- >=0)) { 1130 try { 1131 Thread.sleep(1000); 1132 } catch (InterruptedException iex) { 1133 Slog.e(TAG, "Interrupted while waiting for media", iex); 1134 break; 1135 } 1136 state = Environment.getExternalStorageState(); 1137 } 1138 if (retries == 0) { 1139 Slog.e(TAG, "Timed out waiting for media to check"); 1140 } 1141 } 1142 1143 if (state.equals(Environment.MEDIA_MOUNTED)) { 1144 // Post a unmount message. 1145 ShutdownCallBack ucb = new ShutdownCallBack(path, observer); 1146 mHandler.sendMessage(mHandler.obtainMessage(H_UNMOUNT_PM_UPDATE, ucb)); 1147 } 1148 } 1149 1150 private boolean getUmsEnabling() { 1151 synchronized (mListeners) { 1152 return mUmsEnabling; 1153 } 1154 } 1155 1156 private void setUmsEnabling(boolean enable) { 1157 synchronized (mListeners) { 1158 mUmsEnabling = enable; 1159 } 1160 } 1161 1162 public boolean isUsbMassStorageConnected() { 1163 waitForReady(); 1164 1165 if (getUmsEnabling()) { 1166 return true; 1167 } 1168 return doGetShareMethodAvailable("ums"); 1169 } 1170 1171 public void setUsbMassStorageEnabled(boolean enable) { 1172 waitForReady(); 1173 validatePermission(android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS); 1174 1175 // TODO: Add support for multiple share methods 1176 1177 /* 1178 * If the volume is mounted and we're enabling then unmount it 1179 */ 1180 String path = Environment.getExternalStorageDirectory().getPath(); 1181 String vs = getVolumeState(path); 1182 String method = "ums"; 1183 if (enable && vs.equals(Environment.MEDIA_MOUNTED)) { 1184 // Override for isUsbMassStorageEnabled() 1185 setUmsEnabling(enable); 1186 UmsEnableCallBack umscb = new UmsEnableCallBack(path, method, true); 1187 mHandler.sendMessage(mHandler.obtainMessage(H_UNMOUNT_PM_UPDATE, umscb)); 1188 // Clear override 1189 setUmsEnabling(false); 1190 } 1191 /* 1192 * If we disabled UMS then mount the volume 1193 */ 1194 if (!enable) { 1195 doShareUnshareVolume(path, method, enable); 1196 if (doMountVolume(path) != StorageResultCode.OperationSucceeded) { 1197 Slog.e(TAG, "Failed to remount " + path + 1198 " after disabling share method " + method); 1199 /* 1200 * Even though the mount failed, the unshare didn't so don't indicate an error. 1201 * The mountVolume() call will have set the storage state and sent the necessary 1202 * broadcasts. 1203 */ 1204 } 1205 } 1206 } 1207 1208 public boolean isUsbMassStorageEnabled() { 1209 waitForReady(); 1210 return doGetVolumeShared(Environment.getExternalStorageDirectory().getPath(), "ums"); 1211 } 1212 1213 /** 1214 * @return state of the volume at the specified mount point 1215 */ 1216 public String getVolumeState(String mountPoint) { 1217 /* 1218 * XXX: Until we have multiple volume discovery, just hardwire 1219 * this to /sdcard 1220 */ 1221 if (!mountPoint.equals(Environment.getExternalStorageDirectory().getPath())) { 1222 Slog.w(TAG, "getVolumeState(" + mountPoint + "): Unknown volume"); 1223 throw new IllegalArgumentException(); 1224 } 1225 1226 return mLegacyState; 1227 } 1228 1229 public int mountVolume(String path) { 1230 validatePermission(android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS); 1231 1232 waitForReady(); 1233 return doMountVolume(path); 1234 } 1235 1236 public void unmountVolume(String path, boolean force) { 1237 validatePermission(android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS); 1238 waitForReady(); 1239 1240 String volState = getVolumeState(path); 1241 if (DEBUG_UNMOUNT) Slog.i(TAG, "Unmounting " + path + " force = " + force); 1242 if (Environment.MEDIA_UNMOUNTED.equals(volState) || 1243 Environment.MEDIA_REMOVED.equals(volState) || 1244 Environment.MEDIA_SHARED.equals(volState) || 1245 Environment.MEDIA_UNMOUNTABLE.equals(volState)) { 1246 // Media already unmounted or cannot be unmounted. 1247 // TODO return valid return code when adding observer call back. 1248 return; 1249 } 1250 UnmountCallBack ucb = new UnmountCallBack(path, force); 1251 mHandler.sendMessage(mHandler.obtainMessage(H_UNMOUNT_PM_UPDATE, ucb)); 1252 } 1253 1254 public int formatVolume(String path) { 1255 validatePermission(android.Manifest.permission.MOUNT_FORMAT_FILESYSTEMS); 1256 waitForReady(); 1257 1258 return doFormatVolume(path); 1259 } 1260 1261 public int []getStorageUsers(String path) { 1262 validatePermission(android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS); 1263 waitForReady(); 1264 try { 1265 String[] r = mConnector.doListCommand( 1266 String.format("storage users %s", path), 1267 VoldResponseCode.StorageUsersListResult); 1268 // FMT: <pid> <process name> 1269 int[] data = new int[r.length]; 1270 for (int i = 0; i < r.length; i++) { 1271 String []tok = r[i].split(" "); 1272 try { 1273 data[i] = Integer.parseInt(tok[0]); 1274 } catch (NumberFormatException nfe) { 1275 Slog.e(TAG, String.format("Error parsing pid %s", tok[0])); 1276 return new int[0]; 1277 } 1278 } 1279 return data; 1280 } catch (NativeDaemonConnectorException e) { 1281 Slog.e(TAG, "Failed to retrieve storage users list", e); 1282 return new int[0]; 1283 } 1284 } 1285 1286 private void warnOnNotMounted() { 1287 if (!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { 1288 Slog.w(TAG, "getSecureContainerList() called when storage not mounted"); 1289 } 1290 } 1291 1292 public String[] getSecureContainerList() { 1293 validatePermission(android.Manifest.permission.ASEC_ACCESS); 1294 waitForReady(); 1295 warnOnNotMounted(); 1296 1297 try { 1298 return mConnector.doListCommand("asec list", VoldResponseCode.AsecListResult); 1299 } catch (NativeDaemonConnectorException e) { 1300 return new String[0]; 1301 } 1302 } 1303 1304 public int createSecureContainer(String id, int sizeMb, String fstype, 1305 String key, int ownerUid) { 1306 validatePermission(android.Manifest.permission.ASEC_CREATE); 1307 waitForReady(); 1308 warnOnNotMounted(); 1309 1310 int rc = StorageResultCode.OperationSucceeded; 1311 String cmd = String.format("asec create %s %d %s %s %d", id, sizeMb, fstype, key, ownerUid); 1312 try { 1313 mConnector.doCommand(cmd); 1314 } catch (NativeDaemonConnectorException e) { 1315 rc = StorageResultCode.OperationFailedInternalError; 1316 } 1317 1318 if (rc == StorageResultCode.OperationSucceeded) { 1319 synchronized (mAsecMountSet) { 1320 mAsecMountSet.add(id); 1321 } 1322 } 1323 return rc; 1324 } 1325 1326 public int finalizeSecureContainer(String id) { 1327 validatePermission(android.Manifest.permission.ASEC_CREATE); 1328 warnOnNotMounted(); 1329 1330 int rc = StorageResultCode.OperationSucceeded; 1331 try { 1332 mConnector.doCommand(String.format("asec finalize %s", id)); 1333 /* 1334 * Finalization does a remount, so no need 1335 * to update mAsecMountSet 1336 */ 1337 } catch (NativeDaemonConnectorException e) { 1338 rc = StorageResultCode.OperationFailedInternalError; 1339 } 1340 return rc; 1341 } 1342 1343 public int destroySecureContainer(String id, boolean force) { 1344 validatePermission(android.Manifest.permission.ASEC_DESTROY); 1345 waitForReady(); 1346 warnOnNotMounted(); 1347 1348 /* 1349 * Force a GC to make sure AssetManagers in other threads of the 1350 * system_server are cleaned up. We have to do this since AssetManager 1351 * instances are kept as a WeakReference and it's possible we have files 1352 * open on the external storage. 1353 */ 1354 Runtime.getRuntime().gc(); 1355 1356 int rc = StorageResultCode.OperationSucceeded; 1357 try { 1358 mConnector.doCommand(String.format("asec destroy %s%s", id, (force ? " force" : ""))); 1359 } catch (NativeDaemonConnectorException e) { 1360 int code = e.getCode(); 1361 if (code == VoldResponseCode.OpFailedStorageBusy) { 1362 rc = StorageResultCode.OperationFailedStorageBusy; 1363 } else { 1364 rc = StorageResultCode.OperationFailedInternalError; 1365 } 1366 } 1367 1368 if (rc == StorageResultCode.OperationSucceeded) { 1369 synchronized (mAsecMountSet) { 1370 if (mAsecMountSet.contains(id)) { 1371 mAsecMountSet.remove(id); 1372 } 1373 } 1374 } 1375 1376 return rc; 1377 } 1378 1379 public int mountSecureContainer(String id, String key, int ownerUid) { 1380 validatePermission(android.Manifest.permission.ASEC_MOUNT_UNMOUNT); 1381 waitForReady(); 1382 warnOnNotMounted(); 1383 1384 synchronized (mAsecMountSet) { 1385 if (mAsecMountSet.contains(id)) { 1386 return StorageResultCode.OperationFailedStorageMounted; 1387 } 1388 } 1389 1390 int rc = StorageResultCode.OperationSucceeded; 1391 String cmd = String.format("asec mount %s %s %d", id, key, ownerUid); 1392 try { 1393 mConnector.doCommand(cmd); 1394 } catch (NativeDaemonConnectorException e) { 1395 int code = e.getCode(); 1396 if (code != VoldResponseCode.OpFailedStorageBusy) { 1397 rc = StorageResultCode.OperationFailedInternalError; 1398 } 1399 } 1400 1401 if (rc == StorageResultCode.OperationSucceeded) { 1402 synchronized (mAsecMountSet) { 1403 mAsecMountSet.add(id); 1404 } 1405 } 1406 return rc; 1407 } 1408 1409 public int unmountSecureContainer(String id, boolean force) { 1410 validatePermission(android.Manifest.permission.ASEC_MOUNT_UNMOUNT); 1411 waitForReady(); 1412 warnOnNotMounted(); 1413 1414 synchronized (mAsecMountSet) { 1415 if (!mAsecMountSet.contains(id)) { 1416 return StorageResultCode.OperationFailedStorageNotMounted; 1417 } 1418 } 1419 1420 /* 1421 * Force a GC to make sure AssetManagers in other threads of the 1422 * system_server are cleaned up. We have to do this since AssetManager 1423 * instances are kept as a WeakReference and it's possible we have files 1424 * open on the external storage. 1425 */ 1426 Runtime.getRuntime().gc(); 1427 1428 int rc = StorageResultCode.OperationSucceeded; 1429 String cmd = String.format("asec unmount %s%s", id, (force ? " force" : "")); 1430 try { 1431 mConnector.doCommand(cmd); 1432 } catch (NativeDaemonConnectorException e) { 1433 int code = e.getCode(); 1434 if (code == VoldResponseCode.OpFailedStorageBusy) { 1435 rc = StorageResultCode.OperationFailedStorageBusy; 1436 } else { 1437 rc = StorageResultCode.OperationFailedInternalError; 1438 } 1439 } 1440 1441 if (rc == StorageResultCode.OperationSucceeded) { 1442 synchronized (mAsecMountSet) { 1443 mAsecMountSet.remove(id); 1444 } 1445 } 1446 return rc; 1447 } 1448 1449 public boolean isSecureContainerMounted(String id) { 1450 validatePermission(android.Manifest.permission.ASEC_ACCESS); 1451 waitForReady(); 1452 warnOnNotMounted(); 1453 1454 synchronized (mAsecMountSet) { 1455 return mAsecMountSet.contains(id); 1456 } 1457 } 1458 1459 public int renameSecureContainer(String oldId, String newId) { 1460 validatePermission(android.Manifest.permission.ASEC_RENAME); 1461 waitForReady(); 1462 warnOnNotMounted(); 1463 1464 synchronized (mAsecMountSet) { 1465 /* 1466 * Because a mounted container has active internal state which cannot be 1467 * changed while active, we must ensure both ids are not currently mounted. 1468 */ 1469 if (mAsecMountSet.contains(oldId) || mAsecMountSet.contains(newId)) { 1470 return StorageResultCode.OperationFailedStorageMounted; 1471 } 1472 } 1473 1474 int rc = StorageResultCode.OperationSucceeded; 1475 String cmd = String.format("asec rename %s %s", oldId, newId); 1476 try { 1477 mConnector.doCommand(cmd); 1478 } catch (NativeDaemonConnectorException e) { 1479 rc = StorageResultCode.OperationFailedInternalError; 1480 } 1481 1482 return rc; 1483 } 1484 1485 public String getSecureContainerPath(String id) { 1486 validatePermission(android.Manifest.permission.ASEC_ACCESS); 1487 waitForReady(); 1488 warnOnNotMounted(); 1489 1490 try { 1491 ArrayList<String> rsp = mConnector.doCommand(String.format("asec path %s", id)); 1492 String []tok = rsp.get(0).split(" "); 1493 int code = Integer.parseInt(tok[0]); 1494 if (code != VoldResponseCode.AsecPathResult) { 1495 throw new IllegalStateException(String.format("Unexpected response code %d", code)); 1496 } 1497 return tok[1]; 1498 } catch (NativeDaemonConnectorException e) { 1499 int code = e.getCode(); 1500 if (code == VoldResponseCode.OpFailedStorageNotFound) { 1501 throw new IllegalArgumentException(String.format("Container '%s' not found", id)); 1502 } else { 1503 throw new IllegalStateException(String.format("Unexpected response code %d", code)); 1504 } 1505 } 1506 } 1507 1508 public void finishMediaUpdate() { 1509 mHandler.sendEmptyMessage(H_UNMOUNT_PM_DONE); 1510 } 1511 1512 private boolean isUidOwnerOfPackageOrSystem(String packageName, int callerUid) { 1513 if (callerUid == android.os.Process.SYSTEM_UID) { 1514 return true; 1515 } 1516 1517 if (packageName == null) { 1518 return false; 1519 } 1520 1521 final int packageUid = mPms.getPackageUid(packageName); 1522 1523 if (DEBUG_OBB) { 1524 Slog.d(TAG, "packageName = " + packageName + ", packageUid = " + 1525 packageUid + ", callerUid = " + callerUid); 1526 } 1527 1528 return callerUid == packageUid; 1529 } 1530 1531 public String getMountedObbPath(String filename) { 1532 if (filename == null) { 1533 throw new IllegalArgumentException("filename cannot be null"); 1534 } 1535 1536 waitForReady(); 1537 warnOnNotMounted(); 1538 1539 try { 1540 ArrayList<String> rsp = mConnector.doCommand(String.format("obb path %s", filename)); 1541 String []tok = rsp.get(0).split(" "); 1542 int code = Integer.parseInt(tok[0]); 1543 if (code != VoldResponseCode.AsecPathResult) { 1544 throw new IllegalStateException(String.format("Unexpected response code %d", code)); 1545 } 1546 return tok[1]; 1547 } catch (NativeDaemonConnectorException e) { 1548 int code = e.getCode(); 1549 if (code == VoldResponseCode.OpFailedStorageNotFound) { 1550 return null; 1551 } else { 1552 throw new IllegalStateException(String.format("Unexpected response code %d", code)); 1553 } 1554 } 1555 } 1556 1557 public boolean isObbMounted(String filename) { 1558 if (filename == null) { 1559 throw new IllegalArgumentException("filename cannot be null"); 1560 } 1561 1562 synchronized (mObbMounts) { 1563 return mObbPathToStateMap.containsKey(filename); 1564 } 1565 } 1566 1567 public void mountObb(String filename, String key, IObbActionListener token, int nonce) 1568 throws RemoteException { 1569 if (filename == null) { 1570 throw new IllegalArgumentException("filename cannot be null"); 1571 } 1572 1573 if (token == null) { 1574 throw new IllegalArgumentException("token cannot be null"); 1575 } 1576 1577 final int callerUid = Binder.getCallingUid(); 1578 final ObbState obbState = new ObbState(filename, callerUid, token, nonce); 1579 final ObbAction action = new MountObbAction(obbState, key); 1580 mObbActionHandler.sendMessage(mObbActionHandler.obtainMessage(OBB_RUN_ACTION, action)); 1581 1582 if (DEBUG_OBB) 1583 Slog.i(TAG, "Send to OBB handler: " + action.toString()); 1584 } 1585 1586 public void unmountObb(String filename, boolean force, IObbActionListener token, int nonce) 1587 throws RemoteException { 1588 if (filename == null) { 1589 throw new IllegalArgumentException("filename cannot be null"); 1590 } 1591 1592 final int callerUid = Binder.getCallingUid(); 1593 final ObbState obbState = new ObbState(filename, callerUid, token, nonce); 1594 final ObbAction action = new UnmountObbAction(obbState, force); 1595 mObbActionHandler.sendMessage(mObbActionHandler.obtainMessage(OBB_RUN_ACTION, action)); 1596 1597 if (DEBUG_OBB) 1598 Slog.i(TAG, "Send to OBB handler: " + action.toString()); 1599 } 1600 1601 private void addObbStateLocked(ObbState obbState) throws RemoteException { 1602 final IBinder binder = obbState.getBinder(); 1603 List<ObbState> obbStates = mObbMounts.get(binder); 1604 1605 if (obbStates == null) { 1606 obbStates = new ArrayList<ObbState>(); 1607 mObbMounts.put(binder, obbStates); 1608 } else { 1609 for (final ObbState o : obbStates) { 1610 if (o.filename.equals(obbState.filename)) { 1611 throw new IllegalStateException("Attempt to add ObbState twice. " 1612 + "This indicates an error in the MountService logic."); 1613 } 1614 } 1615 } 1616 1617 obbStates.add(obbState); 1618 try { 1619 obbState.link(); 1620 } catch (RemoteException e) { 1621 /* 1622 * The binder died before we could link it, so clean up our state 1623 * and return failure. 1624 */ 1625 obbStates.remove(obbState); 1626 if (obbStates.isEmpty()) { 1627 mObbMounts.remove(binder); 1628 } 1629 1630 // Rethrow the error so mountObb can get it 1631 throw e; 1632 } 1633 1634 mObbPathToStateMap.put(obbState.filename, obbState); 1635 } 1636 1637 private void removeObbStateLocked(ObbState obbState) { 1638 final IBinder binder = obbState.getBinder(); 1639 final List<ObbState> obbStates = mObbMounts.get(binder); 1640 if (obbStates != null) { 1641 if (obbStates.remove(obbState)) { 1642 obbState.unlink(); 1643 } 1644 if (obbStates.isEmpty()) { 1645 mObbMounts.remove(binder); 1646 } 1647 } 1648 1649 mObbPathToStateMap.remove(obbState.filename); 1650 } 1651 1652 private class ObbActionHandler extends Handler { 1653 private boolean mBound = false; 1654 private final List<ObbAction> mActions = new LinkedList<ObbAction>(); 1655 1656 ObbActionHandler(Looper l) { 1657 super(l); 1658 } 1659 1660 @Override 1661 public void handleMessage(Message msg) { 1662 switch (msg.what) { 1663 case OBB_RUN_ACTION: { 1664 final ObbAction action = (ObbAction) msg.obj; 1665 1666 if (DEBUG_OBB) 1667 Slog.i(TAG, "OBB_RUN_ACTION: " + action.toString()); 1668 1669 // If a bind was already initiated we don't really 1670 // need to do anything. The pending install 1671 // will be processed later on. 1672 if (!mBound) { 1673 // If this is the only one pending we might 1674 // have to bind to the service again. 1675 if (!connectToService()) { 1676 Slog.e(TAG, "Failed to bind to media container service"); 1677 action.handleError(); 1678 return; 1679 } 1680 } 1681 1682 mActions.add(action); 1683 break; 1684 } 1685 case OBB_MCS_BOUND: { 1686 if (DEBUG_OBB) 1687 Slog.i(TAG, "OBB_MCS_BOUND"); 1688 if (msg.obj != null) { 1689 mContainerService = (IMediaContainerService) msg.obj; 1690 } 1691 if (mContainerService == null) { 1692 // Something seriously wrong. Bail out 1693 Slog.e(TAG, "Cannot bind to media container service"); 1694 for (ObbAction action : mActions) { 1695 // Indicate service bind error 1696 action.handleError(); 1697 } 1698 mActions.clear(); 1699 } else if (mActions.size() > 0) { 1700 final ObbAction action = mActions.get(0); 1701 if (action != null) { 1702 action.execute(this); 1703 } 1704 } else { 1705 // Should never happen ideally. 1706 Slog.w(TAG, "Empty queue"); 1707 } 1708 break; 1709 } 1710 case OBB_MCS_RECONNECT: { 1711 if (DEBUG_OBB) 1712 Slog.i(TAG, "OBB_MCS_RECONNECT"); 1713 if (mActions.size() > 0) { 1714 if (mBound) { 1715 disconnectService(); 1716 } 1717 if (!connectToService()) { 1718 Slog.e(TAG, "Failed to bind to media container service"); 1719 for (ObbAction action : mActions) { 1720 // Indicate service bind error 1721 action.handleError(); 1722 } 1723 mActions.clear(); 1724 } 1725 } 1726 break; 1727 } 1728 case OBB_MCS_UNBIND: { 1729 if (DEBUG_OBB) 1730 Slog.i(TAG, "OBB_MCS_UNBIND"); 1731 1732 // Delete pending install 1733 if (mActions.size() > 0) { 1734 mActions.remove(0); 1735 } 1736 if (mActions.size() == 0) { 1737 if (mBound) { 1738 disconnectService(); 1739 } 1740 } else { 1741 // There are more pending requests in queue. 1742 // Just post MCS_BOUND message to trigger processing 1743 // of next pending install. 1744 mObbActionHandler.sendEmptyMessage(OBB_MCS_BOUND); 1745 } 1746 break; 1747 } 1748 case OBB_FLUSH_MOUNT_STATE: { 1749 final String path = (String) msg.obj; 1750 1751 if (DEBUG_OBB) 1752 Slog.i(TAG, "Flushing all OBB state for path " + path); 1753 1754 synchronized (mObbMounts) { 1755 final List<ObbState> obbStatesToRemove = new LinkedList<ObbState>(); 1756 1757 final Iterator<Entry<String, ObbState>> i = 1758 mObbPathToStateMap.entrySet().iterator(); 1759 while (i.hasNext()) { 1760 final Entry<String, ObbState> obbEntry = i.next(); 1761 1762 /* 1763 * If this entry's source file is in the volume path 1764 * that got unmounted, remove it because it's no 1765 * longer valid. 1766 */ 1767 if (obbEntry.getKey().startsWith(path)) { 1768 obbStatesToRemove.add(obbEntry.getValue()); 1769 } 1770 } 1771 1772 for (final ObbState obbState : obbStatesToRemove) { 1773 if (DEBUG_OBB) 1774 Slog.i(TAG, "Removing state for " + obbState.filename); 1775 1776 removeObbStateLocked(obbState); 1777 1778 try { 1779 obbState.token.onObbResult(obbState.filename, obbState.nonce, 1780 OnObbStateChangeListener.UNMOUNTED); 1781 } catch (RemoteException e) { 1782 Slog.i(TAG, "Couldn't send unmount notification for OBB: " 1783 + obbState.filename); 1784 } 1785 } 1786 } 1787 break; 1788 } 1789 } 1790 } 1791 1792 private boolean connectToService() { 1793 if (DEBUG_OBB) 1794 Slog.i(TAG, "Trying to bind to DefaultContainerService"); 1795 1796 Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT); 1797 if (mContext.bindService(service, mDefContainerConn, Context.BIND_AUTO_CREATE)) { 1798 mBound = true; 1799 return true; 1800 } 1801 return false; 1802 } 1803 1804 private void disconnectService() { 1805 mContainerService = null; 1806 mBound = false; 1807 mContext.unbindService(mDefContainerConn); 1808 } 1809 } 1810 1811 abstract class ObbAction { 1812 private static final int MAX_RETRIES = 3; 1813 private int mRetries; 1814 1815 ObbState mObbState; 1816 1817 ObbAction(ObbState obbState) { 1818 mObbState = obbState; 1819 } 1820 1821 public void execute(ObbActionHandler handler) { 1822 try { 1823 if (DEBUG_OBB) 1824 Slog.i(TAG, "Starting to execute action: " + this.toString()); 1825 mRetries++; 1826 if (mRetries > MAX_RETRIES) { 1827 Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up"); 1828 mObbActionHandler.sendEmptyMessage(OBB_MCS_UNBIND); 1829 handleError(); 1830 return; 1831 } else { 1832 handleExecute(); 1833 if (DEBUG_OBB) 1834 Slog.i(TAG, "Posting install MCS_UNBIND"); 1835 mObbActionHandler.sendEmptyMessage(OBB_MCS_UNBIND); 1836 } 1837 } catch (RemoteException e) { 1838 if (DEBUG_OBB) 1839 Slog.i(TAG, "Posting install MCS_RECONNECT"); 1840 mObbActionHandler.sendEmptyMessage(OBB_MCS_RECONNECT); 1841 } catch (Exception e) { 1842 if (DEBUG_OBB) 1843 Slog.d(TAG, "Error handling OBB action", e); 1844 handleError(); 1845 mObbActionHandler.sendEmptyMessage(OBB_MCS_UNBIND); 1846 } 1847 } 1848 1849 abstract void handleExecute() throws RemoteException, IOException; 1850 abstract void handleError(); 1851 1852 protected ObbInfo getObbInfo() throws IOException { 1853 ObbInfo obbInfo; 1854 try { 1855 obbInfo = mContainerService.getObbInfo(mObbState.filename); 1856 } catch (RemoteException e) { 1857 Slog.d(TAG, "Couldn't call DefaultContainerService to fetch OBB info for " 1858 + mObbState.filename); 1859 obbInfo = null; 1860 } 1861 if (obbInfo == null) { 1862 throw new IOException("Couldn't read OBB file: " + mObbState.filename); 1863 } 1864 return obbInfo; 1865 } 1866 1867 protected void sendNewStatusOrIgnore(int status) { 1868 if (mObbState == null || mObbState.token == null) { 1869 return; 1870 } 1871 1872 try { 1873 mObbState.token.onObbResult(mObbState.filename, mObbState.nonce, status); 1874 } catch (RemoteException e) { 1875 Slog.w(TAG, "MountServiceListener went away while calling onObbStateChanged"); 1876 } 1877 } 1878 } 1879 1880 class MountObbAction extends ObbAction { 1881 private String mKey; 1882 1883 MountObbAction(ObbState obbState, String key) { 1884 super(obbState); 1885 mKey = key; 1886 } 1887 1888 public void handleExecute() throws IOException, RemoteException { 1889 waitForReady(); 1890 warnOnNotMounted(); 1891 1892 final ObbInfo obbInfo = getObbInfo(); 1893 1894 if (!isUidOwnerOfPackageOrSystem(obbInfo.packageName, mObbState.callerUid)) { 1895 Slog.w(TAG, "Denied attempt to mount OBB " + obbInfo.filename 1896 + " which is owned by " + obbInfo.packageName); 1897 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_PERMISSION_DENIED); 1898 return; 1899 } 1900 1901 final boolean isMounted; 1902 synchronized (mObbMounts) { 1903 isMounted = mObbPathToStateMap.containsKey(obbInfo.filename); 1904 } 1905 if (isMounted) { 1906 Slog.w(TAG, "Attempt to mount OBB which is already mounted: " + obbInfo.filename); 1907 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_ALREADY_MOUNTED); 1908 return; 1909 } 1910 1911 /* 1912 * The filename passed in might not be the canonical name, so just 1913 * set the filename to the canonicalized version. 1914 */ 1915 mObbState.filename = obbInfo.filename; 1916 1917 final String hashedKey; 1918 if (mKey == null) { 1919 hashedKey = "none"; 1920 } else { 1921 try { 1922 SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1"); 1923 1924 KeySpec ks = new PBEKeySpec(mKey.toCharArray(), obbInfo.salt, 1925 PBKDF2_HASH_ROUNDS, CRYPTO_ALGORITHM_KEY_SIZE); 1926 SecretKey key = factory.generateSecret(ks); 1927 BigInteger bi = new BigInteger(key.getEncoded()); 1928 hashedKey = bi.toString(16); 1929 } catch (NoSuchAlgorithmException e) { 1930 Slog.e(TAG, "Could not load PBKDF2 algorithm", e); 1931 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_INTERNAL); 1932 return; 1933 } catch (InvalidKeySpecException e) { 1934 Slog.e(TAG, "Invalid key spec when loading PBKDF2 algorithm", e); 1935 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_INTERNAL); 1936 return; 1937 } 1938 } 1939 1940 int rc = StorageResultCode.OperationSucceeded; 1941 String cmd = String.format("obb mount %s %s %d", mObbState.filename, hashedKey, 1942 mObbState.callerUid); 1943 try { 1944 mConnector.doCommand(cmd); 1945 } catch (NativeDaemonConnectorException e) { 1946 int code = e.getCode(); 1947 if (code != VoldResponseCode.OpFailedStorageBusy) { 1948 rc = StorageResultCode.OperationFailedInternalError; 1949 } 1950 } 1951 1952 if (rc == StorageResultCode.OperationSucceeded) { 1953 if (DEBUG_OBB) 1954 Slog.d(TAG, "Successfully mounted OBB " + mObbState.filename); 1955 1956 synchronized (mObbMounts) { 1957 addObbStateLocked(mObbState); 1958 } 1959 1960 sendNewStatusOrIgnore(OnObbStateChangeListener.MOUNTED); 1961 } else { 1962 Slog.e(TAG, "Couldn't mount OBB file: " + rc); 1963 1964 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_COULD_NOT_MOUNT); 1965 } 1966 } 1967 1968 public void handleError() { 1969 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_INTERNAL); 1970 } 1971 1972 @Override 1973 public String toString() { 1974 StringBuilder sb = new StringBuilder(); 1975 sb.append("MountObbAction{"); 1976 sb.append("filename="); 1977 sb.append(mObbState.filename); 1978 sb.append(",callerUid="); 1979 sb.append(mObbState.callerUid); 1980 sb.append(",token="); 1981 sb.append(mObbState.token != null ? mObbState.token.toString() : "NULL"); 1982 sb.append(",binder="); 1983 sb.append(mObbState.token != null ? mObbState.getBinder().toString() : "null"); 1984 sb.append('}'); 1985 return sb.toString(); 1986 } 1987 } 1988 1989 class UnmountObbAction extends ObbAction { 1990 private boolean mForceUnmount; 1991 1992 UnmountObbAction(ObbState obbState, boolean force) { 1993 super(obbState); 1994 mForceUnmount = force; 1995 } 1996 1997 public void handleExecute() throws IOException { 1998 waitForReady(); 1999 warnOnNotMounted(); 2000 2001 final ObbInfo obbInfo = getObbInfo(); 2002 2003 final ObbState obbState; 2004 synchronized (mObbMounts) { 2005 obbState = mObbPathToStateMap.get(obbInfo.filename); 2006 } 2007 2008 if (obbState == null) { 2009 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_NOT_MOUNTED); 2010 return; 2011 } 2012 2013 if (obbState.callerUid != mObbState.callerUid) { 2014 Slog.w(TAG, "Permission denied attempting to unmount OBB " + obbInfo.filename 2015 + " (owned by " + obbInfo.packageName + ")"); 2016 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_PERMISSION_DENIED); 2017 return; 2018 } 2019 2020 mObbState.filename = obbInfo.filename; 2021 2022 int rc = StorageResultCode.OperationSucceeded; 2023 String cmd = String.format("obb unmount %s%s", mObbState.filename, 2024 (mForceUnmount ? " force" : "")); 2025 try { 2026 mConnector.doCommand(cmd); 2027 } catch (NativeDaemonConnectorException e) { 2028 int code = e.getCode(); 2029 if (code == VoldResponseCode.OpFailedStorageBusy) { 2030 rc = StorageResultCode.OperationFailedStorageBusy; 2031 } else if (code == VoldResponseCode.OpFailedStorageNotFound) { 2032 // If it's not mounted then we've already won. 2033 rc = StorageResultCode.OperationSucceeded; 2034 } else { 2035 rc = StorageResultCode.OperationFailedInternalError; 2036 } 2037 } 2038 2039 if (rc == StorageResultCode.OperationSucceeded) { 2040 synchronized (mObbMounts) { 2041 removeObbStateLocked(obbState); 2042 } 2043 2044 sendNewStatusOrIgnore(OnObbStateChangeListener.UNMOUNTED); 2045 } else { 2046 Slog.w(TAG, "Could not mount OBB: " + mObbState.filename); 2047 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_COULD_NOT_UNMOUNT); 2048 } 2049 } 2050 2051 public void handleError() { 2052 sendNewStatusOrIgnore(OnObbStateChangeListener.ERROR_INTERNAL); 2053 } 2054 2055 @Override 2056 public String toString() { 2057 StringBuilder sb = new StringBuilder(); 2058 sb.append("UnmountObbAction{"); 2059 sb.append("filename="); 2060 sb.append(mObbState.filename != null ? mObbState.filename : "null"); 2061 sb.append(",force="); 2062 sb.append(mForceUnmount); 2063 sb.append(",callerUid="); 2064 sb.append(mObbState.callerUid); 2065 sb.append(",token="); 2066 sb.append(mObbState.token != null ? mObbState.token.toString() : "null"); 2067 sb.append(",binder="); 2068 sb.append(mObbState.token != null ? mObbState.getBinder().toString() : "null"); 2069 sb.append('}'); 2070 return sb.toString(); 2071 } 2072 } 2073 2074 @Override 2075 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 2076 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) != PackageManager.PERMISSION_GRANTED) { 2077 pw.println("Permission Denial: can't dump ActivityManager from from pid=" 2078 + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid() 2079 + " without permission " + android.Manifest.permission.DUMP); 2080 return; 2081 } 2082 2083 synchronized (mObbMounts) { 2084 pw.println(" mObbMounts:"); 2085 2086 final Iterator<Entry<IBinder, List<ObbState>>> binders = mObbMounts.entrySet().iterator(); 2087 while (binders.hasNext()) { 2088 Entry<IBinder, List<ObbState>> e = binders.next(); 2089 pw.print(" Key="); pw.println(e.getKey().toString()); 2090 final List<ObbState> obbStates = e.getValue(); 2091 for (final ObbState obbState : obbStates) { 2092 pw.print(" "); pw.println(obbState.toString()); 2093 } 2094 } 2095 2096 pw.println(""); 2097 pw.println(" mObbPathToStateMap:"); 2098 final Iterator<Entry<String, ObbState>> maps = mObbPathToStateMap.entrySet().iterator(); 2099 while (maps.hasNext()) { 2100 final Entry<String, ObbState> e = maps.next(); 2101 pw.print(" "); pw.print(e.getKey()); 2102 pw.print(" -> "); pw.println(e.getValue().toString()); 2103 } 2104 } 2105 } 2106 } 2107 2108
