services/core/java/com/android/server/content/ContentService.java

   1 /*
   2  * Copyright (C) 2006 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.content;
  18
  19 import android.Manifest;
  20 import android.accounts.Account;
  21 import android.app.ActivityManager;
  22 import android.content.ComponentName;
  23 import android.content.ContentResolver;
  24 import android.content.Context;
  25 import android.content.IContentService;
  26 import android.content.Intent;
  27 import android.content.ISyncStatusObserver;
  28 import android.content.PeriodicSync;
  29 import android.content.SyncAdapterType;
  30 import android.content.SyncInfo;
  31 import android.content.SyncRequest;
  32 import android.content.SyncStatusInfo;
  33 import android.content.pm.PackageManager;
  34 import android.content.pm.PackageManagerInternal;
  35 import android.database.IContentObserver;
  36 import android.database.sqlite.SQLiteException;
  37 import android.net.Uri;
  38 import android.os.Binder;
  39 import android.os.Bundle;
  40 import android.os.IBinder;
  41 import android.os.Parcel;
  42 import android.os.RemoteException;
  43 import android.os.ServiceManager;
  44 import android.os.SystemProperties;
  45 import android.os.UserHandle;
  46 import android.text.TextUtils;
  47 import android.util.Log;
  48 import android.util.Slog;
  49 import android.util.SparseIntArray;
  50 import com.android.server.LocalServices;
  51
  52 import java.io.FileDescriptor;
  53 import java.io.PrintWriter;
  54 import java.security.InvalidParameterException;
  55 import java.util.ArrayList;
  56 import java.util.Collections;
  57 import java.util.Comparator;
  58 import java.util.List;
  59
  60 /**
  61  * {@hide}
  62  */
  63 public final class ContentService extends IContentService.Stub {
  64     private static final String TAG = "ContentService";
  65     private Context mContext;
  66     private boolean mFactoryTest;
  67     private final ObserverNode mRootNode = new ObserverNode("");
  68     private SyncManager mSyncManager = null;
  69     private final Object mSyncManagerLock = new Object();
  70
  71     private SyncManager getSyncManager() {
  72         if (SystemProperties.getBoolean("config.disable_network", false)) {
  73             return null;
  74         }
  75
  76         synchronized(mSyncManagerLock) {
  77             try {
  78                 // Try to create the SyncManager, return null if it fails (e.g. the disk is full).
  79                 if (mSyncManager == null) mSyncManager = new SyncManager(mContext, mFactoryTest);
  80             } catch (SQLiteException e) {
  81                 Log.e(TAG, "Can't create SyncManager", e);
  82             }
  83             return mSyncManager;
  84         }
  85     }
  86
  87     @Override
  88     protected synchronized void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
  89         mContext.enforceCallingOrSelfPermission(Manifest.permission.DUMP,
  90                 "caller doesn't have the DUMP permission");
  91
  92         // This makes it so that future permission checks will be in the context of this
  93         // process rather than the caller's process. We will restore this before returning.
  94         long identityToken = clearCallingIdentity();
  95         try {
  96             if (mSyncManager == null) {
  97                 pw.println("No SyncManager created!  (Disk full?)");
  98             } else {
  99                 mSyncManager.dump(fd, pw);
 100             }
 101             pw.println();
 102             pw.println("Observer tree:");
 103             synchronized (mRootNode) {
 104                 int[] counts = new int[2];
 105                 final SparseIntArray pidCounts = new SparseIntArray();
 106                 mRootNode.dumpLocked(fd, pw, args, "", "  ", counts, pidCounts);
 107                 pw.println();
 108                 ArrayList<Integer> sorted = new ArrayList<Integer>();
 109                 for (int i=0; i<pidCounts.size(); i++) {
 110                     sorted.add(pidCounts.keyAt(i));
 111                 }
 112                 Collections.sort(sorted, new Comparator<Integer>() {
 113                     @Override
 114                     public int compare(Integer lhs, Integer rhs) {
 115                         int lc = pidCounts.get(lhs);
 116                         int rc = pidCounts.get(rhs);
 117                         if (lc < rc) {
 118                             return 1;
 119                         } else if (lc > rc) {
 120                             return -1;
 121                         }
 122                         return 0;
 123                     }
 124
 125                 });
 126                 for (int i=0; i<sorted.size(); i++) {
 127                     int pid = sorted.get(i);
 128                     pw.print("  pid "); pw.print(pid); pw.print(": ");
 129                             pw.print(pidCounts.get(pid)); pw.println(" observers");
 130                 }
 131                 pw.println();
 132                 pw.print(" Total number of nodes: "); pw.println(counts[0]);
 133                 pw.print(" Total number of observers: "); pw.println(counts[1]);
 134             }
 135         } finally {
 136             restoreCallingIdentity(identityToken);
 137         }
 138     }
 139
 140     @Override
 141     public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
 142             throws RemoteException {
 143         try {
 144             return super.onTransact(code, data, reply, flags);
 145         } catch (RuntimeException e) {
 146             // The content service only throws security exceptions, so let's
 147             // log all others.
 148             if (!(e instanceof SecurityException)) {
 149                 Slog.wtf(TAG, "Content Service Crash", e);
 150             }
 151             throw e;
 152         }
 153     }
 154
 155     /*package*/ ContentService(Context context, boolean factoryTest) {
 156         mContext = context;
 157         mFactoryTest = factoryTest;
 158
 159         // Let the package manager query for the sync adapters for a given authority
 160         // as we grant default permissions to sync adapters for specific authorities.
 161         PackageManagerInternal packageManagerInternal = LocalServices.getService(
 162                 PackageManagerInternal.class);
 163         packageManagerInternal.setSyncAdapterPackagesprovider(
 164                 new PackageManagerInternal.SyncAdapterPackagesProvider() {
 165             @Override
 166             public String[] getPackages(String authority, int userId) {
 167                 return getSyncAdapterPackagesForAuthorityAsUser(authority, userId);
 168             }
 169         });
 170     }
 171
 172     public void systemReady() {
 173         getSyncManager();
 174     }
 175
 176     /**
 177      * Register a content observer tied to a specific user's view of the provider.
 178      * @param userHandle the user whose view of the provider is to be observed.  May be
 179      *     the calling user without requiring any permission, otherwise the caller needs to
 180      *     hold the INTERACT_ACROSS_USERS_FULL permission or hold a read uri grant to the uri.
 181      *     Pseudousers USER_ALL and USER_CURRENT are properly handled; all other pseudousers
 182      *     are forbidden.
 183      */
 184     @Override
 185     public void registerContentObserver(Uri uri, boolean notifyForDescendants,
 186             IContentObserver observer, int userHandle) {
 187         if (observer == null || uri == null) {
 188             throw new IllegalArgumentException("You must pass a valid uri and observer");
 189         }
 190
 191         final int uid = Binder.getCallingUid();
 192         final int pid = Binder.getCallingPid();
 193         final int callingUserHandle = UserHandle.getCallingUserId();
 194         // Registering an observer for any user other than the calling user requires uri grant or
 195         // cross user permission
 196         if (callingUserHandle != userHandle &&
 197                 mContext.checkUriPermission(uri, pid, uid, Intent.FLAG_GRANT_READ_URI_PERMISSION)
 198                         != PackageManager.PERMISSION_GRANTED) {
 199             enforceCrossUserPermission(userHandle,
 200                     "no permission to observe other users' provider view");
 201         }
 202
 203         if (userHandle < 0) {
 204             if (userHandle == UserHandle.USER_CURRENT) {
 205                 userHandle = ActivityManager.getCurrentUser();
 206             } else if (userHandle != UserHandle.USER_ALL) {
 207                 throw new InvalidParameterException("Bad user handle for registerContentObserver: "
 208                         + userHandle);
 209             }
 210         }
 211
 212         synchronized (mRootNode) {
 213             mRootNode.addObserverLocked(uri, observer, notifyForDescendants, mRootNode,
 214                     uid, pid, userHandle);
 215             if (false) Log.v(TAG, "Registered observer " + observer + " at " + uri +
 216                     " with notifyForDescendants " + notifyForDescendants);
 217         }
 218     }
 219
 220     public void registerContentObserver(Uri uri, boolean notifyForDescendants,
 221             IContentObserver observer) {
 222         registerContentObserver(uri, notifyForDescendants, observer,
 223                 UserHandle.getCallingUserId());
 224     }
 225
 226     public void unregisterContentObserver(IContentObserver observer) {
 227         if (observer == null) {
 228             throw new IllegalArgumentException("You must pass a valid observer");
 229         }
 230         synchronized (mRootNode) {
 231             mRootNode.removeObserverLocked(observer);
 232             if (false) Log.v(TAG, "Unregistered observer " + observer);
 233         }
 234     }
 235
 236     /**
 237      * Notify observers of a particular user's view of the provider.
 238      * @param userHandle the user whose view of the provider is to be notified.  May be
 239      *     the calling user without requiring any permission, otherwise the caller needs to
 240      *     hold the INTERACT_ACROSS_USERS_FULL permission or hold a write uri grant to the uri.
 241      *     Pseudousers USER_ALL and USER_CURRENT are properly interpreted; no other pseudousers are
 242      *     allowed.
 243      */
 244     @Override
 245     public void notifyChange(Uri uri, IContentObserver observer,
 246             boolean observerWantsSelfNotifications, boolean syncToNetwork,
 247             int userHandle) {
 248         if (Log.isLoggable(TAG, Log.VERBOSE)) {
 249             Log.v(TAG, "Notifying update of " + uri + " for user " + userHandle
 250                     + " from observer " + observer + ", syncToNetwork " + syncToNetwork);
 251         }
 252
 253         final int uid = Binder.getCallingUid();
 254         final int pid = Binder.getCallingPid();
 255         final int callingUserHandle = UserHandle.getCallingUserId();
 256         // Notify for any user other than the caller requires uri grant or cross user permission
 257         if (callingUserHandle != userHandle &&
 258                 mContext.checkUriPermission(uri, pid, uid, Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
 259                         != PackageManager.PERMISSION_GRANTED) {
 260             enforceCrossUserPermission(userHandle, "no permission to notify other users");
 261         }
 262
 263         // We passed the permission check; resolve pseudouser targets as appropriate
 264         if (userHandle < 0) {
 265             if (userHandle == UserHandle.USER_CURRENT) {
 266                 userHandle = ActivityManager.getCurrentUser();
 267             } else if (userHandle != UserHandle.USER_ALL) {
 268                 throw new InvalidParameterException("Bad user handle for notifyChange: "
 269                         + userHandle);
 270             }
 271         }
 272
 273         // This makes it so that future permission checks will be in the context of this
 274         // process rather than the caller's process. We will restore this before returning.
 275         long identityToken = clearCallingIdentity();
 276         try {
 277             ArrayList<ObserverCall> calls = new ArrayList<ObserverCall>();
 278             synchronized (mRootNode) {
 279                 mRootNode.collectObserversLocked(uri, 0, observer, observerWantsSelfNotifications,
 280                         userHandle, calls);
 281             }
 282             final int numCalls = calls.size();
 283             for (int i=0; i<numCalls; i++) {
 284                 ObserverCall oc = calls.get(i);
 285                 try {
 286                     oc.mObserver.onChange(oc.mSelfChange, uri, userHandle);
 287                     if (Log.isLoggable(TAG, Log.VERBOSE)) {
 288                         Log.v(TAG, "Notified " + oc.mObserver + " of " + "update at " + uri);
 289                     }
 290                 } catch (RemoteException ex) {
 291                     synchronized (mRootNode) {
 292                         Log.w(TAG, "Found dead observer, removing");
 293                         IBinder binder = oc.mObserver.asBinder();
 294                         final ArrayList<ObserverNode.ObserverEntry> list
 295                                 = oc.mNode.mObservers;
 296                         int numList = list.size();
 297                         for (int j=0; j<numList; j++) {
 298                             ObserverNode.ObserverEntry oe = list.get(j);
 299                             if (oe.observer.asBinder() == binder) {
 300                                 list.remove(j);
 301                                 j--;
 302                                 numList--;
 303                             }
 304                         }
 305                     }
 306                 }
 307             }
 308             if (syncToNetwork) {
 309                 SyncManager syncManager = getSyncManager();
 310                 if (syncManager != null) {
 311                     syncManager.scheduleLocalSync(null /* all accounts */, callingUserHandle, uid,
 312                             uri.getAuthority());
 313                 }
 314             }
 315         } finally {
 316             restoreCallingIdentity(identityToken);
 317         }
 318     }
 319
 320     public void notifyChange(Uri uri, IContentObserver observer,
 321             boolean observerWantsSelfNotifications, boolean syncToNetwork) {
 322         notifyChange(uri, observer, observerWantsSelfNotifications, syncToNetwork,
 323                 UserHandle.getCallingUserId());
 324     }
 325
 326     /**
 327      * Hide this class since it is not part of api,
 328      * but current unittest framework requires it to be public
 329      * @hide
 330      *
 331      */
 332     public static final class ObserverCall {
 333         final ObserverNode mNode;
 334         final IContentObserver mObserver;
 335         final boolean mSelfChange;
 336
 337         ObserverCall(ObserverNode node, IContentObserver observer, boolean selfChange) {
 338             mNode = node;
 339             mObserver = observer;
 340             mSelfChange = selfChange;
 341         }
 342     }
 343
 344     public void requestSync(Account account, String authority, Bundle extras) {
 345         ContentResolver.validateSyncExtrasBundle(extras);
 346         int userId = UserHandle.getCallingUserId();
 347         int uId = Binder.getCallingUid();
 348
 349         // This makes it so that future permission checks will be in the context of this
 350         // process rather than the caller's process. We will restore this before returning.
 351         long identityToken = clearCallingIdentity();
 352         try {
 353             SyncManager syncManager = getSyncManager();
 354             if (syncManager != null) {
 355                 syncManager.scheduleSync(account, userId, uId, authority, extras,
 356                         0 /* no delay */, 0 /* no delay */,
 357                         false /* onlyThoseWithUnkownSyncableState */);
 358             }
 359         } finally {
 360             restoreCallingIdentity(identityToken);
 361         }
 362     }
 363
 364     /**
 365      * Request a sync with a generic {@link android.content.SyncRequest} object. This will be
 366      * either:
 367      *   periodic OR one-off sync.
 368      * and
 369      *   anonymous OR provider sync.
 370      * Depending on the request, we enqueue to suit in the SyncManager.
 371      * @param request The request object. Validation of this object is done by its builder.
 372      */
 373     public void sync(SyncRequest request) {
 374         syncAsUser(request, UserHandle.getCallingUserId());
 375     }
 376
 377     /**
 378      * If the user id supplied is different to the calling user, the caller must hold the
 379      * INTERACT_ACROSS_USERS_FULL permission.
 380      */
 381     public void syncAsUser(SyncRequest request, int userId) {
 382         enforceCrossUserPermission(userId, "no permission to request sync as user: " + userId);
 383         int callerUid = Binder.getCallingUid();
 384         // This makes it so that future permission checks will be in the context of this
 385         // process rather than the caller's process. We will restore this before returning.
 386         long identityToken = clearCallingIdentity();
 387         try {
 388             SyncManager syncManager = getSyncManager();
 389             if (syncManager == null) {
 390                 return;
 391             }
 392
 393             Bundle extras = request.getBundle();
 394             long flextime = request.getSyncFlexTime();
 395             long runAtTime = request.getSyncRunTime();
 396             if (request.isPeriodic()) {
 397                 mContext.enforceCallingOrSelfPermission(
 398                         Manifest.permission.WRITE_SYNC_SETTINGS,
 399                         "no permission to write the sync settings");
 400                 SyncStorageEngine.EndPoint info;
 401                 info = new SyncStorageEngine.EndPoint(
 402                         request.getAccount(), request.getProvider(), userId);
 403                 if (runAtTime < 60) {
 404                     Slog.w(TAG, "Requested poll frequency of " + runAtTime
 405                             + " seconds being rounded up to 60 seconds.");
 406                     runAtTime = 60;
 407                 }
 408                 // Schedule periodic sync.
 409                 getSyncManager().getSyncStorageEngine()
 410                     .updateOrAddPeriodicSync(info, runAtTime, flextime, extras);
 411             } else {
 412                 long beforeRuntimeMillis = (flextime) * 1000;
 413                 long runtimeMillis = runAtTime * 1000;
 414                 syncManager.scheduleSync(
 415                         request.getAccount(), userId, callerUid, request.getProvider(), extras,
 416                         beforeRuntimeMillis, runtimeMillis,
 417                         false /* onlyThoseWithUnknownSyncableState */);
 418             }
 419         } finally {
 420             restoreCallingIdentity(identityToken);
 421         }
 422     }
 423
 424     /**
 425      * Clear all scheduled sync operations that match the uri and cancel the active sync
 426      * if they match the authority and account, if they are present.
 427      *
 428      * @param account filter the pending and active syncs to cancel using this account, or null.
 429      * @param authority filter the pending and active syncs to cancel using this authority, or
 430      * null.
 431      * @param cname cancel syncs running on this service, or null for provider/account.
 432      */
 433     @Override
 434     public void cancelSync(Account account, String authority, ComponentName cname) {
 435         cancelSyncAsUser(account, authority, cname, UserHandle.getCallingUserId());
 436     }
 437
 438     /**
 439      * Clear all scheduled sync operations that match the uri and cancel the active sync
 440      * if they match the authority and account, if they are present.
 441      *
 442      * <p> If the user id supplied is different to the calling user, the caller must hold the
 443      * INTERACT_ACROSS_USERS_FULL permission.
 444      *
 445      * @param account filter the pending and active syncs to cancel using this account, or null.
 446      * @param authority filter the pending and active syncs to cancel using this authority, or
 447      * null.
 448      * @param userId the user id for which to cancel sync operations.
 449      * @param cname cancel syncs running on this service, or null for provider/account.
 450      */
 451     @Override
 452     public void cancelSyncAsUser(Account account, String authority, ComponentName cname,
 453             int userId) {
 454         if (authority != null && authority.length() == 0) {
 455             throw new IllegalArgumentException("Authority must be non-empty");
 456         }
 457         enforceCrossUserPermission(userId,
 458                 "no permission to modify the sync settings for user " + userId);
 459         // This makes it so that future permission checks will be in the context of this
 460         // process rather than the caller's process. We will restore this before returning.
 461         long identityToken = clearCallingIdentity();
 462         try {
 463             SyncManager syncManager = getSyncManager();
 464             if (syncManager != null) {
 465                 SyncStorageEngine.EndPoint info;
 466                 if (cname == null) {
 467                     info = new SyncStorageEngine.EndPoint(account, authority, userId);
 468                 } else {
 469                     info = new SyncStorageEngine.EndPoint(cname, userId);
 470                 }
 471                 syncManager.clearScheduledSyncOperations(info);
 472                 syncManager.cancelActiveSync(info, null /* all syncs for this adapter */);
 473             }
 474         } finally {
 475             restoreCallingIdentity(identityToken);
 476         }
 477     }
 478
 479     public void cancelRequest(SyncRequest request) {
 480         SyncManager syncManager = getSyncManager();
 481         if (syncManager == null) return;
 482         int userId = UserHandle.getCallingUserId();
 483
 484         long identityToken = clearCallingIdentity();
 485         try {
 486             SyncStorageEngine.EndPoint info;
 487             Bundle extras = new Bundle(request.getBundle());
 488             Account account = request.getAccount();
 489             String provider = request.getProvider();
 490             info = new SyncStorageEngine.EndPoint(account, provider, userId);
 491             if (request.isPeriodic()) {
 492                 // Remove periodic sync.
 493                 mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS,
 494                         "no permission to write the sync settings");
 495                 getSyncManager().getSyncStorageEngine().removePeriodicSync(info, extras);
 496             }
 497             // Cancel active syncs and clear pending syncs from the queue.
 498             syncManager.cancelScheduledSyncOperation(info, extras);
 499             syncManager.cancelActiveSync(info, extras);
 500         } finally {
 501             restoreCallingIdentity(identityToken);
 502         }
 503     }
 504
 505     /**
 506      * Get information about the SyncAdapters that are known to the system.
 507      * @return an array of SyncAdapters that have registered with the system
 508      */
 509     @Override
 510     public SyncAdapterType[] getSyncAdapterTypes() {
 511         return getSyncAdapterTypesAsUser(UserHandle.getCallingUserId());
 512     }
 513
 514     /**
 515      * Get information about the SyncAdapters that are known to the system for a particular user.
 516      *
 517      * <p> If the user id supplied is different to the calling user, the caller must hold the
 518      * INTERACT_ACROSS_USERS_FULL permission.
 519      *
 520      * @return an array of SyncAdapters that have registered with the system
 521      */
 522     @Override
 523     public SyncAdapterType[] getSyncAdapterTypesAsUser(int userId) {
 524         enforceCrossUserPermission(userId,
 525                 "no permission to read sync settings for user " + userId);
 526         // This makes it so that future permission checks will be in the context of this
 527         // process rather than the caller's process. We will restore this before returning.
 528         final long identityToken = clearCallingIdentity();
 529         try {
 530             SyncManager syncManager = getSyncManager();
 531             return syncManager.getSyncAdapterTypes(userId);
 532         } finally {
 533             restoreCallingIdentity(identityToken);
 534         }
 535     }
 536
 537     @Override
 538     public String[] getSyncAdapterPackagesForAuthorityAsUser(String authority, int userId) {
 539         enforceCrossUserPermission(userId,
 540                 "no permission to read sync settings for user " + userId);
 541         // This makes it so that future permission checks will be in the context of this
 542         // process rather than the caller's process. We will restore this before returning.
 543         final long identityToken = clearCallingIdentity();
 544         try {
 545             SyncManager syncManager = getSyncManager();
 546             return syncManager.getSyncAdapterPackagesForAuthorityAsUser(authority, userId);
 547         } finally {
 548             restoreCallingIdentity(identityToken);
 549         }
 550     }
 551
 552     @Override
 553     public boolean getSyncAutomatically(Account account, String providerName) {
 554         return getSyncAutomaticallyAsUser(account, providerName, UserHandle.getCallingUserId());
 555     }
 556
 557     /**
 558      * If the user id supplied is different to the calling user, the caller must hold the
 559      * INTERACT_ACROSS_USERS_FULL permission.
 560      */
 561     @Override
 562     public boolean getSyncAutomaticallyAsUser(Account account, String providerName, int userId) {
 563         enforceCrossUserPermission(userId,
 564                 "no permission to read the sync settings for user " + userId);
 565         mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS,
 566                 "no permission to read the sync settings");
 567
 568         long identityToken = clearCallingIdentity();
 569         try {
 570             SyncManager syncManager = getSyncManager();
 571             if (syncManager != null) {
 572                 return syncManager.getSyncStorageEngine()
 573                         .getSyncAutomatically(account, userId, providerName);
 574             }
 575         } finally {
 576             restoreCallingIdentity(identityToken);
 577         }
 578         return false;
 579     }
 580
 581     @Override
 582     public void setSyncAutomatically(Account account, String providerName, boolean sync) {
 583         setSyncAutomaticallyAsUser(account, providerName, sync, UserHandle.getCallingUserId());
 584     }
 585
 586     @Override
 587     public void setSyncAutomaticallyAsUser(Account account, String providerName, boolean sync,
 588             int userId) {
 589         if (TextUtils.isEmpty(providerName)) {
 590             throw new IllegalArgumentException("Authority must be non-empty");
 591         }
 592         mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS,
 593                 "no permission to write the sync settings");
 594         enforceCrossUserPermission(userId,
 595                 "no permission to modify the sync settings for user " + userId);
 596
 597         long identityToken = clearCallingIdentity();
 598         try {
 599             SyncManager syncManager = getSyncManager();
 600             if (syncManager != null) {
 601                 syncManager.getSyncStorageEngine().setSyncAutomatically(account, userId,
 602                         providerName, sync);
 603             }
 604         } finally {
 605             restoreCallingIdentity(identityToken);
 606         }
 607     }
 608
 609     /** Old API. Schedule periodic sync with default flex time. */
 610     @Override
 611     public void addPeriodicSync(Account account, String authority, Bundle extras,
 612             long pollFrequency) {
 613         if (account == null) {
 614             throw new IllegalArgumentException("Account must not be null");
 615         }
 616         if (TextUtils.isEmpty(authority)) {
 617             throw new IllegalArgumentException("Authority must not be empty.");
 618         }
 619         mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS,
 620                 "no permission to write the sync settings");
 621
 622         int userId = UserHandle.getCallingUserId();
 623         if (pollFrequency < 60) {
 624             Slog.w(TAG, "Requested poll frequency of " + pollFrequency
 625                     + " seconds being rounded up to 60 seconds.");
 626             pollFrequency = 60;
 627         }
 628         long defaultFlex = SyncStorageEngine.calculateDefaultFlexTime(pollFrequency);
 629
 630         long identityToken = clearCallingIdentity();
 631         try {
 632             SyncStorageEngine.EndPoint info =
 633                     new SyncStorageEngine.EndPoint(account, authority, userId);
 634             getSyncManager().getSyncStorageEngine()
 635                 .updateOrAddPeriodicSync(info,
 636                         pollFrequency,
 637                         defaultFlex,
 638                         extras);
 639         } finally {
 640             restoreCallingIdentity(identityToken);
 641         }
 642     }
 643
 644     public void removePeriodicSync(Account account, String authority, Bundle extras) {
 645         if (account == null) {
 646             throw new IllegalArgumentException("Account must not be null");
 647         }
 648         if (TextUtils.isEmpty(authority)) {
 649             throw new IllegalArgumentException("Authority must not be empty");
 650         }
 651         mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS,
 652                 "no permission to write the sync settings");
 653
 654         int userId = UserHandle.getCallingUserId();
 655         long identityToken = clearCallingIdentity();
 656         try {
 657             getSyncManager().getSyncStorageEngine()
 658                 .removePeriodicSync(
 659                         new SyncStorageEngine.EndPoint(account, authority, userId),
 660                         extras);
 661         } finally {
 662             restoreCallingIdentity(identityToken);
 663         }
 664     }
 665
 666
 667     public List<PeriodicSync> getPeriodicSyncs(Account account, String providerName,
 668             ComponentName cname) {
 669         if (account == null) {
 670             throw new IllegalArgumentException("Account must not be null");
 671         }
 672         if (TextUtils.isEmpty(providerName)) {
 673             throw new IllegalArgumentException("Authority must not be empty");
 674         }
 675         mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS,
 676                 "no permission to read the sync settings");
 677
 678         int userId = UserHandle.getCallingUserId();
 679         long identityToken = clearCallingIdentity();
 680         try {
 681             return getSyncManager().getSyncStorageEngine().getPeriodicSyncs(
 682                     new SyncStorageEngine.EndPoint(account, providerName, userId));
 683         } finally {
 684             restoreCallingIdentity(identityToken);
 685         }
 686     }
 687
 688     public int getIsSyncable(Account account, String providerName) {
 689         return getIsSyncableAsUser(account, providerName, UserHandle.getCallingUserId());
 690     }
 691
 692     /**
 693      * If the user id supplied is different to the calling user, the caller must hold the
 694      * INTERACT_ACROSS_USERS_FULL permission.
 695      */
 696     public int getIsSyncableAsUser(Account account, String providerName, int userId) {
 697         enforceCrossUserPermission(userId,
 698                 "no permission to read the sync settings for user " + userId);
 699         mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS,
 700                 "no permission to read the sync settings");
 701
 702         long identityToken = clearCallingIdentity();
 703         try {
 704             SyncManager syncManager = getSyncManager();
 705             if (syncManager != null) {
 706                 return syncManager.getIsSyncable(
 707                         account, userId, providerName);
 708             }
 709         } finally {
 710             restoreCallingIdentity(identityToken);
 711         }
 712         return -1;
 713     }
 714
 715     public void setIsSyncable(Account account, String providerName, int syncable) {
 716         if (TextUtils.isEmpty(providerName)) {
 717             throw new IllegalArgumentException("Authority must not be empty");
 718         }
 719         mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS,
 720                 "no permission to write the sync settings");
 721
 722         int userId = UserHandle.getCallingUserId();
 723         long identityToken = clearCallingIdentity();
 724         try {
 725             SyncManager syncManager = getSyncManager();
 726             if (syncManager != null) {
 727                 syncManager.getSyncStorageEngine().setIsSyncable(
 728                         account, userId, providerName, syncable);
 729             }
 730         } finally {
 731             restoreCallingIdentity(identityToken);
 732         }
 733     }
 734
 735     @Override
 736     public boolean getMasterSyncAutomatically() {
 737         return getMasterSyncAutomaticallyAsUser(UserHandle.getCallingUserId());
 738     }
 739
 740     /**
 741      * If the user id supplied is different to the calling user, the caller must hold the
 742      * INTERACT_ACROSS_USERS_FULL permission.
 743      */
 744     @Override
 745     public boolean getMasterSyncAutomaticallyAsUser(int userId) {
 746         enforceCrossUserPermission(userId,
 747                 "no permission to read the sync settings for user " + userId);
 748         mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS,
 749                 "no permission to read the sync settings");
 750
 751         long identityToken = clearCallingIdentity();
 752         try {
 753             SyncManager syncManager = getSyncManager();
 754             if (syncManager != null) {
 755                 return syncManager.getSyncStorageEngine().getMasterSyncAutomatically(userId);
 756             }
 757         } finally {
 758             restoreCallingIdentity(identityToken);
 759         }
 760         return false;
 761     }
 762
 763     @Override
 764     public void setMasterSyncAutomatically(boolean flag) {
 765         setMasterSyncAutomaticallyAsUser(flag, UserHandle.getCallingUserId());
 766     }
 767
 768     @Override
 769     public void setMasterSyncAutomaticallyAsUser(boolean flag, int userId) {
 770         enforceCrossUserPermission(userId,
 771                 "no permission to set the sync status for user " + userId);
 772         mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS,
 773                 "no permission to write the sync settings");
 774
 775         long identityToken = clearCallingIdentity();
 776         try {
 777             SyncManager syncManager = getSyncManager();
 778             if (syncManager != null) {
 779                 syncManager.getSyncStorageEngine().setMasterSyncAutomatically(flag, userId);
 780             }
 781         } finally {
 782             restoreCallingIdentity(identityToken);
 783         }
 784     }
 785
 786     public boolean isSyncActive(Account account, String authority, ComponentName cname) {
 787         mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS,
 788                 "no permission to read the sync stats");
 789         int userId = UserHandle.getCallingUserId();
 790         int callingUid = Binder.getCallingUid();
 791         long identityToken = clearCallingIdentity();
 792         try {
 793             SyncManager syncManager = getSyncManager();
 794             if (syncManager == null) {
 795                 return false;
 796             }
 797             return syncManager.getSyncStorageEngine().isSyncActive(
 798                     new SyncStorageEngine.EndPoint(account, authority, userId));
 799         } finally {
 800             restoreCallingIdentity(identityToken);
 801         }
 802     }
 803
 804     public List<SyncInfo> getCurrentSyncs() {
 805         return getCurrentSyncsAsUser(UserHandle.getCallingUserId());
 806     }
 807
 808     /**
 809      * If the user id supplied is different to the calling user, the caller must hold the
 810      * INTERACT_ACROSS_USERS_FULL permission.
 811      */
 812     public List<SyncInfo> getCurrentSyncsAsUser(int userId) {
 813         enforceCrossUserPermission(userId,
 814                 "no permission to read the sync settings for user " + userId);
 815         mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS,
 816                 "no permission to read the sync stats");
 817
 818         long identityToken = clearCallingIdentity();
 819         try {
 820             return getSyncManager().getSyncStorageEngine().getCurrentSyncsCopy(userId);
 821         } finally {
 822             restoreCallingIdentity(identityToken);
 823         }
 824     }
 825
 826     public SyncStatusInfo getSyncStatus(Account account, String authority, ComponentName cname) {
 827         return getSyncStatusAsUser(account, authority, cname, UserHandle.getCallingUserId());
 828     }
 829
 830     /**
 831      * If the user id supplied is different to the calling user, the caller must hold the
 832      * INTERACT_ACROSS_USERS_FULL permission.
 833      */
 834     public SyncStatusInfo getSyncStatusAsUser(Account account, String authority,
 835             ComponentName cname, int userId) {
 836         if (TextUtils.isEmpty(authority)) {
 837             throw new IllegalArgumentException("Authority must not be empty");
 838         }
 839
 840         enforceCrossUserPermission(userId,
 841                 "no permission to read the sync stats for user " + userId);
 842         mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS,
 843                 "no permission to read the sync stats");
 844
 845         int callerUid = Binder.getCallingUid();
 846         long identityToken = clearCallingIdentity();
 847         try {
 848             SyncManager syncManager = getSyncManager();
 849             if (syncManager == null) {
 850                 return null;
 851             }
 852             SyncStorageEngine.EndPoint info;
 853             if (!(account == null || authority == null)) {
 854                 info = new SyncStorageEngine.EndPoint(account, authority, userId);
 855             } else {
 856                 throw new IllegalArgumentException("Must call sync status with valid authority");
 857             }
 858             return syncManager.getSyncStorageEngine().getStatusByAuthority(info);
 859         } finally {
 860             restoreCallingIdentity(identityToken);
 861         }
 862     }
 863
 864     public boolean isSyncPending(Account account, String authority, ComponentName cname) {
 865         return isSyncPendingAsUser(account, authority, cname, UserHandle.getCallingUserId());
 866     }
 867
 868     @Override
 869     public boolean isSyncPendingAsUser(Account account, String authority, ComponentName cname,
 870             int userId) {
 871         mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS,
 872                 "no permission to read the sync stats");
 873         enforceCrossUserPermission(userId,
 874                 "no permission to retrieve the sync settings for user " + userId);
 875         int callerUid = Binder.getCallingUid();
 876         long identityToken = clearCallingIdentity();
 877         SyncManager syncManager = getSyncManager();
 878         if (syncManager == null) return false;
 879
 880         try {
 881             SyncStorageEngine.EndPoint info;
 882             if (!(account == null || authority == null)) {
 883                 info = new SyncStorageEngine.EndPoint(account, authority, userId);
 884             } else {
 885                 throw new IllegalArgumentException("Invalid authority specified");
 886             }
 887             return syncManager.getSyncStorageEngine().isSyncPending(info);
 888         } finally {
 889             restoreCallingIdentity(identityToken);
 890         }
 891     }
 892
 893     public void addStatusChangeListener(int mask, ISyncStatusObserver callback) {
 894         long identityToken = clearCallingIdentity();
 895         try {
 896             SyncManager syncManager = getSyncManager();
 897             if (syncManager != null && callback != null) {
 898                 syncManager.getSyncStorageEngine().addStatusChangeListener(mask, callback);
 899             }
 900         } finally {
 901             restoreCallingIdentity(identityToken);
 902         }
 903     }
 904
 905     public void removeStatusChangeListener(ISyncStatusObserver callback) {
 906         long identityToken = clearCallingIdentity();
 907         try {
 908             SyncManager syncManager = getSyncManager();
 909             if (syncManager != null && callback != null) {
 910                 syncManager.getSyncStorageEngine().removeStatusChangeListener(callback);
 911             }
 912         } finally {
 913             restoreCallingIdentity(identityToken);
 914         }
 915     }
 916
 917     public static ContentService main(Context context, boolean factoryTest) {
 918         ContentService service = new ContentService(context, factoryTest);
 919         ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME, service);
 920         return service;
 921     }
 922
 923     /**
 924      * Checks if the request is from the system or an app that has INTERACT_ACROSS_USERS_FULL
 925      * permission, if the userHandle is not for the caller.
 926      *
 927      * @param userHandle the user handle of the user we want to act on behalf of.
 928      * @param message the message to log on security exception.
 929      */
 930     private void enforceCrossUserPermission(int userHandle, String message) {
 931         final int callingUser = UserHandle.getCallingUserId();
 932         if (callingUser != userHandle) {
 933             mContext.enforceCallingOrSelfPermission(
 934                     Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
 935         }
 936     }
 937
 938     /**
 939      * Hide this class since it is not part of api,
 940      * but current unittest framework requires it to be public
 941      * @hide
 942      */
 943     public static final class ObserverNode {
 944         private class ObserverEntry implements IBinder.DeathRecipient {
 945             public final IContentObserver observer;
 946             public final int uid;
 947             public final int pid;
 948             public final boolean notifyForDescendants;
 949             private final int userHandle;
 950             private final Object observersLock;
 951
 952             public ObserverEntry(IContentObserver o, boolean n, Object observersLock,
 953                     int _uid, int _pid, int _userHandle) {
 954                 this.observersLock = observersLock;
 955                 observer = o;
 956                 uid = _uid;
 957                 pid = _pid;
 958                 userHandle = _userHandle;
 959                 notifyForDescendants = n;
 960                 try {
 961                     observer.asBinder().linkToDeath(this, 0);
 962                 } catch (RemoteException e) {
 963                     binderDied();
 964                 }
 965             }
 966
 967             public void binderDied() {
 968                 synchronized (observersLock) {
 969                     removeObserverLocked(observer);
 970                 }
 971             }
 972
 973             public void dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args,
 974                     String name, String prefix, SparseIntArray pidCounts) {
 975                 pidCounts.put(pid, pidCounts.get(pid)+1);
 976                 pw.print(prefix); pw.print(name); pw.print(": pid=");
 977                         pw.print(pid); pw.print(" uid=");
 978                         pw.print(uid); pw.print(" user=");
 979                         pw.print(userHandle); pw.print(" target=");
 980                         pw.println(Integer.toHexString(System.identityHashCode(
 981                                 observer != null ? observer.asBinder() : null)));
 982             }
 983         }
 984
 985         public static final int INSERT_TYPE = 0;
 986         public static final int UPDATE_TYPE = 1;
 987         public static final int DELETE_TYPE = 2;
 988
 989         private String mName;
 990         private ArrayList<ObserverNode> mChildren = new ArrayList<ObserverNode>();
 991         private ArrayList<ObserverEntry> mObservers = new ArrayList<ObserverEntry>();
 992
 993         public ObserverNode(String name) {
 994             mName = name;
 995         }
 996
 997         public void dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args,
 998                 String name, String prefix, int[] counts, SparseIntArray pidCounts) {
 999             String innerName = null;
1000             if (mObservers.size() > 0) {
1001                 if ("".equals(name)) {
1002                     innerName = mName;
1003                 } else {
1004                     innerName = name + "/" + mName;
1005                 }
1006                 for (int i=0; i<mObservers.size(); i++) {
1007                     counts[1]++;
1008                     mObservers.get(i).dumpLocked(fd, pw, args, innerName, prefix,
1009                             pidCounts);
1010                 }
1011             }
1012             if (mChildren.size() > 0) {
1013                 if (innerName == null) {
1014                     if ("".equals(name)) {
1015                         innerName = mName;
1016                     } else {
1017                         innerName = name + "/" + mName;
1018                     }
1019                 }
1020                 for (int i=0; i<mChildren.size(); i++) {
1021                     counts[0]++;
1022                     mChildren.get(i).dumpLocked(fd, pw, args, innerName, prefix,
1023                             counts, pidCounts);
1024                 }
1025             }
1026         }
1027
1028         private String getUriSegment(Uri uri, int index) {
1029             if (uri != null) {
1030                 if (index == 0) {
1031                     return uri.getAuthority();
1032                 } else {
1033                     return uri.getPathSegments().get(index - 1);
1034                 }
1035             } else {
1036                 return null;
1037             }
1038         }
1039
1040         private int countUriSegments(Uri uri) {
1041             if (uri == null) {
1042                 return 0;
1043             }
1044             return uri.getPathSegments().size() + 1;
1045         }
1046
1047         // Invariant:  userHandle is either a hard user number or is USER_ALL
1048         public void addObserverLocked(Uri uri, IContentObserver observer,
1049                 boolean notifyForDescendants, Object observersLock,
1050                 int uid, int pid, int userHandle) {
1051             addObserverLocked(uri, 0, observer, notifyForDescendants, observersLock,
1052                     uid, pid, userHandle);
1053         }
1054
1055         private void addObserverLocked(Uri uri, int index, IContentObserver observer,
1056                 boolean notifyForDescendants, Object observersLock,
1057                 int uid, int pid, int userHandle) {
1058             // If this is the leaf node add the observer
1059             if (index == countUriSegments(uri)) {
1060                 mObservers.add(new ObserverEntry(observer, notifyForDescendants, observersLock,
1061                         uid, pid, userHandle));
1062                 return;
1063             }
1064
1065             // Look to see if the proper child already exists
1066             String segment = getUriSegment(uri, index);
1067             if (segment == null) {
1068                 throw new IllegalArgumentException("Invalid Uri (" + uri + ") used for observer");
1069             }
1070             int N = mChildren.size();
1071             for (int i = 0; i < N; i++) {
1072                 ObserverNode node = mChildren.get(i);
1073                 if (node.mName.equals(segment)) {
1074                     node.addObserverLocked(uri, index + 1, observer, notifyForDescendants,
1075                             observersLock, uid, pid, userHandle);
1076                     return;
1077                 }
1078             }
1079
1080             // No child found, create one
1081             ObserverNode node = new ObserverNode(segment);
1082             mChildren.add(node);
1083             node.addObserverLocked(uri, index + 1, observer, notifyForDescendants,
1084                     observersLock, uid, pid, userHandle);
1085         }
1086
1087         public boolean removeObserverLocked(IContentObserver observer) {
1088             int size = mChildren.size();
1089             for (int i = 0; i < size; i++) {
1090                 boolean empty = mChildren.get(i).removeObserverLocked(observer);
1091                 if (empty) {
1092                     mChildren.remove(i);
1093                     i--;
1094                     size--;
1095                 }
1096             }
1097
1098             IBinder observerBinder = observer.asBinder();
1099             size = mObservers.size();
1100             for (int i = 0; i < size; i++) {
1101                 ObserverEntry entry = mObservers.get(i);
1102                 if (entry.observer.asBinder() == observerBinder) {
1103                     mObservers.remove(i);
1104                     // We no longer need to listen for death notifications. Remove it.
1105                     observerBinder.unlinkToDeath(entry, 0);
1106                     break;
1107                 }
1108             }
1109
1110             if (mChildren.size() == 0 && mObservers.size() == 0) {
1111                 return true;
1112             }
1113             return false;
1114         }
1115
1116         private void collectMyObserversLocked(boolean leaf, IContentObserver observer,
1117                 boolean observerWantsSelfNotifications, int targetUserHandle,
1118                 ArrayList<ObserverCall> calls) {
1119             int N = mObservers.size();
1120             IBinder observerBinder = observer == null ? null : observer.asBinder();
1121             for (int i = 0; i < N; i++) {
1122                 ObserverEntry entry = mObservers.get(i);
1123
1124                 // Don't notify the observer if it sent the notification and isn't interested
1125                 // in self notifications
1126                 boolean selfChange = (entry.observer.asBinder() == observerBinder);
1127                 if (selfChange && !observerWantsSelfNotifications) {
1128                     continue;
1129                 }
1130
1131                 // Does this observer match the target user?
1132                 if (targetUserHandle == UserHandle.USER_ALL
1133                         || entry.userHandle == UserHandle.USER_ALL
1134                         || targetUserHandle == entry.userHandle) {
1135                     // Make sure the observer is interested in the notification
1136                     if (leaf || (!leaf && entry.notifyForDescendants)) {
1137                         calls.add(new ObserverCall(this, entry.observer, selfChange));
1138                     }
1139                 }
1140             }
1141         }
1142
1143         /**
1144          * targetUserHandle is either a hard user handle or is USER_ALL
1145          */
1146         public void collectObserversLocked(Uri uri, int index, IContentObserver observer,
1147                 boolean observerWantsSelfNotifications, int targetUserHandle,
1148                 ArrayList<ObserverCall> calls) {
1149             String segment = null;
1150             int segmentCount = countUriSegments(uri);
1151             if (index >= segmentCount) {
1152                 // This is the leaf node, notify all observers
1153                 collectMyObserversLocked(true, observer, observerWantsSelfNotifications,
1154                         targetUserHandle, calls);
1155             } else if (index < segmentCount){
1156                 segment = getUriSegment(uri, index);
1157                 // Notify any observers at this level who are interested in descendants
1158                 collectMyObserversLocked(false, observer, observerWantsSelfNotifications,
1159                         targetUserHandle, calls);
1160             }
1161
1162             int N = mChildren.size();
1163             for (int i = 0; i < N; i++) {
1164                 ObserverNode node = mChildren.get(i);
1165                 if (segment == null || node.mName.equals(segment)) {
1166                     // We found the child,
1167                     node.collectObserversLocked(uri, index + 1,
1168                             observer, observerWantsSelfNotifications, targetUserHandle, calls);
1169                     if (segment != null) {
1170                         break;
1171                     }
1172                 }
1173             }
1174         }
1175     }
1176 }