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.providers.downloads; 18 19 import static android.provider.BaseColumns._ID; 20 import static android.provider.Downloads.Impl.COLUMN_DESTINATION; 21 import static android.provider.Downloads.Impl.COLUMN_MEDIAPROVIDER_URI; 22 import static android.provider.Downloads.Impl.COLUMN_MEDIA_SCANNED; 23 import static android.provider.Downloads.Impl.COLUMN_MIME_TYPE; 24 import static android.provider.Downloads.Impl.DESTINATION_NON_DOWNLOADMANAGER_DOWNLOAD; 25 import static android.provider.Downloads.Impl._DATA; 26 27 import android.app.AppOpsManager; 28 import android.app.DownloadManager; 29 import android.app.DownloadManager.Request; 30 import android.app.job.JobScheduler; 31 import android.content.ContentProvider; 32 import android.content.ContentUris; 33 import android.content.ContentValues; 34 import android.content.Context; 35 import android.content.Intent; 36 import android.content.UriMatcher; 37 import android.content.pm.ApplicationInfo; 38 import android.content.pm.PackageManager; 39 import android.content.pm.PackageManager.NameNotFoundException; 40 import android.database.Cursor; 41 import android.database.DatabaseUtils; 42 import android.database.SQLException; 43 import android.database.sqlite.SQLiteDatabase; 44 import android.database.sqlite.SQLiteOpenHelper; 45 import android.net.Uri; 46 import android.os.Binder; 47 import android.os.ParcelFileDescriptor; 48 import android.os.ParcelFileDescriptor.OnCloseListener; 49 import android.os.Process; 50 import android.provider.BaseColumns; 51 import android.provider.Downloads; 52 import android.provider.OpenableColumns; 53 import android.text.TextUtils; 54 import android.text.format.DateUtils; 55 import android.util.Log; 56 57 import com.android.internal.util.IndentingPrintWriter; 58 59 import libcore.io.IoUtils; 60 61 import com.google.android.collect.Maps; 62 import com.google.common.annotations.VisibleForTesting; 63 64 import java.io.File; 65 import java.io.FileDescriptor; 66 import java.io.FileNotFoundException; 67 import java.io.IOException; 68 import java.io.PrintWriter; 69 import java.util.ArrayList; 70 import java.util.Arrays; 71 import java.util.HashMap; 72 import java.util.HashSet; 73 import java.util.Iterator; 74 import java.util.List; 75 import java.util.Map; 76 77 /** 78 * Allows application to interact with the download manager. 79 */ 80 public final class DownloadProvider extends ContentProvider { 81 /** Database filename */ 82 private static final String DB_NAME = "downloads.db"; 83 /** Current database version */ 84 private static final int DB_VERSION = 110; 85 /** Name of table in the database */ 86 private static final String DB_TABLE = "downloads"; 87 88 /** MIME type for the entire download list */ 89 private static final String DOWNLOAD_LIST_TYPE = "vnd.android.cursor.dir/download"; 90 /** MIME type for an individual download */ 91 private static final String DOWNLOAD_TYPE = "vnd.android.cursor.item/download"; 92 93 /** URI matcher used to recognize URIs sent by applications */ 94 private static final UriMatcher sURIMatcher = new UriMatcher(UriMatcher.NO_MATCH); 95 /** URI matcher constant for the URI of all downloads belonging to the calling UID */ 96 private static final int MY_DOWNLOADS = 1; 97 /** URI matcher constant for the URI of an individual download belonging to the calling UID */ 98 private static final int MY_DOWNLOADS_ID = 2; 99 /** URI matcher constant for the URI of all downloads in the system */ 100 private static final int ALL_DOWNLOADS = 3; 101 /** URI matcher constant for the URI of an individual download */ 102 private static final int ALL_DOWNLOADS_ID = 4; 103 /** URI matcher constant for the URI of a download's request headers */ 104 private static final int REQUEST_HEADERS_URI = 5; 105 /** URI matcher constant for the public URI returned by 106 * {@link DownloadManager#getUriForDownloadedFile(long)} if the given downloaded file 107 * is publicly accessible. 108 */ 109 private static final int PUBLIC_DOWNLOAD_ID = 6; 110 static { 111 sURIMatcher.addURI("downloads", "my_downloads", MY_DOWNLOADS); 112 sURIMatcher.addURI("downloads", "my_downloads/#", MY_DOWNLOADS_ID); 113 sURIMatcher.addURI("downloads", "all_downloads", ALL_DOWNLOADS); 114 sURIMatcher.addURI("downloads", "all_downloads/#", ALL_DOWNLOADS_ID); 115 sURIMatcher.addURI("downloads", 116 "my_downloads/#/" + Downloads.Impl.RequestHeaders.URI_SEGMENT, 117 REQUEST_HEADERS_URI); 118 sURIMatcher.addURI("downloads", 119 "all_downloads/#/" + Downloads.Impl.RequestHeaders.URI_SEGMENT, 120 REQUEST_HEADERS_URI); 121 // temporary, for backwards compatibility 122 sURIMatcher.addURI("downloads", "download", MY_DOWNLOADS); 123 sURIMatcher.addURI("downloads", "download/#", MY_DOWNLOADS_ID); 124 sURIMatcher.addURI("downloads", 125 "download/#/" + Downloads.Impl.RequestHeaders.URI_SEGMENT, 126 REQUEST_HEADERS_URI); 127 sURIMatcher.addURI("downloads", 128 Downloads.Impl.PUBLICLY_ACCESSIBLE_DOWNLOADS_URI_SEGMENT + "/#", 129 PUBLIC_DOWNLOAD_ID); 130 } 131 132 /** Different base URIs that could be used to access an individual download */ 133 private static final Uri[] BASE_URIS = new Uri[] { 134 Downloads.Impl.CONTENT_URI, 135 Downloads.Impl.ALL_DOWNLOADS_CONTENT_URI, 136 }; 137 138 private static final String[] sAppReadableColumnsArray = new String[] { 139 Downloads.Impl._ID, 140 Downloads.Impl.COLUMN_APP_DATA, 141 Downloads.Impl._DATA, 142 Downloads.Impl.COLUMN_MIME_TYPE, 143 Downloads.Impl.COLUMN_VISIBILITY, 144 Downloads.Impl.COLUMN_DESTINATION, 145 Downloads.Impl.COLUMN_CONTROL, 146 Downloads.Impl.COLUMN_STATUS, 147 Downloads.Impl.COLUMN_LAST_MODIFICATION, 148 Downloads.Impl.COLUMN_NOTIFICATION_PACKAGE, 149 Downloads.Impl.COLUMN_NOTIFICATION_CLASS, 150 Downloads.Impl.COLUMN_TOTAL_BYTES, 151 Downloads.Impl.COLUMN_CURRENT_BYTES, 152 Downloads.Impl.COLUMN_TITLE, 153 Downloads.Impl.COLUMN_DESCRIPTION, 154 Downloads.Impl.COLUMN_URI, 155 Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI, 156 Downloads.Impl.COLUMN_FILE_NAME_HINT, 157 Downloads.Impl.COLUMN_MEDIAPROVIDER_URI, 158 Downloads.Impl.COLUMN_DELETED, 159 OpenableColumns.DISPLAY_NAME, 160 OpenableColumns.SIZE, 161 }; 162 163 private static final HashSet<String> sAppReadableColumnsSet; 164 private static final HashMap<String, String> sColumnsMap; 165 166 static { 167 sAppReadableColumnsSet = new HashSet<String>(); 168 for (int i = 0; i < sAppReadableColumnsArray.length; ++i) { 169 sAppReadableColumnsSet.add(sAppReadableColumnsArray[i]); 170 } 171 172 sColumnsMap = Maps.newHashMap(); 173 sColumnsMap.put(OpenableColumns.DISPLAY_NAME, 174 Downloads.Impl.COLUMN_TITLE + " AS " + OpenableColumns.DISPLAY_NAME); 175 sColumnsMap.put(OpenableColumns.SIZE, 176 Downloads.Impl.COLUMN_TOTAL_BYTES + " AS " + OpenableColumns.SIZE); 177 } 178 private static final List<String> downloadManagerColumnsList = 179 Arrays.asList(DownloadManager.UNDERLYING_COLUMNS); 180 181 @VisibleForTesting 182 SystemFacade mSystemFacade; 183 184 /** The database that lies underneath this content provider */ 185 private SQLiteOpenHelper mOpenHelper = null; 186 187 /** List of uids that can access the downloads */ 188 private int mSystemUid = -1; 189 private int mDefContainerUid = -1; 190 191 /** 192 * This class encapsulates a SQL where clause and its parameters. It makes it possible for 193 * shared methods (like {@link DownloadProvider#getWhereClause(Uri, String, String[], int)}) 194 * to return both pieces of information, and provides some utility logic to ease piece-by-piece 195 * construction of selections. 196 */ 197 private static class SqlSelection { 198 public StringBuilder mWhereClause = new StringBuilder(); 199 public List<String> mParameters = new ArrayList<String>(); 200 201 public <T> void appendClause(String newClause, final T... parameters) { 202 if (newClause == null || newClause.isEmpty()) { 203 return; 204 } 205 if (mWhereClause.length() != 0) { 206 mWhereClause.append(" AND "); 207 } 208 mWhereClause.append("("); 209 mWhereClause.append(newClause); 210 mWhereClause.append(")"); 211 if (parameters != null) { 212 for (Object parameter : parameters) { 213 mParameters.add(parameter.toString()); 214 } 215 } 216 } 217 218 public String getSelection() { 219 return mWhereClause.toString(); 220 } 221 222 public String[] getParameters() { 223 String[] array = new String[mParameters.size()]; 224 return mParameters.toArray(array); 225 } 226 } 227 228 /** 229 * Creates and updated database on demand when opening it. 230 * Helper class to create database the first time the provider is 231 * initialized and upgrade it when a new version of the provider needs 232 * an updated version of the database. 233 */ 234 private final class DatabaseHelper extends SQLiteOpenHelper { 235 public DatabaseHelper(final Context context) { 236 super(context, DB_NAME, null, DB_VERSION); 237 } 238 239 /** 240 * Creates database the first time we try to open it. 241 */ 242 @Override 243 public void onCreate(final SQLiteDatabase db) { 244 if (Constants.LOGVV) { 245 Log.v(Constants.TAG, "populating new database"); 246 } 247 onUpgrade(db, 0, DB_VERSION); 248 } 249 250 /** 251 * Updates the database format when a content provider is used 252 * with a database that was created with a different format. 253 * 254 * Note: to support downgrades, creating a table should always drop it first if it already 255 * exists. 256 */ 257 @Override 258 public void onUpgrade(final SQLiteDatabase db, int oldV, final int newV) { 259 if (oldV == 31) { 260 // 31 and 100 are identical, just in different codelines. Upgrading from 31 is the 261 // same as upgrading from 100. 262 oldV = 100; 263 } else if (oldV < 100) { 264 // no logic to upgrade from these older version, just recreate the DB 265 Log.i(Constants.TAG, "Upgrading downloads database from version " + oldV 266 + " to version " + newV + ", which will destroy all old data"); 267 oldV = 99; 268 } else if (oldV > newV) { 269 // user must have downgraded software; we have no way to know how to downgrade the 270 // DB, so just recreate it 271 Log.i(Constants.TAG, "Downgrading downloads database from version " + oldV 272 + " (current version is " + newV + "), destroying all old data"); 273 oldV = 99; 274 } 275 276 for (int version = oldV + 1; version <= newV; version++) { 277 upgradeTo(db, version); 278 } 279 } 280 281 /** 282 * Upgrade database from (version - 1) to version. 283 */ 284 private void upgradeTo(SQLiteDatabase db, int version) { 285 switch (version) { 286 case 100: 287 createDownloadsTable(db); 288 break; 289 290 case 101: 291 createHeadersTable(db); 292 break; 293 294 case 102: 295 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_IS_PUBLIC_API, 296 "INTEGER NOT NULL DEFAULT 0"); 297 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_ALLOW_ROAMING, 298 "INTEGER NOT NULL DEFAULT 0"); 299 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_ALLOWED_NETWORK_TYPES, 300 "INTEGER NOT NULL DEFAULT 0"); 301 break; 302 303 case 103: 304 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI, 305 "INTEGER NOT NULL DEFAULT 1"); 306 makeCacheDownloadsInvisible(db); 307 break; 308 309 case 104: 310 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_BYPASS_RECOMMENDED_SIZE_LIMIT, 311 "INTEGER NOT NULL DEFAULT 0"); 312 break; 313 314 case 105: 315 fillNullValues(db); 316 break; 317 318 case 106: 319 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_MEDIAPROVIDER_URI, "TEXT"); 320 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_DELETED, 321 "BOOLEAN NOT NULL DEFAULT 0"); 322 break; 323 324 case 107: 325 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_ERROR_MSG, "TEXT"); 326 break; 327 328 case 108: 329 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_ALLOW_METERED, 330 "INTEGER NOT NULL DEFAULT 1"); 331 break; 332 333 case 109: 334 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_ALLOW_WRITE, 335 "BOOLEAN NOT NULL DEFAULT 0"); 336 break; 337 338 case 110: 339 addColumn(db, DB_TABLE, Downloads.Impl.COLUMN_FLAGS, 340 "INTEGER NOT NULL DEFAULT 0"); 341 break; 342 343 default: 344 throw new IllegalStateException("Don't know how to upgrade to " + version); 345 } 346 } 347 348 /** 349 * insert() now ensures these four columns are never null for new downloads, so this method 350 * makes that true for existing columns, so that code can rely on this assumption. 351 */ 352 private void fillNullValues(SQLiteDatabase db) { 353 ContentValues values = new ContentValues(); 354 values.put(Downloads.Impl.COLUMN_CURRENT_BYTES, 0); 355 fillNullValuesForColumn(db, values); 356 values.put(Downloads.Impl.COLUMN_TOTAL_BYTES, -1); 357 fillNullValuesForColumn(db, values); 358 values.put(Downloads.Impl.COLUMN_TITLE, ""); 359 fillNullValuesForColumn(db, values); 360 values.put(Downloads.Impl.COLUMN_DESCRIPTION, ""); 361 fillNullValuesForColumn(db, values); 362 } 363 364 private void fillNullValuesForColumn(SQLiteDatabase db, ContentValues values) { 365 String column = values.valueSet().iterator().next().getKey(); 366 db.update(DB_TABLE, values, column + " is null", null); 367 values.clear(); 368 } 369 370 /** 371 * Set all existing downloads to the cache partition to be invisible in the downloads UI. 372 */ 373 private void makeCacheDownloadsInvisible(SQLiteDatabase db) { 374 ContentValues values = new ContentValues(); 375 values.put(Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI, false); 376 String cacheSelection = Downloads.Impl.COLUMN_DESTINATION 377 + " != " + Downloads.Impl.DESTINATION_EXTERNAL; 378 db.update(DB_TABLE, values, cacheSelection, null); 379 } 380 381 /** 382 * Add a column to a table using ALTER TABLE. 383 * @param dbTable name of the table 384 * @param columnName name of the column to add 385 * @param columnDefinition SQL for the column definition 386 */ 387 private void addColumn(SQLiteDatabase db, String dbTable, String columnName, 388 String columnDefinition) { 389 db.execSQL("ALTER TABLE " + dbTable + " ADD COLUMN " + columnName + " " 390 + columnDefinition); 391 } 392 393 /** 394 * Creates the table that'll hold the download information. 395 */ 396 private void createDownloadsTable(SQLiteDatabase db) { 397 try { 398 db.execSQL("DROP TABLE IF EXISTS " + DB_TABLE); 399 db.execSQL("CREATE TABLE " + DB_TABLE + "(" + 400 Downloads.Impl._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," + 401 Downloads.Impl.COLUMN_URI + " TEXT, " + 402 Constants.RETRY_AFTER_X_REDIRECT_COUNT + " INTEGER, " + 403 Downloads.Impl.COLUMN_APP_DATA + " TEXT, " + 404 Downloads.Impl.COLUMN_NO_INTEGRITY + " BOOLEAN, " + 405 Downloads.Impl.COLUMN_FILE_NAME_HINT + " TEXT, " + 406 Constants.OTA_UPDATE + " BOOLEAN, " + 407 Downloads.Impl._DATA + " TEXT, " + 408 Downloads.Impl.COLUMN_MIME_TYPE + " TEXT, " + 409 Downloads.Impl.COLUMN_DESTINATION + " INTEGER, " + 410 Constants.NO_SYSTEM_FILES + " BOOLEAN, " + 411 Downloads.Impl.COLUMN_VISIBILITY + " INTEGER, " + 412 Downloads.Impl.COLUMN_CONTROL + " INTEGER, " + 413 Downloads.Impl.COLUMN_STATUS + " INTEGER, " + 414 Downloads.Impl.COLUMN_FAILED_CONNECTIONS + " INTEGER, " + 415 Downloads.Impl.COLUMN_LAST_MODIFICATION + " BIGINT, " + 416 Downloads.Impl.COLUMN_NOTIFICATION_PACKAGE + " TEXT, " + 417 Downloads.Impl.COLUMN_NOTIFICATION_CLASS + " TEXT, " + 418 Downloads.Impl.COLUMN_NOTIFICATION_EXTRAS + " TEXT, " + 419 Downloads.Impl.COLUMN_COOKIE_DATA + " TEXT, " + 420 Downloads.Impl.COLUMN_USER_AGENT + " TEXT, " + 421 Downloads.Impl.COLUMN_REFERER + " TEXT, " + 422 Downloads.Impl.COLUMN_TOTAL_BYTES + " INTEGER, " + 423 Downloads.Impl.COLUMN_CURRENT_BYTES + " INTEGER, " + 424 Constants.ETAG + " TEXT, " + 425 Constants.UID + " INTEGER, " + 426 Downloads.Impl.COLUMN_OTHER_UID + " INTEGER, " + 427 Downloads.Impl.COLUMN_TITLE + " TEXT, " + 428 Downloads.Impl.COLUMN_DESCRIPTION + " TEXT, " + 429 Downloads.Impl.COLUMN_MEDIA_SCANNED + " BOOLEAN);"); 430 } catch (SQLException ex) { 431 Log.e(Constants.TAG, "couldn't create table in downloads database"); 432 throw ex; 433 } 434 } 435 436 private void createHeadersTable(SQLiteDatabase db) { 437 db.execSQL("DROP TABLE IF EXISTS " + Downloads.Impl.RequestHeaders.HEADERS_DB_TABLE); 438 db.execSQL("CREATE TABLE " + Downloads.Impl.RequestHeaders.HEADERS_DB_TABLE + "(" + 439 "id INTEGER PRIMARY KEY AUTOINCREMENT," + 440 Downloads.Impl.RequestHeaders.COLUMN_DOWNLOAD_ID + " INTEGER NOT NULL," + 441 Downloads.Impl.RequestHeaders.COLUMN_HEADER + " TEXT NOT NULL," + 442 Downloads.Impl.RequestHeaders.COLUMN_VALUE + " TEXT NOT NULL" + 443 ");"); 444 } 445 } 446 447 /** 448 * Initializes the content provider when it is created. 449 */ 450 @Override 451 public boolean onCreate() { 452 if (mSystemFacade == null) { 453 mSystemFacade = new RealSystemFacade(getContext()); 454 } 455 456 mOpenHelper = new DatabaseHelper(getContext()); 457 // Initialize the system uid 458 mSystemUid = Process.SYSTEM_UID; 459 // Initialize the default container uid. Package name hardcoded 460 // for now. 461 ApplicationInfo appInfo = null; 462 try { 463 appInfo = getContext().getPackageManager(). 464 getApplicationInfo("com.android.defcontainer", 0); 465 } catch (NameNotFoundException e) { 466 Log.wtf(Constants.TAG, "Could not get ApplicationInfo for com.android.defconatiner", e); 467 } 468 if (appInfo != null) { 469 mDefContainerUid = appInfo.uid; 470 } 471 return true; 472 } 473 474 /** 475 * Returns the content-provider-style MIME types of the various 476 * types accessible through this content provider. 477 */ 478 @Override 479 public String getType(final Uri uri) { 480 int match = sURIMatcher.match(uri); 481 switch (match) { 482 case MY_DOWNLOADS: 483 case ALL_DOWNLOADS: { 484 return DOWNLOAD_LIST_TYPE; 485 } 486 case MY_DOWNLOADS_ID: 487 case ALL_DOWNLOADS_ID: 488 case PUBLIC_DOWNLOAD_ID: { 489 // return the mimetype of this id from the database 490 final String id = getDownloadIdFromUri(uri); 491 final SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 492 final String mimeType = DatabaseUtils.stringForQuery(db, 493 "SELECT " + Downloads.Impl.COLUMN_MIME_TYPE + " FROM " + DB_TABLE + 494 " WHERE " + Downloads.Impl._ID + " = ?", 495 new String[]{id}); 496 if (TextUtils.isEmpty(mimeType)) { 497 return DOWNLOAD_TYPE; 498 } else { 499 return mimeType; 500 } 501 } 502 default: { 503 if (Constants.LOGV) { 504 Log.v(Constants.TAG, "calling getType on an unknown URI: " + uri); 505 } 506 throw new IllegalArgumentException("Unknown URI: " + uri); 507 } 508 } 509 } 510 511 /** 512 * Inserts a row in the database 513 */ 514 @Override 515 public Uri insert(final Uri uri, final ContentValues values) { 516 checkInsertPermissions(values); 517 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 518 519 // note we disallow inserting into ALL_DOWNLOADS 520 int match = sURIMatcher.match(uri); 521 if (match != MY_DOWNLOADS) { 522 Log.d(Constants.TAG, "calling insert on an unknown/invalid URI: " + uri); 523 throw new IllegalArgumentException("Unknown/Invalid URI " + uri); 524 } 525 526 // copy some of the input values as it 527 ContentValues filteredValues = new ContentValues(); 528 copyString(Downloads.Impl.COLUMN_URI, values, filteredValues); 529 copyString(Downloads.Impl.COLUMN_APP_DATA, values, filteredValues); 530 copyBoolean(Downloads.Impl.COLUMN_NO_INTEGRITY, values, filteredValues); 531 copyString(Downloads.Impl.COLUMN_FILE_NAME_HINT, values, filteredValues); 532 copyString(Downloads.Impl.COLUMN_MIME_TYPE, values, filteredValues); 533 copyBoolean(Downloads.Impl.COLUMN_IS_PUBLIC_API, values, filteredValues); 534 535 boolean isPublicApi = 536 values.getAsBoolean(Downloads.Impl.COLUMN_IS_PUBLIC_API) == Boolean.TRUE; 537 538 // validate the destination column 539 Integer dest = values.getAsInteger(Downloads.Impl.COLUMN_DESTINATION); 540 if (dest != null) { 541 if (getContext().checkCallingOrSelfPermission(Downloads.Impl.PERMISSION_ACCESS_ADVANCED) 542 != PackageManager.PERMISSION_GRANTED 543 && (dest == Downloads.Impl.DESTINATION_CACHE_PARTITION 544 || dest == Downloads.Impl.DESTINATION_CACHE_PARTITION_NOROAMING 545 || dest == Downloads.Impl.DESTINATION_SYSTEMCACHE_PARTITION)) { 546 throw new SecurityException("setting destination to : " + dest + 547 " not allowed, unless PERMISSION_ACCESS_ADVANCED is granted"); 548 } 549 // for public API behavior, if an app has CACHE_NON_PURGEABLE permission, automatically 550 // switch to non-purgeable download 551 boolean hasNonPurgeablePermission = 552 getContext().checkCallingOrSelfPermission( 553 Downloads.Impl.PERMISSION_CACHE_NON_PURGEABLE) 554 == PackageManager.PERMISSION_GRANTED; 555 if (isPublicApi && dest == Downloads.Impl.DESTINATION_CACHE_PARTITION_PURGEABLE 556 && hasNonPurgeablePermission) { 557 dest = Downloads.Impl.DESTINATION_CACHE_PARTITION; 558 } 559 if (dest == Downloads.Impl.DESTINATION_FILE_URI) { 560 checkFileUriDestination(values); 561 562 } else if (dest == Downloads.Impl.DESTINATION_EXTERNAL) { 563 getContext().enforceCallingOrSelfPermission( 564 android.Manifest.permission.WRITE_EXTERNAL_STORAGE, 565 "No permission to write"); 566 567 final AppOpsManager appOps = getContext().getSystemService(AppOpsManager.class); 568 if (appOps.noteProxyOp(AppOpsManager.OP_WRITE_EXTERNAL_STORAGE, 569 getCallingPackage()) != AppOpsManager.MODE_ALLOWED) { 570 throw new SecurityException("No permission to write"); 571 } 572 573 } else if (dest == Downloads.Impl.DESTINATION_SYSTEMCACHE_PARTITION) { 574 getContext().enforcePermission( 575 android.Manifest.permission.ACCESS_CACHE_FILESYSTEM, 576 Binder.getCallingPid(), Binder.getCallingUid(), 577 "need ACCESS_CACHE_FILESYSTEM permission to use system cache"); 578 } 579 filteredValues.put(Downloads.Impl.COLUMN_DESTINATION, dest); 580 } 581 582 // validate the visibility column 583 Integer vis = values.getAsInteger(Downloads.Impl.COLUMN_VISIBILITY); 584 if (vis == null) { 585 if (dest == Downloads.Impl.DESTINATION_EXTERNAL) { 586 filteredValues.put(Downloads.Impl.COLUMN_VISIBILITY, 587 Downloads.Impl.VISIBILITY_VISIBLE_NOTIFY_COMPLETED); 588 } else { 589 filteredValues.put(Downloads.Impl.COLUMN_VISIBILITY, 590 Downloads.Impl.VISIBILITY_HIDDEN); 591 } 592 } else { 593 filteredValues.put(Downloads.Impl.COLUMN_VISIBILITY, vis); 594 } 595 // copy the control column as is 596 copyInteger(Downloads.Impl.COLUMN_CONTROL, values, filteredValues); 597 598 /* 599 * requests coming from 600 * DownloadManager.addCompletedDownload(String, String, String, 601 * boolean, String, String, long) need special treatment 602 */ 603 if (values.getAsInteger(Downloads.Impl.COLUMN_DESTINATION) == 604 Downloads.Impl.DESTINATION_NON_DOWNLOADMANAGER_DOWNLOAD) { 605 // these requests always are marked as 'completed' 606 filteredValues.put(Downloads.Impl.COLUMN_STATUS, Downloads.Impl.STATUS_SUCCESS); 607 filteredValues.put(Downloads.Impl.COLUMN_TOTAL_BYTES, 608 values.getAsLong(Downloads.Impl.COLUMN_TOTAL_BYTES)); 609 filteredValues.put(Downloads.Impl.COLUMN_CURRENT_BYTES, 0); 610 copyInteger(Downloads.Impl.COLUMN_MEDIA_SCANNED, values, filteredValues); 611 copyString(Downloads.Impl._DATA, values, filteredValues); 612 copyBoolean(Downloads.Impl.COLUMN_ALLOW_WRITE, values, filteredValues); 613 } else { 614 filteredValues.put(Downloads.Impl.COLUMN_STATUS, Downloads.Impl.STATUS_PENDING); 615 filteredValues.put(Downloads.Impl.COLUMN_TOTAL_BYTES, -1); 616 filteredValues.put(Downloads.Impl.COLUMN_CURRENT_BYTES, 0); 617 } 618 619 // set lastupdate to current time 620 long lastMod = mSystemFacade.currentTimeMillis(); 621 filteredValues.put(Downloads.Impl.COLUMN_LAST_MODIFICATION, lastMod); 622 623 // use packagename of the caller to set the notification columns 624 String pckg = values.getAsString(Downloads.Impl.COLUMN_NOTIFICATION_PACKAGE); 625 String clazz = values.getAsString(Downloads.Impl.COLUMN_NOTIFICATION_CLASS); 626 if (pckg != null && (clazz != null || isPublicApi)) { 627 int uid = Binder.getCallingUid(); 628 try { 629 if (uid == 0 || mSystemFacade.userOwnsPackage(uid, pckg)) { 630 filteredValues.put(Downloads.Impl.COLUMN_NOTIFICATION_PACKAGE, pckg); 631 if (clazz != null) { 632 filteredValues.put(Downloads.Impl.COLUMN_NOTIFICATION_CLASS, clazz); 633 } 634 } 635 } catch (PackageManager.NameNotFoundException ex) { 636 /* ignored for now */ 637 } 638 } 639 640 // copy some more columns as is 641 copyString(Downloads.Impl.COLUMN_NOTIFICATION_EXTRAS, values, filteredValues); 642 copyString(Downloads.Impl.COLUMN_COOKIE_DATA, values, filteredValues); 643 copyString(Downloads.Impl.COLUMN_USER_AGENT, values, filteredValues); 644 copyString(Downloads.Impl.COLUMN_REFERER, values, filteredValues); 645 646 // UID, PID columns 647 if (getContext().checkCallingOrSelfPermission(Downloads.Impl.PERMISSION_ACCESS_ADVANCED) 648 == PackageManager.PERMISSION_GRANTED) { 649 copyInteger(Downloads.Impl.COLUMN_OTHER_UID, values, filteredValues); 650 } 651 filteredValues.put(Constants.UID, Binder.getCallingUid()); 652 if (Binder.getCallingUid() == 0) { 653 copyInteger(Constants.UID, values, filteredValues); 654 } 655 656 // copy some more columns as is 657 copyStringWithDefault(Downloads.Impl.COLUMN_TITLE, values, filteredValues, ""); 658 copyStringWithDefault(Downloads.Impl.COLUMN_DESCRIPTION, values, filteredValues, ""); 659 660 // is_visible_in_downloads_ui column 661 if (values.containsKey(Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI)) { 662 copyBoolean(Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI, values, filteredValues); 663 } else { 664 // by default, make external downloads visible in the UI 665 boolean isExternal = (dest == null || dest == Downloads.Impl.DESTINATION_EXTERNAL); 666 filteredValues.put(Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI, isExternal); 667 } 668 669 // public api requests and networktypes/roaming columns 670 if (isPublicApi) { 671 copyInteger(Downloads.Impl.COLUMN_ALLOWED_NETWORK_TYPES, values, filteredValues); 672 copyBoolean(Downloads.Impl.COLUMN_ALLOW_ROAMING, values, filteredValues); 673 copyBoolean(Downloads.Impl.COLUMN_ALLOW_METERED, values, filteredValues); 674 copyInteger(Downloads.Impl.COLUMN_FLAGS, values, filteredValues); 675 } 676 677 if (Constants.LOGVV) { 678 Log.v(Constants.TAG, "initiating download with UID " 679 + filteredValues.getAsInteger(Constants.UID)); 680 if (filteredValues.containsKey(Downloads.Impl.COLUMN_OTHER_UID)) { 681 Log.v(Constants.TAG, "other UID " + 682 filteredValues.getAsInteger(Downloads.Impl.COLUMN_OTHER_UID)); 683 } 684 } 685 686 long rowID = db.insert(DB_TABLE, null, filteredValues); 687 if (rowID == -1) { 688 Log.d(Constants.TAG, "couldn't insert into downloads database"); 689 return null; 690 } 691 692 insertRequestHeaders(db, rowID, values); 693 notifyContentChanged(uri, match); 694 695 final long token = Binder.clearCallingIdentity(); 696 try { 697 Helpers.scheduleJob(getContext(), rowID); 698 } finally { 699 Binder.restoreCallingIdentity(token); 700 } 701 702 if (values.getAsInteger(COLUMN_DESTINATION) == DESTINATION_NON_DOWNLOADMANAGER_DOWNLOAD 703 && values.getAsInteger(COLUMN_MEDIA_SCANNED) == 0) { 704 DownloadScanner.requestScanBlocking(getContext(), rowID, values.getAsString(_DATA), 705 values.getAsString(COLUMN_MIME_TYPE)); 706 } 707 708 return ContentUris.withAppendedId(Downloads.Impl.CONTENT_URI, rowID); 709 } 710 711 /** 712 * Check that the file URI provided for DESTINATION_FILE_URI is valid. 713 */ 714 private void checkFileUriDestination(ContentValues values) { 715 String fileUri = values.getAsString(Downloads.Impl.COLUMN_FILE_NAME_HINT); 716 if (fileUri == null) { 717 throw new IllegalArgumentException( 718 "DESTINATION_FILE_URI must include a file URI under COLUMN_FILE_NAME_HINT"); 719 } 720 Uri uri = Uri.parse(fileUri); 721 String scheme = uri.getScheme(); 722 if (scheme == null || !scheme.equals("file")) { 723 throw new IllegalArgumentException("Not a file URI: " + uri); 724 } 725 final String path = uri.getPath(); 726 if (path == null) { 727 throw new IllegalArgumentException("Invalid file URI: " + uri); 728 } 729 730 final File file; 731 try { 732 file = new File(path).getCanonicalFile(); 733 } catch (IOException e) { 734 throw new SecurityException(e); 735 } 736 737 if (Helpers.isFilenameValidInExternalPackage(getContext(), file, getCallingPackage())) { 738 // No permissions required for paths belonging to calling package 739 return; 740 } else if (Helpers.isFilenameValidInExternal(getContext(), file)) { 741 // Otherwise we require write permission 742 getContext().enforceCallingOrSelfPermission( 743 android.Manifest.permission.WRITE_EXTERNAL_STORAGE, 744 "No permission to write to " + file); 745 746 final AppOpsManager appOps = getContext().getSystemService(AppOpsManager.class); 747 if (appOps.noteProxyOp(AppOpsManager.OP_WRITE_EXTERNAL_STORAGE, 748 getCallingPackage()) != AppOpsManager.MODE_ALLOWED) { 749 throw new SecurityException("No permission to write to " + file); 750 } 751 752 } else { 753 throw new SecurityException("Unsupported path " + file); 754 } 755 } 756 757 /** 758 * Apps with the ACCESS_DOWNLOAD_MANAGER permission can access this provider freely, subject to 759 * constraints in the rest of the code. Apps without that may still access this provider through 760 * the public API, but additional restrictions are imposed. We check those restrictions here. 761 * 762 * @param values ContentValues provided to insert() 763 * @throws SecurityException if the caller has insufficient permissions 764 */ 765 private void checkInsertPermissions(ContentValues values) { 766 if (getContext().checkCallingOrSelfPermission(Downloads.Impl.PERMISSION_ACCESS) 767 == PackageManager.PERMISSION_GRANTED) { 768 return; 769 } 770 771 getContext().enforceCallingOrSelfPermission(android.Manifest.permission.INTERNET, 772 "INTERNET permission is required to use the download manager"); 773 774 // ensure the request fits within the bounds of a public API request 775 // first copy so we can remove values 776 values = new ContentValues(values); 777 778 // check columns whose values are restricted 779 enforceAllowedValues(values, Downloads.Impl.COLUMN_IS_PUBLIC_API, Boolean.TRUE); 780 781 // validate the destination column 782 if (values.getAsInteger(Downloads.Impl.COLUMN_DESTINATION) == 783 Downloads.Impl.DESTINATION_NON_DOWNLOADMANAGER_DOWNLOAD) { 784 /* this row is inserted by 785 * DownloadManager.addCompletedDownload(String, String, String, 786 * boolean, String, String, long) 787 */ 788 values.remove(Downloads.Impl.COLUMN_TOTAL_BYTES); 789 values.remove(Downloads.Impl._DATA); 790 values.remove(Downloads.Impl.COLUMN_STATUS); 791 } 792 enforceAllowedValues(values, Downloads.Impl.COLUMN_DESTINATION, 793 Downloads.Impl.DESTINATION_CACHE_PARTITION_PURGEABLE, 794 Downloads.Impl.DESTINATION_FILE_URI, 795 Downloads.Impl.DESTINATION_NON_DOWNLOADMANAGER_DOWNLOAD); 796 797 if (getContext().checkCallingOrSelfPermission(Downloads.Impl.PERMISSION_NO_NOTIFICATION) 798 == PackageManager.PERMISSION_GRANTED) { 799 enforceAllowedValues(values, Downloads.Impl.COLUMN_VISIBILITY, 800 Request.VISIBILITY_HIDDEN, 801 Request.VISIBILITY_VISIBLE, 802 Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED, 803 Request.VISIBILITY_VISIBLE_NOTIFY_ONLY_COMPLETION); 804 } else { 805 enforceAllowedValues(values, Downloads.Impl.COLUMN_VISIBILITY, 806 Request.VISIBILITY_VISIBLE, 807 Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED, 808 Request.VISIBILITY_VISIBLE_NOTIFY_ONLY_COMPLETION); 809 } 810 811 // remove the rest of the columns that are allowed (with any value) 812 values.remove(Downloads.Impl.COLUMN_URI); 813 values.remove(Downloads.Impl.COLUMN_TITLE); 814 values.remove(Downloads.Impl.COLUMN_DESCRIPTION); 815 values.remove(Downloads.Impl.COLUMN_MIME_TYPE); 816 values.remove(Downloads.Impl.COLUMN_FILE_NAME_HINT); // checked later in insert() 817 values.remove(Downloads.Impl.COLUMN_NOTIFICATION_PACKAGE); // checked later in insert() 818 values.remove(Downloads.Impl.COLUMN_ALLOWED_NETWORK_TYPES); 819 values.remove(Downloads.Impl.COLUMN_ALLOW_ROAMING); 820 values.remove(Downloads.Impl.COLUMN_ALLOW_METERED); 821 values.remove(Downloads.Impl.COLUMN_FLAGS); 822 values.remove(Downloads.Impl.COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI); 823 values.remove(Downloads.Impl.COLUMN_MEDIA_SCANNED); 824 values.remove(Downloads.Impl.COLUMN_ALLOW_WRITE); 825 Iterator<Map.Entry<String, Object>> iterator = values.valueSet().iterator(); 826 while (iterator.hasNext()) { 827 String key = iterator.next().getKey(); 828 if (key.startsWith(Downloads.Impl.RequestHeaders.INSERT_KEY_PREFIX)) { 829 iterator.remove(); 830 } 831 } 832 833 // any extra columns are extraneous and disallowed 834 if (values.size() > 0) { 835 StringBuilder error = new StringBuilder("Invalid columns in request: "); 836 boolean first = true; 837 for (Map.Entry<String, Object> entry : values.valueSet()) { 838 if (!first) { 839 error.append(", "); 840 } 841 error.append(entry.getKey()); 842 } 843 throw new SecurityException(error.toString()); 844 } 845 } 846 847 /** 848 * Remove column from values, and throw a SecurityException if the value isn't within the 849 * specified allowedValues. 850 */ 851 private void enforceAllowedValues(ContentValues values, String column, 852 Object... allowedValues) { 853 Object value = values.get(column); 854 values.remove(column); 855 for (Object allowedValue : allowedValues) { 856 if (value == null && allowedValue == null) { 857 return; 858 } 859 if (value != null && value.equals(allowedValue)) { 860 return; 861 } 862 } 863 throw new SecurityException("Invalid value for " + column + ": " + value); 864 } 865 866 private Cursor queryCleared(Uri uri, String[] projection, String selection, 867 String[] selectionArgs, String sort) { 868 final long token = Binder.clearCallingIdentity(); 869 try { 870 return query(uri, projection, selection, selectionArgs, sort); 871 } finally { 872 Binder.restoreCallingIdentity(token); 873 } 874 } 875 876 /** 877 * Starts a database query 878 */ 879 @Override 880 public Cursor query(final Uri uri, String[] projection, 881 final String selection, final String[] selectionArgs, 882 final String sort) { 883 884 Helpers.validateSelection(selection, sAppReadableColumnsSet); 885 886 SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 887 888 int match = sURIMatcher.match(uri); 889 if (match == -1) { 890 if (Constants.LOGV) { 891 Log.v(Constants.TAG, "querying unknown URI: " + uri); 892 } 893 throw new IllegalArgumentException("Unknown URI: " + uri); 894 } 895 896 if (match == REQUEST_HEADERS_URI) { 897 if (projection != null || selection != null || sort != null) { 898 throw new UnsupportedOperationException("Request header queries do not support " 899 + "projections, selections or sorting"); 900 } 901 return queryRequestHeaders(db, uri); 902 } 903 904 SqlSelection fullSelection = getWhereClause(uri, selection, selectionArgs, match); 905 906 if (shouldRestrictVisibility()) { 907 if (projection == null) { 908 projection = sAppReadableColumnsArray.clone(); 909 } else { 910 // check the validity of the columns in projection 911 for (int i = 0; i < projection.length; ++i) { 912 if (!sAppReadableColumnsSet.contains(projection[i]) && 913 !downloadManagerColumnsList.contains(projection[i])) { 914 throw new IllegalArgumentException( 915 "column " + projection[i] + " is not allowed in queries"); 916 } 917 } 918 } 919 920 for (int i = 0; i < projection.length; i++) { 921 final String newColumn = sColumnsMap.get(projection[i]); 922 if (newColumn != null) { 923 projection[i] = newColumn; 924 } 925 } 926 } 927 928 if (Constants.LOGVV) { 929 logVerboseQueryInfo(projection, selection, selectionArgs, sort, db); 930 } 931 932 Cursor ret = db.query(DB_TABLE, projection, fullSelection.getSelection(), 933 fullSelection.getParameters(), null, null, sort); 934 935 if (ret != null) { 936 ret.setNotificationUri(getContext().getContentResolver(), uri); 937 if (Constants.LOGVV) { 938 Log.v(Constants.TAG, 939 "created cursor " + ret + " on behalf of " + Binder.getCallingPid()); 940 } 941 } else { 942 if (Constants.LOGV) { 943 Log.v(Constants.TAG, "query failed in downloads database"); 944 } 945 } 946 947 return ret; 948 } 949 950 private void logVerboseQueryInfo(String[] projection, final String selection, 951 final String[] selectionArgs, final String sort, SQLiteDatabase db) { 952 java.lang.StringBuilder sb = new java.lang.StringBuilder(); 953 sb.append("starting query, database is "); 954 if (db != null) { 955 sb.append("not "); 956 } 957 sb.append("null; "); 958 if (projection == null) { 959 sb.append("projection is null; "); 960 } else if (projection.length == 0) { 961 sb.append("projection is empty; "); 962 } else { 963 for (int i = 0; i < projection.length; ++i) { 964 sb.append("projection["); 965 sb.append(i); 966 sb.append("] is "); 967 sb.append(projection[i]); 968 sb.append("; "); 969 } 970 } 971 sb.append("selection is "); 972 sb.append(selection); 973 sb.append("; "); 974 if (selectionArgs == null) { 975 sb.append("selectionArgs is null; "); 976 } else if (selectionArgs.length == 0) { 977 sb.append("selectionArgs is empty; "); 978 } else { 979 for (int i = 0; i < selectionArgs.length; ++i) { 980 sb.append("selectionArgs["); 981 sb.append(i); 982 sb.append("] is "); 983 sb.append(selectionArgs[i]); 984 sb.append("; "); 985 } 986 } 987 sb.append("sort is "); 988 sb.append(sort); 989 sb.append("."); 990 Log.v(Constants.TAG, sb.toString()); 991 } 992 993 private String getDownloadIdFromUri(final Uri uri) { 994 return uri.getPathSegments().get(1); 995 } 996 997 /** 998 * Insert request headers for a download into the DB. 999 */ 1000 private void insertRequestHeaders(SQLiteDatabase db, long downloadId, ContentValues values) { 1001 ContentValues rowValues = new ContentValues(); 1002 rowValues.put(Downloads.Impl.RequestHeaders.COLUMN_DOWNLOAD_ID, downloadId); 1003 for (Map.Entry<String, Object> entry : values.valueSet()) { 1004 String key = entry.getKey(); 1005 if (key.startsWith(Downloads.Impl.RequestHeaders.INSERT_KEY_PREFIX)) { 1006 String headerLine = entry.getValue().toString(); 1007 if (!headerLine.contains(":")) { 1008 throw new IllegalArgumentException("Invalid HTTP header line: " + headerLine); 1009 } 1010 String[] parts = headerLine.split(":", 2); 1011 rowValues.put(Downloads.Impl.RequestHeaders.COLUMN_HEADER, parts[0].trim()); 1012 rowValues.put(Downloads.Impl.RequestHeaders.COLUMN_VALUE, parts[1].trim()); 1013 db.insert(Downloads.Impl.RequestHeaders.HEADERS_DB_TABLE, null, rowValues); 1014 } 1015 } 1016 } 1017 1018 /** 1019 * Handle a query for the custom request headers registered for a download. 1020 */ 1021 private Cursor queryRequestHeaders(SQLiteDatabase db, Uri uri) { 1022 String where = Downloads.Impl.RequestHeaders.COLUMN_DOWNLOAD_ID + "=" 1023 + getDownloadIdFromUri(uri); 1024 String[] projection = new String[] {Downloads.Impl.RequestHeaders.COLUMN_HEADER, 1025 Downloads.Impl.RequestHeaders.COLUMN_VALUE}; 1026 return db.query(Downloads.Impl.RequestHeaders.HEADERS_DB_TABLE, projection, where, 1027 null, null, null, null); 1028 } 1029 1030 /** 1031 * Delete request headers for downloads matching the given query. 1032 */ 1033 private void deleteRequestHeaders(SQLiteDatabase db, String where, String[] whereArgs) { 1034 String[] projection = new String[] {Downloads.Impl._ID}; 1035 Cursor cursor = db.query(DB_TABLE, projection, where, whereArgs, null, null, null, null); 1036 try { 1037 for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { 1038 long id = cursor.getLong(0); 1039 String idWhere = Downloads.Impl.RequestHeaders.COLUMN_DOWNLOAD_ID + "=" + id; 1040 db.delete(Downloads.Impl.RequestHeaders.HEADERS_DB_TABLE, idWhere, null); 1041 } 1042 } finally { 1043 cursor.close(); 1044 } 1045 } 1046 1047 /** 1048 * @return true if we should restrict the columns readable by this caller 1049 */ 1050 private boolean shouldRestrictVisibility() { 1051 int callingUid = Binder.getCallingUid(); 1052 return Binder.getCallingPid() != Process.myPid() && 1053 callingUid != mSystemUid && 1054 callingUid != mDefContainerUid; 1055 } 1056 1057 /** 1058 * Updates a row in the database 1059 */ 1060 @Override 1061 public int update(final Uri uri, final ContentValues values, 1062 final String where, final String[] whereArgs) { 1063 1064 Helpers.validateSelection(where, sAppReadableColumnsSet); 1065 1066 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1067 1068 int count; 1069 boolean updateSchedule = false; 1070 1071 ContentValues filteredValues; 1072 if (Binder.getCallingPid() != Process.myPid()) { 1073 filteredValues = new ContentValues(); 1074 copyString(Downloads.Impl.COLUMN_APP_DATA, values, filteredValues); 1075 copyInteger(Downloads.Impl.COLUMN_VISIBILITY, values, filteredValues); 1076 Integer i = values.getAsInteger(Downloads.Impl.COLUMN_CONTROL); 1077 if (i != null) { 1078 filteredValues.put(Downloads.Impl.COLUMN_CONTROL, i); 1079 updateSchedule = true; 1080 } 1081 1082 copyInteger(Downloads.Impl.COLUMN_CONTROL, values, filteredValues); 1083 copyString(Downloads.Impl.COLUMN_TITLE, values, filteredValues); 1084 copyString(Downloads.Impl.COLUMN_MEDIAPROVIDER_URI, values, filteredValues); 1085 copyString(Downloads.Impl.COLUMN_DESCRIPTION, values, filteredValues); 1086 copyInteger(Downloads.Impl.COLUMN_DELETED, values, filteredValues); 1087 } else { 1088 filteredValues = values; 1089 String filename = values.getAsString(Downloads.Impl._DATA); 1090 if (filename != null) { 1091 Cursor c = null; 1092 try { 1093 c = query(uri, new String[] 1094 { Downloads.Impl.COLUMN_TITLE }, null, null, null); 1095 if (!c.moveToFirst() || c.getString(0).isEmpty()) { 1096 values.put(Downloads.Impl.COLUMN_TITLE, new File(filename).getName()); 1097 } 1098 } finally { 1099 IoUtils.closeQuietly(c); 1100 } 1101 } 1102 1103 Integer status = values.getAsInteger(Downloads.Impl.COLUMN_STATUS); 1104 boolean isRestart = status != null && status == Downloads.Impl.STATUS_PENDING; 1105 boolean isUserBypassingSizeLimit = 1106 values.containsKey(Downloads.Impl.COLUMN_BYPASS_RECOMMENDED_SIZE_LIMIT); 1107 if (isRestart || isUserBypassingSizeLimit) { 1108 updateSchedule = true; 1109 } 1110 } 1111 1112 int match = sURIMatcher.match(uri); 1113 switch (match) { 1114 case MY_DOWNLOADS: 1115 case MY_DOWNLOADS_ID: 1116 case ALL_DOWNLOADS: 1117 case ALL_DOWNLOADS_ID: 1118 if (filteredValues.size() == 0) { 1119 count = 0; 1120 break; 1121 } 1122 1123 final SqlSelection selection = getWhereClause(uri, where, whereArgs, match); 1124 count = db.update(DB_TABLE, filteredValues, selection.getSelection(), 1125 selection.getParameters()); 1126 if (updateSchedule) { 1127 final long token = Binder.clearCallingIdentity(); 1128 try { 1129 try (Cursor cursor = db.query(DB_TABLE, new String[] { _ID }, 1130 selection.getSelection(), selection.getParameters(), 1131 null, null, null)) { 1132 while (cursor.moveToNext()) { 1133 Helpers.scheduleJob(getContext(), cursor.getInt(0)); 1134 } 1135 } 1136 } finally { 1137 Binder.restoreCallingIdentity(token); 1138 } 1139 } 1140 break; 1141 1142 default: 1143 Log.d(Constants.TAG, "updating unknown/invalid URI: " + uri); 1144 throw new UnsupportedOperationException("Cannot update URI: " + uri); 1145 } 1146 1147 notifyContentChanged(uri, match); 1148 return count; 1149 } 1150 1151 /** 1152 * Notify of a change through both URIs (/my_downloads and /all_downloads) 1153 * @param uri either URI for the changed download(s) 1154 * @param uriMatch the match ID from {@link #sURIMatcher} 1155 */ 1156 private void notifyContentChanged(final Uri uri, int uriMatch) { 1157 Long downloadId = null; 1158 if (uriMatch == MY_DOWNLOADS_ID || uriMatch == ALL_DOWNLOADS_ID) { 1159 downloadId = Long.parseLong(getDownloadIdFromUri(uri)); 1160 } 1161 for (Uri uriToNotify : BASE_URIS) { 1162 if (downloadId != null) { 1163 uriToNotify = ContentUris.withAppendedId(uriToNotify, downloadId); 1164 } 1165 getContext().getContentResolver().notifyChange(uriToNotify, null); 1166 } 1167 } 1168 1169 private SqlSelection getWhereClause(final Uri uri, final String where, final String[] whereArgs, 1170 int uriMatch) { 1171 SqlSelection selection = new SqlSelection(); 1172 selection.appendClause(where, whereArgs); 1173 if (uriMatch == MY_DOWNLOADS_ID || uriMatch == ALL_DOWNLOADS_ID || 1174 uriMatch == PUBLIC_DOWNLOAD_ID) { 1175 selection.appendClause(Downloads.Impl._ID + " = ?", getDownloadIdFromUri(uri)); 1176 } 1177 if ((uriMatch == MY_DOWNLOADS || uriMatch == MY_DOWNLOADS_ID) 1178 && getContext().checkCallingOrSelfPermission(Downloads.Impl.PERMISSION_ACCESS_ALL) 1179 != PackageManager.PERMISSION_GRANTED) { 1180 selection.appendClause( 1181 Constants.UID + "= ? OR " + Downloads.Impl.COLUMN_OTHER_UID + "= ?", 1182 Binder.getCallingUid(), Binder.getCallingUid()); 1183 } 1184 return selection; 1185 } 1186 1187 /** 1188 * Deletes a row in the database 1189 */ 1190 @Override 1191 public int delete(final Uri uri, final String where, final String[] whereArgs) { 1192 if (shouldRestrictVisibility()) { 1193 Helpers.validateSelection(where, sAppReadableColumnsSet); 1194 } 1195 1196 final JobScheduler scheduler = getContext().getSystemService(JobScheduler.class); 1197 final SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1198 int count; 1199 int match = sURIMatcher.match(uri); 1200 switch (match) { 1201 case MY_DOWNLOADS: 1202 case MY_DOWNLOADS_ID: 1203 case ALL_DOWNLOADS: 1204 case ALL_DOWNLOADS_ID: 1205 final SqlSelection selection = getWhereClause(uri, where, whereArgs, match); 1206 deleteRequestHeaders(db, selection.getSelection(), selection.getParameters()); 1207 1208 try (Cursor cursor = db.query(DB_TABLE, new String[] { 1209 _ID, _DATA, COLUMN_MEDIAPROVIDER_URI 1210 }, selection.getSelection(), selection.getParameters(), null, null, null)) { 1211 while (cursor.moveToNext()) { 1212 final long id = cursor.getLong(0); 1213 scheduler.cancel((int) id); 1214 1215 DownloadStorageProvider.onDownloadProviderDelete(getContext(), id); 1216 1217 final String path = cursor.getString(1); 1218 if (!TextUtils.isEmpty(path)) { 1219 try { 1220 final File file = new File(path).getCanonicalFile(); 1221 if (Helpers.isFilenameValid(getContext(), file)) { 1222 Log.v(Constants.TAG, 1223 "Deleting " + file + " via provider delete"); 1224 file.delete(); 1225 } 1226 } catch (IOException ignored) { 1227 } 1228 } 1229 1230 final String mediaUri = cursor.getString(2); 1231 if (!TextUtils.isEmpty(mediaUri)) { 1232 final long token = Binder.clearCallingIdentity(); 1233 try { 1234 getContext().getContentResolver().delete(Uri.parse(mediaUri), null, 1235 null); 1236 } finally { 1237 Binder.restoreCallingIdentity(token); 1238 } 1239 } 1240 } 1241 } 1242 1243 count = db.delete(DB_TABLE, selection.getSelection(), selection.getParameters()); 1244 break; 1245 1246 default: 1247 Log.d(Constants.TAG, "deleting unknown/invalid URI: " + uri); 1248 throw new UnsupportedOperationException("Cannot delete URI: " + uri); 1249 } 1250 notifyContentChanged(uri, match); 1251 return count; 1252 } 1253 1254 /** 1255 * Remotely opens a file 1256 */ 1257 @Override 1258 public ParcelFileDescriptor openFile(final Uri uri, String mode) throws FileNotFoundException { 1259 if (Constants.LOGVV) { 1260 logVerboseOpenFileInfo(uri, mode); 1261 } 1262 1263 final Cursor cursor = queryCleared(uri, new String[] { 1264 Downloads.Impl._DATA, Downloads.Impl.COLUMN_STATUS, 1265 Downloads.Impl.COLUMN_DESTINATION, Downloads.Impl.COLUMN_MEDIA_SCANNED }, null, 1266 null, null); 1267 final String path; 1268 final boolean shouldScan; 1269 try { 1270 int count = (cursor != null) ? cursor.getCount() : 0; 1271 if (count != 1) { 1272 // If there is not exactly one result, throw an appropriate exception. 1273 if (count == 0) { 1274 throw new FileNotFoundException("No entry for " + uri); 1275 } 1276 throw new FileNotFoundException("Multiple items at " + uri); 1277 } 1278 1279 if (cursor.moveToFirst()) { 1280 final int status = cursor.getInt(1); 1281 final int destination = cursor.getInt(2); 1282 final int mediaScanned = cursor.getInt(3); 1283 1284 path = cursor.getString(0); 1285 shouldScan = Downloads.Impl.isStatusSuccess(status) && ( 1286 destination == Downloads.Impl.DESTINATION_EXTERNAL 1287 || destination == Downloads.Impl.DESTINATION_FILE_URI 1288 || destination == Downloads.Impl.DESTINATION_NON_DOWNLOADMANAGER_DOWNLOAD) 1289 && mediaScanned != 2; 1290 } else { 1291 throw new FileNotFoundException("Failed moveToFirst"); 1292 } 1293 } finally { 1294 IoUtils.closeQuietly(cursor); 1295 } 1296 1297 if (path == null) { 1298 throw new FileNotFoundException("No filename found."); 1299 } 1300 1301 final File file; 1302 try { 1303 file = new File(path).getCanonicalFile(); 1304 } catch (IOException e) { 1305 throw new FileNotFoundException(e.getMessage()); 1306 } 1307 1308 if (!Helpers.isFilenameValid(getContext(), file)) { 1309 throw new FileNotFoundException("Invalid file: " + file); 1310 } 1311 1312 final int pfdMode = ParcelFileDescriptor.parseMode(mode); 1313 if (pfdMode == ParcelFileDescriptor.MODE_READ_ONLY) { 1314 return ParcelFileDescriptor.open(file, pfdMode); 1315 } else { 1316 try { 1317 // When finished writing, update size and timestamp 1318 return ParcelFileDescriptor.open(file, pfdMode, Helpers.getAsyncHandler(), 1319 new OnCloseListener() { 1320 @Override 1321 public void onClose(IOException e) { 1322 final ContentValues values = new ContentValues(); 1323 values.put(Downloads.Impl.COLUMN_TOTAL_BYTES, file.length()); 1324 values.put(Downloads.Impl.COLUMN_LAST_MODIFICATION, 1325 System.currentTimeMillis()); 1326 update(uri, values, null, null); 1327 1328 if (shouldScan) { 1329 final Intent intent = new Intent( 1330 Intent.ACTION_MEDIA_SCANNER_SCAN_FILE); 1331 intent.setData(Uri.fromFile(file)); 1332 getContext().sendBroadcast(intent); 1333 } 1334 } 1335 }); 1336 } catch (IOException e) { 1337 throw new FileNotFoundException("Failed to open for writing: " + e); 1338 } 1339 } 1340 } 1341 1342 @Override 1343 public void dump(FileDescriptor fd, PrintWriter writer, String[] args) { 1344 final IndentingPrintWriter pw = new IndentingPrintWriter(writer, " ", 120); 1345 1346 pw.println("Downloads updated in last hour:"); 1347 pw.increaseIndent(); 1348 1349 final SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 1350 final long modifiedAfter = mSystemFacade.currentTimeMillis() - DateUtils.HOUR_IN_MILLIS; 1351 final Cursor cursor = db.query(DB_TABLE, null, 1352 Downloads.Impl.COLUMN_LAST_MODIFICATION + ">" + modifiedAfter, null, null, null, 1353 Downloads.Impl._ID + " ASC"); 1354 try { 1355 final String[] cols = cursor.getColumnNames(); 1356 final int idCol = cursor.getColumnIndex(BaseColumns._ID); 1357 while (cursor.moveToNext()) { 1358 pw.println("Download #" + cursor.getInt(idCol) + ":"); 1359 pw.increaseIndent(); 1360 for (int i = 0; i < cols.length; i++) { 1361 // Omit sensitive data when dumping 1362 if (Downloads.Impl.COLUMN_COOKIE_DATA.equals(cols[i])) { 1363 continue; 1364 } 1365 pw.printPair(cols[i], cursor.getString(i)); 1366 } 1367 pw.println(); 1368 pw.decreaseIndent(); 1369 } 1370 } finally { 1371 cursor.close(); 1372 } 1373 1374 pw.decreaseIndent(); 1375 } 1376 1377 private void logVerboseOpenFileInfo(Uri uri, String mode) { 1378 Log.v(Constants.TAG, "openFile uri: " + uri + ", mode: " + mode 1379 + ", uid: " + Binder.getCallingUid()); 1380 Cursor cursor = query(Downloads.Impl.CONTENT_URI, 1381 new String[] { "_id" }, null, null, "_id"); 1382 if (cursor == null) { 1383 Log.v(Constants.TAG, "null cursor in openFile"); 1384 } else { 1385 try { 1386 if (!cursor.moveToFirst()) { 1387 Log.v(Constants.TAG, "empty cursor in openFile"); 1388 } else { 1389 do { 1390 Log.v(Constants.TAG, "row " + cursor.getInt(0) + " available"); 1391 } while(cursor.moveToNext()); 1392 } 1393 } finally { 1394 cursor.close(); 1395 } 1396 } 1397 cursor = query(uri, new String[] { "_data" }, null, null, null); 1398 if (cursor == null) { 1399 Log.v(Constants.TAG, "null cursor in openFile"); 1400 } else { 1401 try { 1402 if (!cursor.moveToFirst()) { 1403 Log.v(Constants.TAG, "empty cursor in openFile"); 1404 } else { 1405 String filename = cursor.getString(0); 1406 Log.v(Constants.TAG, "filename in openFile: " + filename); 1407 if (new java.io.File(filename).isFile()) { 1408 Log.v(Constants.TAG, "file exists in openFile"); 1409 } 1410 } 1411 } finally { 1412 cursor.close(); 1413 } 1414 } 1415 } 1416 1417 private static final void copyInteger(String key, ContentValues from, ContentValues to) { 1418 Integer i = from.getAsInteger(key); 1419 if (i != null) { 1420 to.put(key, i); 1421 } 1422 } 1423 1424 private static final void copyBoolean(String key, ContentValues from, ContentValues to) { 1425 Boolean b = from.getAsBoolean(key); 1426 if (b != null) { 1427 to.put(key, b); 1428 } 1429 } 1430 1431 private static final void copyString(String key, ContentValues from, ContentValues to) { 1432 String s = from.getAsString(key); 1433 if (s != null) { 1434 to.put(key, s); 1435 } 1436 } 1437 1438 private static final void copyStringWithDefault(String key, ContentValues from, 1439 ContentValues to, String defaultValue) { 1440 copyString(key, from, to); 1441 if (!to.containsKey(key)) { 1442 to.put(key, defaultValue); 1443 } 1444 } 1445 } 1446
