netwerk/cache/nsCacheEntryDescriptor.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsICache.h"
   8 #include "nsCache.h"
   9 #include "nsCacheService.h"
  10 #include "nsCacheEntryDescriptor.h"
  11 #include "nsCacheEntry.h"
  12 #include "nsReadableUtils.h"
  13 #include "nsIOutputStream.h"
  14 #include "nsCRT.h"
  15
  16 #define kMinDecompressReadBufLen 1024
  17 #define kMinCompressWriteBufLen  1024
  18
  19 NS_IMPL_THREADSAFE_ISUPPORTS2(nsCacheEntryDescriptor,
  20                               nsICacheEntryDescriptor,
  21                               nsICacheEntryInfo)
  22
  23 nsCacheEntryDescriptor::nsCacheEntryDescriptor(nsCacheEntry * entry,
  24                                                nsCacheAccessMode accessGranted)
  25     : mCacheEntry(entry),
  26       mAccessGranted(accessGranted),
  27       mOutput(nullptr)
  28 {
  29     PR_INIT_CLIST(this);
  30     NS_ADDREF(nsCacheService::GlobalInstance());  // ensure it lives for the lifetime of the descriptor
  31 }
  32
  33
  34 nsCacheEntryDescriptor::~nsCacheEntryDescriptor()
  35 {
  36     // No need to close if the cache entry has already been severed.  This
  37     // helps avoid a shutdown assertion (bug 285519) that is caused when
  38     // consumers end up holding onto these objects past xpcom-shutdown.  It's
  39     // okay for them to do that because the cache service calls our Close
  40     // method during xpcom-shutdown, so we don't need to complain about it.
  41     if (mCacheEntry)
  42         Close();
  43
  44     nsCacheService * service = nsCacheService::GlobalInstance();
  45     NS_RELEASE(service);
  46 }
  47
  48
  49 NS_IMETHODIMP
  50 nsCacheEntryDescriptor::GetClientID(char ** result)
  51 {
  52     NS_ENSURE_ARG_POINTER(result);
  53
  54     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETCLIENTID));
  55     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
  56
  57     return ClientIDFromCacheKey(*(mCacheEntry->Key()), result);
  58 }
  59
  60
  61 NS_IMETHODIMP
  62 nsCacheEntryDescriptor::GetDeviceID(char ** aDeviceID)
  63 {
  64     NS_ENSURE_ARG_POINTER(aDeviceID);
  65     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETDEVICEID));
  66     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
  67
  68     const char* deviceID = mCacheEntry->GetDeviceID();
  69     if (!deviceID) {
  70         *aDeviceID = nullptr;
  71         return NS_OK;
  72     }
  73
  74     *aDeviceID = NS_strdup(deviceID);
  75     return *aDeviceID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
  76 }
  77
  78
  79 NS_IMETHODIMP
  80 nsCacheEntryDescriptor::GetKey(nsACString &result)
  81 {
  82     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETKEY));
  83     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
  84
  85     return ClientKeyFromCacheKey(*(mCacheEntry->Key()), result);
  86 }
  87
  88
  89 NS_IMETHODIMP
  90 nsCacheEntryDescriptor::GetFetchCount(PRInt32 *result)
  91 {
  92     NS_ENSURE_ARG_POINTER(result);
  93     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETFETCHCOUNT));
  94     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
  95
  96     *result = mCacheEntry->FetchCount();
  97     return NS_OK;
  98 }
  99
 100
 101 NS_IMETHODIMP
 102 nsCacheEntryDescriptor::GetLastFetched(PRUint32 *result)
 103 {
 104     NS_ENSURE_ARG_POINTER(result);
 105     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETLASTFETCHED));
 106     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 107
 108     *result = mCacheEntry->LastFetched();
 109     return NS_OK;
 110 }
 111
 112
 113 NS_IMETHODIMP
 114 nsCacheEntryDescriptor::GetLastModified(PRUint32 *result)
 115 {
 116     NS_ENSURE_ARG_POINTER(result);
 117     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETLASTMODIFIED));
 118     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 119
 120     *result = mCacheEntry->LastModified();
 121     return NS_OK;
 122 }
 123
 124
 125 NS_IMETHODIMP
 126 nsCacheEntryDescriptor::GetExpirationTime(PRUint32 *result)
 127 {
 128     NS_ENSURE_ARG_POINTER(result);
 129     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETEXPIRATIONTIME));
 130     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 131
 132     *result = mCacheEntry->ExpirationTime();
 133     return NS_OK;
 134 }
 135
 136
 137 NS_IMETHODIMP
 138 nsCacheEntryDescriptor::SetExpirationTime(PRUint32 expirationTime)
 139 {
 140     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETEXPIRATIONTIME));
 141     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 142
 143     mCacheEntry->SetExpirationTime(expirationTime);
 144     mCacheEntry->MarkEntryDirty();
 145     return NS_OK;
 146 }
 147
 148
 149 NS_IMETHODIMP nsCacheEntryDescriptor::IsStreamBased(bool *result)
 150 {
 151     NS_ENSURE_ARG_POINTER(result);
 152     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_ISSTREAMBASED));
 153     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 154
 155     *result = mCacheEntry->IsStreamData();
 156     return NS_OK;
 157 }
 158
 159 NS_IMETHODIMP nsCacheEntryDescriptor::GetPredictedDataSize(PRInt64 *result)
 160 {
 161     NS_ENSURE_ARG_POINTER(result);
 162     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETPREDICTEDDATASIZE));
 163     if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
 164
 165     *result = mCacheEntry->PredictedDataSize();
 166     return NS_OK;
 167 }
 168
 169 NS_IMETHODIMP nsCacheEntryDescriptor::SetPredictedDataSize(PRInt64
 170                                                            predictedSize)
 171 {
 172     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETPREDICTEDDATASIZE));
 173     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 174
 175     mCacheEntry->SetPredictedDataSize(predictedSize);
 176     return NS_OK;
 177 }
 178
 179 NS_IMETHODIMP nsCacheEntryDescriptor::GetDataSize(PRUint32 *result)
 180 {
 181     NS_ENSURE_ARG_POINTER(result);
 182     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETDATASIZE));
 183     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 184
 185     const char* val = mCacheEntry->GetMetaDataElement("uncompressed-len");
 186     if (!val) {
 187         *result = mCacheEntry->DataSize();
 188     } else {
 189         *result = atol(val);
 190     }
 191
 192     return NS_OK;
 193 }
 194
 195
 196 NS_IMETHODIMP nsCacheEntryDescriptor::GetStorageDataSize(PRUint32 *result)
 197 {
 198     NS_ENSURE_ARG_POINTER(result);
 199     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSTORAGEDATASIZE));
 200     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 201
 202     *result = mCacheEntry->DataSize();
 203
 204     return NS_OK;
 205 }
 206
 207
 208 nsresult
 209 nsCacheEntryDescriptor::RequestDataSizeChange(PRInt32 deltaSize)
 210 {
 211     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_REQUESTDATASIZECHANGE));
 212     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 213
 214     nsresult  rv;
 215     rv = nsCacheService::OnDataSizeChange(mCacheEntry, deltaSize);
 216     if (NS_SUCCEEDED(rv)) {
 217         // XXX review for signed/unsigned math errors
 218         PRUint32  newDataSize = mCacheEntry->DataSize() + deltaSize;
 219         mCacheEntry->SetDataSize(newDataSize);
 220         mCacheEntry->TouchData();
 221     }
 222     return rv;
 223 }
 224
 225
 226 NS_IMETHODIMP
 227 nsCacheEntryDescriptor::SetDataSize(PRUint32 dataSize)
 228 {
 229     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETDATASIZE));
 230     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 231
 232     // XXX review for signed/unsigned math errors
 233     PRInt32  deltaSize = dataSize - mCacheEntry->DataSize();
 234
 235     nsresult  rv;
 236     rv = nsCacheService::OnDataSizeChange(mCacheEntry, deltaSize);
 237     // this had better be NS_OK, this call instance is advisory for memory cache objects
 238     if (NS_SUCCEEDED(rv)) {
 239         // XXX review for signed/unsigned math errors
 240         PRUint32  newDataSize = mCacheEntry->DataSize() + deltaSize;
 241         mCacheEntry->SetDataSize(newDataSize);
 242         mCacheEntry->TouchData();
 243     } else {
 244         NS_WARNING("failed SetDataSize() on memory cache object!");
 245     }
 246
 247     return rv;
 248 }
 249
 250
 251 NS_IMETHODIMP
 252 nsCacheEntryDescriptor::OpenInputStream(PRUint32 offset, nsIInputStream ** result)
 253 {
 254     NS_ENSURE_ARG_POINTER(result);
 255
 256     {
 257         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_OPENINPUTSTREAM));
 258         if (!mCacheEntry)                  return NS_ERROR_NOT_AVAILABLE;
 259         if (!mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
 260
 261         // ensure valid permissions
 262         if (!(mAccessGranted & nsICache::ACCESS_READ))
 263             return NS_ERROR_CACHE_READ_ACCESS_DENIED;
 264     }
 265
 266     nsInputStreamWrapper* cacheInput = nullptr;
 267     const char *val;
 268     val = mCacheEntry->GetMetaDataElement("uncompressed-len");
 269     if (val) {
 270         cacheInput = new nsDecompressInputStreamWrapper(this, offset);
 271     } else {
 272         cacheInput = new nsInputStreamWrapper(this, offset);
 273     }
 274     if (!cacheInput) return NS_ERROR_OUT_OF_MEMORY;
 275
 276     NS_ADDREF(*result = cacheInput);
 277     return NS_OK;
 278 }
 279
 280 NS_IMETHODIMP
 281 nsCacheEntryDescriptor::OpenOutputStream(PRUint32 offset, nsIOutputStream ** result)
 282 {
 283     NS_ENSURE_ARG_POINTER(result);
 284
 285     {
 286         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_OPENOUTPUTSTREAM));
 287         if (!mCacheEntry)                  return NS_ERROR_NOT_AVAILABLE;
 288         if (!mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
 289
 290         // ensure valid permissions
 291         if (!(mAccessGranted & nsICache::ACCESS_WRITE))
 292             return NS_ERROR_CACHE_WRITE_ACCESS_DENIED;
 293     }
 294
 295     nsOutputStreamWrapper* cacheOutput = nullptr;
 296     PRInt32 compressionLevel = nsCacheService::CacheCompressionLevel();
 297     const char *val;
 298     val = mCacheEntry->GetMetaDataElement("uncompressed-len");
 299     if ((compressionLevel > 0) && val) {
 300         cacheOutput = new nsCompressOutputStreamWrapper(this, offset);
 301     } else {
 302         // clear compression flag when compression disabled - see bug #715198
 303         if (val) {
 304             mCacheEntry->SetMetaDataElement("uncompressed-len", nullptr);
 305         }
 306         cacheOutput = new nsOutputStreamWrapper(this, offset);
 307     }
 308     if (!cacheOutput) return NS_ERROR_OUT_OF_MEMORY;
 309
 310     NS_ADDREF(*result = cacheOutput);
 311     return NS_OK;
 312 }
 313
 314
 315 NS_IMETHODIMP
 316 nsCacheEntryDescriptor::GetCacheElement(nsISupports ** result)
 317 {
 318     NS_ENSURE_ARG_POINTER(result);
 319     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETCACHEELEMENT));
 320     if (!mCacheEntry)                 return NS_ERROR_NOT_AVAILABLE;
 321     if (mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_STREAM;
 322
 323     NS_IF_ADDREF(*result = mCacheEntry->Data());
 324     return NS_OK;
 325 }
 326
 327
 328 NS_IMETHODIMP
 329 nsCacheEntryDescriptor::SetCacheElement(nsISupports * cacheElement)
 330 {
 331     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETCACHEELEMENT));
 332     if (!mCacheEntry)                 return NS_ERROR_NOT_AVAILABLE;
 333     if (mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_STREAM;
 334
 335     return nsCacheService::SetCacheElement(mCacheEntry, cacheElement);
 336 }
 337
 338
 339 NS_IMETHODIMP
 340 nsCacheEntryDescriptor::GetAccessGranted(nsCacheAccessMode *result)
 341 {
 342     NS_ENSURE_ARG_POINTER(result);
 343     *result = mAccessGranted;
 344     return NS_OK;
 345 }
 346
 347
 348 NS_IMETHODIMP
 349 nsCacheEntryDescriptor::GetStoragePolicy(nsCacheStoragePolicy *result)
 350 {
 351     NS_ENSURE_ARG_POINTER(result);
 352     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSTORAGEPOLICY));
 353     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 354
 355     *result = mCacheEntry->StoragePolicy();
 356     return NS_OK;
 357 }
 358
 359
 360 NS_IMETHODIMP
 361 nsCacheEntryDescriptor::SetStoragePolicy(nsCacheStoragePolicy policy)
 362 {
 363     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETSTORAGEPOLICY));
 364     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 365     // XXX validate policy against session?
 366
 367     bool        storageEnabled = false;
 368     storageEnabled = nsCacheService::IsStorageEnabledForPolicy_Locked(policy);
 369     if (!storageEnabled)    return NS_ERROR_FAILURE;
 370
 371     // Don't change the storage policy of entries we can't write
 372     if (!(mAccessGranted & nsICache::ACCESS_WRITE))
 373         return NS_ERROR_NOT_AVAILABLE;
 374
 375     // Don't allow a cache entry to move from memory-only to anything else
 376     if (mCacheEntry->StoragePolicy() == nsICache::STORE_IN_MEMORY &&
 377         policy != nsICache::STORE_IN_MEMORY)
 378         return NS_ERROR_NOT_AVAILABLE;
 379
 380     mCacheEntry->SetStoragePolicy(policy);
 381     mCacheEntry->MarkEntryDirty();
 382     return NS_OK;
 383 }
 384
 385
 386 NS_IMETHODIMP
 387 nsCacheEntryDescriptor::GetFile(nsIFile ** result)
 388 {
 389     NS_ENSURE_ARG_POINTER(result);
 390     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETFILE));
 391     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 392
 393     return nsCacheService::GetFileForEntry(mCacheEntry, result);
 394 }
 395
 396
 397 NS_IMETHODIMP
 398 nsCacheEntryDescriptor::GetSecurityInfo(nsISupports ** result)
 399 {
 400     NS_ENSURE_ARG_POINTER(result);
 401     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSECURITYINFO));
 402     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 403
 404     *result = mCacheEntry->SecurityInfo();
 405     NS_IF_ADDREF(*result);
 406     return NS_OK;
 407 }
 408
 409
 410 NS_IMETHODIMP
 411 nsCacheEntryDescriptor::SetSecurityInfo(nsISupports * securityInfo)
 412 {
 413     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETSECURITYINFO));
 414     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 415
 416     mCacheEntry->SetSecurityInfo(securityInfo);
 417     mCacheEntry->MarkEntryDirty();
 418     return NS_OK;
 419 }
 420
 421
 422 NS_IMETHODIMP
 423 nsCacheEntryDescriptor::Doom()
 424 {
 425     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_DOOM));
 426     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 427
 428     return nsCacheService::DoomEntry(mCacheEntry);
 429 }
 430
 431
 432 NS_IMETHODIMP
 433 nsCacheEntryDescriptor::DoomAndFailPendingRequests(nsresult status)
 434 {
 435     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_DOOMANDFAILPENDINGREQUESTS));
 436     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 437
 438     return NS_ERROR_NOT_IMPLEMENTED;
 439 }
 440
 441
 442 NS_IMETHODIMP
 443 nsCacheEntryDescriptor::MarkValid()
 444 {
 445     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_MARKVALID));
 446     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 447
 448     nsresult  rv = nsCacheService::ValidateEntry(mCacheEntry);
 449     return rv;
 450 }
 451
 452
 453 NS_IMETHODIMP
 454 nsCacheEntryDescriptor::Close()
 455 {
 456     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_CLOSE));
 457     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 458
 459     // XXX perhaps closing descriptors should clear/sever transports
 460
 461     // tell nsCacheService we're going away
 462     nsCacheService::CloseDescriptor(this);
 463     NS_ASSERTION(mCacheEntry == nullptr, "mCacheEntry not null");
 464
 465     return NS_OK;
 466 }
 467
 468
 469 NS_IMETHODIMP
 470 nsCacheEntryDescriptor::GetMetaDataElement(const char *key, char **result)
 471 {
 472     NS_ENSURE_ARG_POINTER(key);
 473     *result = nullptr;
 474
 475     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETMETADATAELEMENT));
 476     NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE);
 477
 478     const char *value;
 479
 480     value = mCacheEntry->GetMetaDataElement(key);
 481     if (!value) return NS_ERROR_NOT_AVAILABLE;
 482
 483     *result = NS_strdup(value);
 484     if (!*result) return NS_ERROR_OUT_OF_MEMORY;
 485
 486     return NS_OK;
 487 }
 488
 489
 490 NS_IMETHODIMP
 491 nsCacheEntryDescriptor::SetMetaDataElement(const char *key, const char *value)
 492 {
 493     NS_ENSURE_ARG_POINTER(key);
 494
 495     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETMETADATAELEMENT));
 496     NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE);
 497
 498     // XXX allow null value, for clearing key?
 499
 500     nsresult rv = mCacheEntry->SetMetaDataElement(key, value);
 501     if (NS_SUCCEEDED(rv))
 502         mCacheEntry->TouchMetaData();
 503     return rv;
 504 }
 505
 506
 507 NS_IMETHODIMP
 508 nsCacheEntryDescriptor::VisitMetaData(nsICacheMetaDataVisitor * visitor)
 509 {
 510     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_VISITMETADATA));
 511     // XXX check callers, we're calling out of module
 512     NS_ENSURE_ARG_POINTER(visitor);
 513     if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
 514
 515     return mCacheEntry->VisitMetaDataElements(visitor);
 516 }
 517
 518
 519 /******************************************************************************
 520  * nsCacheInputStream - a wrapper for nsIInputStream keeps the cache entry
 521  *                      open while referenced.
 522  ******************************************************************************/
 523
 524 NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheEntryDescriptor::nsInputStreamWrapper,
 525                               nsIInputStream)
 526
 527 nsresult nsCacheEntryDescriptor::
 528 nsInputStreamWrapper::LazyInit()
 529 {
 530     nsCacheServiceAutoLock lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_LAZYINIT));
 531
 532     nsCacheAccessMode mode;
 533     nsresult rv = mDescriptor->GetAccessGranted(&mode);
 534     if (NS_FAILED(rv)) return rv;
 535
 536     NS_ENSURE_TRUE(mode & nsICache::ACCESS_READ, NS_ERROR_UNEXPECTED);
 537
 538     nsCacheEntry* cacheEntry = mDescriptor->CacheEntry();
 539     if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE;
 540
 541     rv = nsCacheService::OpenInputStreamForEntry(cacheEntry, mode,
 542                                                  mStartOffset,
 543                                                  getter_AddRefs(mInput));
 544
 545     CACHE_LOG_DEBUG(("nsInputStreamWrapper::LazyInit "
 546                       "[entry=%p, wrapper=%p, mInput=%p, rv=%d]",
 547                       mDescriptor, this, mInput.get(), int(rv)));
 548
 549     if (NS_FAILED(rv)) return rv;
 550
 551     mInitialized = true;
 552     return NS_OK;
 553 }
 554
 555 nsresult nsCacheEntryDescriptor::
 556 nsInputStreamWrapper::Close()
 557 {
 558     nsresult rv = EnsureInit();
 559     if (NS_FAILED(rv)) return rv;
 560
 561     return mInput->Close();
 562 }
 563
 564 nsresult nsCacheEntryDescriptor::
 565 nsInputStreamWrapper::Available(PRUint64 *avail)
 566 {
 567     nsresult rv = EnsureInit();
 568     if (NS_FAILED(rv)) return rv;
 569
 570     return mInput->Available(avail);
 571 }
 572
 573 nsresult nsCacheEntryDescriptor::
 574 nsInputStreamWrapper::Read(char *buf, PRUint32 count, PRUint32 *countRead)
 575 {
 576     nsresult rv = EnsureInit();
 577     if (NS_SUCCEEDED(rv))
 578         rv = mInput->Read(buf, count, countRead);
 579
 580     CACHE_LOG_DEBUG(("nsInputStreamWrapper::Read "
 581                       "[entry=%p, wrapper=%p, mInput=%p, rv=%d]",
 582                       mDescriptor, this, mInput.get(), rv));
 583
 584     return rv;
 585 }
 586
 587 nsresult nsCacheEntryDescriptor::
 588 nsInputStreamWrapper::ReadSegments(nsWriteSegmentFun writer, void *closure,
 589                                    PRUint32 count, PRUint32 *countRead)
 590 {
 591     // cache stream not buffered
 592     return NS_ERROR_NOT_IMPLEMENTED;
 593 }
 594
 595 nsresult nsCacheEntryDescriptor::
 596 nsInputStreamWrapper::IsNonBlocking(bool *result)
 597 {
 598     // cache streams will never return NS_BASE_STREAM_WOULD_BLOCK
 599     *result = false;
 600     return NS_OK;
 601 }
 602
 603
 604 /******************************************************************************
 605  * nsDecompressInputStreamWrapper - an input stream wrapper that decompresses
 606  ******************************************************************************/
 607
 608 NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheEntryDescriptor::nsDecompressInputStreamWrapper,
 609                               nsIInputStream)
 610
 611 NS_IMETHODIMP nsCacheEntryDescriptor::
 612 nsDecompressInputStreamWrapper::Read(char *    buf,
 613                                      PRUint32  count,
 614                                      PRUint32 *countRead)
 615 {
 616     int zerr = Z_OK;
 617     nsresult rv = NS_OK;
 618
 619     if (!mStreamInitialized) {
 620         rv = InitZstream();
 621         if (NS_FAILED(rv)) {
 622             return rv;
 623         }
 624     }
 625
 626     mZstream.next_out = (Bytef*)buf;
 627     mZstream.avail_out = count;
 628
 629     if (mReadBufferLen < count) {
 630         // Allocate a buffer for reading from the input stream. This will
 631         // determine the max number of compressed bytes read from the
 632         // input stream at one time. Making the buffer size proportional
 633         // to the request size is not necessary, but helps minimize the
 634         // number of read requests to the input stream.
 635         PRUint32 newBufLen = NS_MAX(count, (PRUint32)kMinDecompressReadBufLen);
 636         unsigned char* newBuf;
 637         newBuf = (unsigned char*)nsMemory::Realloc(mReadBuffer,
 638             newBufLen);
 639         if (newBuf) {
 640             mReadBuffer = newBuf;
 641             mReadBufferLen = newBufLen;
 642         }
 643         if (!mReadBuffer) {
 644             mReadBufferLen = 0;
 645             return NS_ERROR_OUT_OF_MEMORY;
 646         }
 647     }
 648
 649     // read and inflate data until the output buffer is full, or
 650     // there is no more data to read
 651     while (NS_SUCCEEDED(rv) &&
 652            zerr == Z_OK &&
 653            mZstream.avail_out > 0 &&
 654            count > 0) {
 655         if (mZstream.avail_in == 0) {
 656             rv = nsInputStreamWrapper::Read((char*)mReadBuffer,
 657                                             mReadBufferLen,
 658                                             &mZstream.avail_in);
 659             if (NS_FAILED(rv) || !mZstream.avail_in) {
 660                 break;
 661             }
 662             mZstream.next_in = mReadBuffer;
 663         }
 664         zerr = inflate(&mZstream, Z_NO_FLUSH);
 665         if (zerr == Z_STREAM_END) {
 666             // The compressed data may have been stored in multiple
 667             // chunks/streams. To allow for this case, re-initialize
 668             // the inflate stream and continue decompressing from
 669             // the next byte.
 670             Bytef * saveNextIn = mZstream.next_in;
 671             unsigned int saveAvailIn = mZstream.avail_in;
 672             Bytef * saveNextOut = mZstream.next_out;
 673             unsigned int saveAvailOut = mZstream.avail_out;
 674             inflateReset(&mZstream);
 675             mZstream.next_in = saveNextIn;
 676             mZstream.avail_in = saveAvailIn;
 677             mZstream.next_out = saveNextOut;
 678             mZstream.avail_out = saveAvailOut;
 679             zerr = Z_OK;
 680         } else if (zerr != Z_OK) {
 681             rv = NS_ERROR_INVALID_CONTENT_ENCODING;
 682         }
 683     }
 684     if (NS_SUCCEEDED(rv)) {
 685         *countRead = count - mZstream.avail_out;
 686     }
 687     return rv;
 688 }
 689
 690 nsresult nsCacheEntryDescriptor::
 691 nsDecompressInputStreamWrapper::Close()
 692 {
 693     EndZstream();
 694     if (mReadBuffer) {
 695         nsMemory::Free(mReadBuffer);
 696         mReadBuffer = 0;
 697         mReadBufferLen = 0;
 698     }
 699     return nsInputStreamWrapper::Close();
 700 }
 701
 702 nsresult nsCacheEntryDescriptor::
 703 nsDecompressInputStreamWrapper::InitZstream()
 704 {
 705     // Initialize zlib inflate stream
 706     mZstream.zalloc = Z_NULL;
 707     mZstream.zfree = Z_NULL;
 708     mZstream.opaque = Z_NULL;
 709     mZstream.next_out = Z_NULL;
 710     mZstream.avail_out = 0;
 711     mZstream.next_in = Z_NULL;
 712     mZstream.avail_in = 0;
 713     if (inflateInit(&mZstream) != Z_OK) {
 714         return NS_ERROR_FAILURE;
 715     }
 716     mStreamInitialized = true;
 717     return NS_OK;
 718 }
 719
 720 nsresult nsCacheEntryDescriptor::
 721 nsDecompressInputStreamWrapper::EndZstream()
 722 {
 723     if (mStreamInitialized && !mStreamEnded) {
 724         inflateEnd(&mZstream);
 725         mStreamEnded = true;
 726     }
 727     return NS_OK;
 728 }
 729
 730
 731 /******************************************************************************
 732  * nsOutputStreamWrapper - a wrapper for nsIOutputstream to track the amount of
 733  *                         data written to a cache entry.
 734  *                       - also keeps the cache entry open while referenced.
 735  ******************************************************************************/
 736
 737 NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheEntryDescriptor::nsOutputStreamWrapper,
 738                               nsIOutputStream)
 739
 740 nsresult nsCacheEntryDescriptor::
 741 nsOutputStreamWrapper::LazyInit()
 742 {
 743     nsCacheServiceAutoLock lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_LAZYINIT));
 744
 745     nsCacheAccessMode mode;
 746     nsresult rv = mDescriptor->GetAccessGranted(&mode);
 747     if (NS_FAILED(rv)) return rv;
 748
 749     NS_ENSURE_TRUE(mode & nsICache::ACCESS_WRITE, NS_ERROR_UNEXPECTED);
 750
 751     nsCacheEntry* cacheEntry = mDescriptor->CacheEntry();
 752     if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE;
 753
 754     NS_ASSERTION(mOutput == nullptr, "mOutput set in LazyInit");
 755
 756     nsCOMPtr<nsIOutputStream> stream;
 757     rv = nsCacheService::OpenOutputStreamForEntry(cacheEntry, mode, mStartOffset,
 758                                                   getter_AddRefs(stream));
 759     if (NS_FAILED(rv))
 760         return rv;
 761
 762     nsCacheDevice* device = cacheEntry->CacheDevice();
 763     if (device) {
 764         // the entry has been truncated to mStartOffset bytes, inform device
 765         PRInt32 size = cacheEntry->DataSize();
 766         rv = device->OnDataSizeChange(cacheEntry, mStartOffset - size);
 767         if (NS_SUCCEEDED(rv))
 768             cacheEntry->SetDataSize(mStartOffset);
 769     } else {
 770         rv = NS_ERROR_NOT_AVAILABLE;
 771     }
 772
 773     // If anything above failed, clean up internal state and get out of here
 774     // (see bug #654926)...
 775     if (NS_FAILED(rv)) {
 776         mDescriptor->InternalCleanup(stream);
 777         return rv;
 778     }
 779
 780     // ... otherwise, set members and mark initialized
 781     mDescriptor->mOutput = mOutput = stream;
 782     mInitialized = true;
 783     return NS_OK;
 784 }
 785
 786 nsresult nsCacheEntryDescriptor::
 787 nsOutputStreamWrapper::OnWrite(PRUint32 count)
 788 {
 789     if (count > PR_INT32_MAX)  return NS_ERROR_UNEXPECTED;
 790     return mDescriptor->RequestDataSizeChange((PRInt32)count);
 791 }
 792
 793 NS_IMETHODIMP nsCacheEntryDescriptor::
 794 nsOutputStreamWrapper::Close()
 795 {
 796     nsresult rv = EnsureInit();
 797     if (NS_FAILED(rv)) return rv;
 798
 799     return mOutput->Close();
 800 }
 801
 802 NS_IMETHODIMP nsCacheEntryDescriptor::
 803 nsOutputStreamWrapper::Flush()
 804 {
 805     nsresult rv = EnsureInit();
 806     if (NS_FAILED(rv)) return rv;
 807
 808     return mOutput->Flush();
 809 }
 810
 811 NS_IMETHODIMP nsCacheEntryDescriptor::
 812 nsOutputStreamWrapper::Write(const char * buf,
 813                              PRUint32     count,
 814                              PRUint32 *   result)
 815 {
 816     nsresult rv = EnsureInit();
 817     if (NS_FAILED(rv)) return rv;
 818
 819     rv = OnWrite(count);
 820     if (NS_FAILED(rv)) return rv;
 821
 822     return mOutput->Write(buf, count, result);
 823 }
 824
 825 NS_IMETHODIMP nsCacheEntryDescriptor::
 826 nsOutputStreamWrapper::WriteFrom(nsIInputStream * inStr,
 827                                  PRUint32         count,
 828                                  PRUint32 *       result)
 829 {
 830     return NS_ERROR_NOT_IMPLEMENTED;
 831 }
 832
 833 NS_IMETHODIMP nsCacheEntryDescriptor::
 834 nsOutputStreamWrapper::WriteSegments(nsReadSegmentFun  reader,
 835                                      void *            closure,
 836                                      PRUint32          count,
 837                                      PRUint32 *        result)
 838 {
 839     return NS_ERROR_NOT_IMPLEMENTED;
 840 }
 841
 842 NS_IMETHODIMP nsCacheEntryDescriptor::
 843 nsOutputStreamWrapper::IsNonBlocking(bool *result)
 844 {
 845     // cache streams will never return NS_BASE_STREAM_WOULD_BLOCK
 846     *result = false;
 847     return NS_OK;
 848 }
 849
 850
 851 /******************************************************************************
 852  * nsCompressOutputStreamWrapper - an output stream wrapper that compresses
 853  *   data before it is written
 854  ******************************************************************************/
 855
 856 NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheEntryDescriptor::nsCompressOutputStreamWrapper,
 857                               nsIOutputStream)
 858
 859 NS_IMETHODIMP nsCacheEntryDescriptor::
 860 nsCompressOutputStreamWrapper::Write(const char * buf,
 861                                      PRUint32     count,
 862                                      PRUint32 *   result)
 863 {
 864     int zerr = Z_OK;
 865     nsresult rv = NS_OK;
 866
 867     if (!mStreamInitialized) {
 868         rv = InitZstream();
 869         if (NS_FAILED(rv)) {
 870             return rv;
 871         }
 872     }
 873
 874     if (!mWriteBuffer) {
 875         // Once allocated, this buffer is referenced by the zlib stream and
 876         // cannot be grown. We use 2x(initial write request) to approximate
 877         // a stream buffer size proportional to request buffers.
 878         mWriteBufferLen = NS_MAX(count*2, (PRUint32)kMinCompressWriteBufLen);
 879         mWriteBuffer = (unsigned char*)nsMemory::Alloc(mWriteBufferLen);
 880         if (!mWriteBuffer) {
 881             mWriteBufferLen = 0;
 882             return NS_ERROR_OUT_OF_MEMORY;
 883         }
 884         mZstream.next_out = mWriteBuffer;
 885         mZstream.avail_out = mWriteBufferLen;
 886     }
 887
 888     // Compress (deflate) the requested buffer. Keep going
 889     // until the entire buffer has been deflated.
 890     mZstream.avail_in = count;
 891     mZstream.next_in = (Bytef*)buf;
 892     while (mZstream.avail_in > 0) {
 893         zerr = deflate(&mZstream, Z_NO_FLUSH);
 894         if (zerr == Z_STREAM_ERROR) {
 895             deflateEnd(&mZstream);
 896             mStreamInitialized = false;
 897             return NS_ERROR_FAILURE;
 898         }
 899         // Note: Z_BUF_ERROR is non-fatal and sometimes expected here.
 900
 901         // If the compression stream output buffer is filled, write
 902         // it out to the underlying stream wrapper.
 903         if (mZstream.avail_out == 0) {
 904             rv = WriteBuffer();
 905             if (NS_FAILED(rv)) {
 906                 deflateEnd(&mZstream);
 907                 mStreamInitialized = false;
 908                 return rv;
 909             }
 910         }
 911     }
 912     *result = count;
 913     mUncompressedCount += *result;
 914     return NS_OK;
 915 }
 916
 917 NS_IMETHODIMP nsCacheEntryDescriptor::
 918 nsCompressOutputStreamWrapper::Close()
 919 {
 920     nsresult rv = NS_OK;
 921     int zerr = 0;
 922
 923     if (mStreamInitialized) {
 924         // complete compression of any data remaining in the zlib stream
 925         do {
 926             zerr = deflate(&mZstream, Z_FINISH);
 927             rv = WriteBuffer();
 928         } while (zerr == Z_OK && rv == NS_OK);
 929         deflateEnd(&mZstream);
 930     }
 931
 932     if (mDescriptor->CacheEntry()) {
 933         nsCAutoString uncompressedLenStr;
 934         rv = mDescriptor->GetMetaDataElement("uncompressed-len",
 935                                              getter_Copies(uncompressedLenStr));
 936         if (NS_SUCCEEDED(rv)) {
 937             PRInt32 oldCount = uncompressedLenStr.ToInteger(&rv);
 938             if (NS_SUCCEEDED(rv)) {
 939                 mUncompressedCount += oldCount;
 940             }
 941         }
 942         uncompressedLenStr.Adopt(0);
 943         uncompressedLenStr.AppendInt(mUncompressedCount);
 944         rv = mDescriptor->SetMetaDataElement("uncompressed-len",
 945             uncompressedLenStr.get());
 946     }
 947
 948     if (mWriteBuffer) {
 949         nsMemory::Free(mWriteBuffer);
 950         mWriteBuffer = 0;
 951         mWriteBufferLen = 0;
 952     }
 953
 954     return nsOutputStreamWrapper::Close();
 955 }
 956
 957 nsresult nsCacheEntryDescriptor::
 958 nsCompressOutputStreamWrapper::InitZstream()
 959 {
 960     // Determine compression level: Aggressive compression
 961     // may impact performance on mobile devices, while a
 962     // lower compression level still provides substantial
 963     // space savings for many text streams.
 964     PRInt32 compressionLevel = nsCacheService::CacheCompressionLevel();
 965
 966     // Initialize zlib deflate stream
 967     mZstream.zalloc = Z_NULL;
 968     mZstream.zfree = Z_NULL;
 969     mZstream.opaque = Z_NULL;
 970     if (deflateInit2(&mZstream, compressionLevel, Z_DEFLATED,
 971                      MAX_WBITS, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
 972         return NS_ERROR_FAILURE;
 973     }
 974     mZstream.next_in = Z_NULL;
 975     mZstream.avail_in = 0;
 976
 977     mStreamInitialized = true;
 978
 979     return NS_OK;
 980 }
 981
 982 nsresult nsCacheEntryDescriptor::
 983 nsCompressOutputStreamWrapper::WriteBuffer()
 984 {
 985     PRUint32 bytesToWrite = mWriteBufferLen - mZstream.avail_out;
 986     PRUint32 result = 0;
 987     nsresult rv = nsCacheEntryDescriptor::nsOutputStreamWrapper::Write(
 988         (const char *)mWriteBuffer, bytesToWrite, &result);
 989     mZstream.next_out = mWriteBuffer;
 990     mZstream.avail_out = mWriteBufferLen;
 991     return rv;
 992 }
 993