modules/libjar/nsJARURI.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is mozilla.org Code.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications Corporation.
  20  * Portions created by the Initial Developer are Copyright (C) 1998
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsJARURI.h"
  40 #include "nsNetUtil.h"
  41 #include "nsIIOService.h"
  42 #include "nsIStandardURL.h"
  43 #include "nsCRT.h"
  44 #include "nsIComponentManager.h"
  45 #include "nsIServiceManager.h"
  46 #include "nsIZipReader.h"
  47 #include "nsReadableUtils.h"
  48 #include "nsAutoPtr.h"
  49 #include "nsNetCID.h"
  50 #include "nsIObjectInputStream.h"
  51 #include "nsIObjectOutputStream.h"
  52 #include "nsIProgrammingLanguage.h"
  53
  54 static NS_DEFINE_CID(kJARURICID, NS_JARURI_CID);
  55
  56 ////////////////////////////////////////////////////////////////////////////////
  57
  58 nsJARURI::nsJARURI()
  59 {
  60 }
  61
  62 nsJARURI::~nsJARURI()
  63 {
  64 }
  65
  66 // XXX Why is this threadsafe?
  67 NS_IMPL_THREADSAFE_ADDREF(nsJARURI)
  68 NS_IMPL_THREADSAFE_RELEASE(nsJARURI)
  69 NS_INTERFACE_MAP_BEGIN(nsJARURI)
  70   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIJARURI)
  71   NS_INTERFACE_MAP_ENTRY(nsIURI)
  72   NS_INTERFACE_MAP_ENTRY(nsIURL)
  73   NS_INTERFACE_MAP_ENTRY(nsIJARURI)
  74   NS_INTERFACE_MAP_ENTRY(nsISerializable)
  75   NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
  76   NS_INTERFACE_MAP_ENTRY(nsINestedURI)
  77   // see nsJARURI::Equals
  78   if (aIID.Equals(NS_GET_IID(nsJARURI)))
  79       foundInterface = reinterpret_cast<nsISupports*>(this);
  80   else
  81 NS_INTERFACE_MAP_END
  82
  83 nsresult
  84 nsJARURI::Init(const char *charsetHint)
  85 {
  86     mCharsetHint = charsetHint;
  87     return NS_OK;
  88 }
  89
  90 #define NS_JAR_SCHEME           NS_LITERAL_CSTRING("jar:")
  91 #define NS_JAR_DELIMITER        NS_LITERAL_CSTRING("!/")
  92 #define NS_BOGUS_ENTRY_SCHEME   NS_LITERAL_CSTRING("x:///")
  93
  94 // FormatSpec takes the entry spec (including the "x:///" at the
  95 // beginning) and gives us a full JAR spec.
  96 nsresult
  97 nsJARURI::FormatSpec(const nsACString &entrySpec, nsACString &result,
  98                      PRBool aIncludeScheme)
  99 {
 100     // The entrySpec MUST start with "x:///"
 101     NS_ASSERTION(StringBeginsWith(entrySpec, NS_BOGUS_ENTRY_SCHEME),
 102                  "bogus entry spec");
 103
 104     nsCAutoString fileSpec;
 105     nsresult rv = mJARFile->GetSpec(fileSpec);
 106     if (NS_FAILED(rv)) return rv;
 107
 108     if (aIncludeScheme)
 109         result = NS_JAR_SCHEME;
 110     else
 111         result.Truncate();
 112
 113     result.Append(fileSpec + NS_JAR_DELIMITER +
 114                   Substring(entrySpec, 5, entrySpec.Length() - 5));
 115     return NS_OK;
 116 }
 117
 118 nsresult
 119 nsJARURI::CreateEntryURL(const nsACString& entryFilename,
 120                          const char* charset,
 121                          nsIURL** url)
 122 {
 123     *url = nsnull;
 124
 125     nsCOMPtr<nsIStandardURL> stdURL(do_CreateInstance(NS_STANDARDURL_CONTRACTID));
 126     if (!stdURL) {
 127         return NS_ERROR_OUT_OF_MEMORY;
 128     }
 129
 130     // Flatten the concatenation, just in case.  See bug 128288
 131     nsCAutoString spec(NS_BOGUS_ENTRY_SCHEME + entryFilename);
 132     nsresult rv = stdURL->Init(nsIStandardURL::URLTYPE_NO_AUTHORITY, -1,
 133                                spec, charset, nsnull);
 134     if (NS_FAILED(rv)) {
 135         return rv;
 136     }
 137
 138     return CallQueryInterface(stdURL, url);
 139 }
 140
 141 ////////////////////////////////////////////////////////////////////////////////
 142 // nsISerializable methods:
 143
 144 NS_IMETHODIMP
 145 nsJARURI::Read(nsIObjectInputStream* aInputStream)
 146 {
 147     nsresult rv;
 148
 149     rv = aInputStream->ReadObject(PR_TRUE, getter_AddRefs(mJARFile));
 150     NS_ENSURE_SUCCESS(rv, rv);
 151
 152     rv = aInputStream->ReadObject(PR_TRUE, getter_AddRefs(mJAREntry));
 153     NS_ENSURE_SUCCESS(rv, rv);
 154
 155     rv = aInputStream->ReadCString(mCharsetHint);
 156     return rv;
 157 }
 158
 159 NS_IMETHODIMP
 160 nsJARURI::Write(nsIObjectOutputStream* aOutputStream)
 161 {
 162     nsresult rv;
 163
 164     rv = aOutputStream->WriteCompoundObject(mJARFile, NS_GET_IID(nsIURI),
 165                                             PR_TRUE);
 166     NS_ENSURE_SUCCESS(rv, rv);
 167
 168     rv = aOutputStream->WriteCompoundObject(mJAREntry, NS_GET_IID(nsIURL),
 169                                             PR_TRUE);
 170     NS_ENSURE_SUCCESS(rv, rv);
 171
 172     rv = aOutputStream->WriteStringZ(mCharsetHint.get());
 173     return rv;
 174 }
 175
 176 ////////////////////////////////////////////////////////////////////////////////
 177 // nsIClassInfo methods:
 178
 179 NS_IMETHODIMP
 180 nsJARURI::GetInterfaces(PRUint32 *count, nsIID * **array)
 181 {
 182     *count = 0;
 183     *array = nsnull;
 184     return NS_OK;
 185 }
 186
 187 NS_IMETHODIMP
 188 nsJARURI::GetHelperForLanguage(PRUint32 language, nsISupports **_retval)
 189 {
 190     *_retval = nsnull;
 191     return NS_OK;
 192 }
 193
 194 NS_IMETHODIMP
 195 nsJARURI::GetContractID(char * *aContractID)
 196 {
 197     *aContractID = nsnull;
 198     return NS_OK;
 199 }
 200
 201 NS_IMETHODIMP
 202 nsJARURI::GetClassDescription(char * *aClassDescription)
 203 {
 204     *aClassDescription = nsnull;
 205     return NS_OK;
 206 }
 207
 208 NS_IMETHODIMP
 209 nsJARURI::GetClassID(nsCID * *aClassID)
 210 {
 211     *aClassID = (nsCID*) nsMemory::Alloc(sizeof(nsCID));
 212     if (!*aClassID)
 213         return NS_ERROR_OUT_OF_MEMORY;
 214     return GetClassIDNoAlloc(*aClassID);
 215 }
 216
 217 NS_IMETHODIMP
 218 nsJARURI::GetImplementationLanguage(PRUint32 *aImplementationLanguage)
 219 {
 220     *aImplementationLanguage = nsIProgrammingLanguage::CPLUSPLUS;
 221     return NS_OK;
 222 }
 223
 224 NS_IMETHODIMP
 225 nsJARURI::GetFlags(PRUint32 *aFlags)
 226 {
 227     // XXX We implement THREADSAFE addref/release, but probably shouldn't.
 228     *aFlags = nsIClassInfo::MAIN_THREAD_ONLY;
 229     return NS_OK;
 230 }
 231
 232 NS_IMETHODIMP
 233 nsJARURI::GetClassIDNoAlloc(nsCID *aClassIDNoAlloc)
 234 {
 235     *aClassIDNoAlloc = kJARURICID;
 236     return NS_OK;
 237 }
 238
 239 ////////////////////////////////////////////////////////////////////////////////
 240 // nsIURI methods:
 241
 242 NS_IMETHODIMP
 243 nsJARURI::GetSpec(nsACString &aSpec)
 244 {
 245     nsCAutoString entrySpec;
 246     mJAREntry->GetSpec(entrySpec);
 247     return FormatSpec(entrySpec, aSpec);
 248 }
 249
 250 NS_IMETHODIMP
 251 nsJARURI::SetSpec(const nsACString& aSpec)
 252 {
 253     return SetSpecWithBase(aSpec, nsnull);
 254 }
 255
 256 nsresult
 257 nsJARURI::SetSpecWithBase(const nsACString &aSpec, nsIURI* aBaseURL)
 258 {
 259     nsresult rv;
 260
 261     nsCOMPtr<nsIIOService> ioServ(do_GetIOService(&rv));
 262     NS_ENSURE_SUCCESS(rv, rv);
 263
 264     nsCAutoString scheme;
 265     rv = ioServ->ExtractScheme(aSpec, scheme);
 266     if (NS_FAILED(rv)) {
 267         // not an absolute URI
 268         if (!aBaseURL)
 269             return NS_ERROR_MALFORMED_URI;
 270
 271         nsRefPtr<nsJARURI> otherJAR;
 272         aBaseURL->QueryInterface(NS_GET_IID(nsJARURI), getter_AddRefs(otherJAR));
 273         NS_ENSURE_TRUE(otherJAR, NS_NOINTERFACE);
 274
 275         mJARFile = otherJAR->mJARFile;
 276
 277         nsCOMPtr<nsIStandardURL> entry(do_CreateInstance(NS_STANDARDURL_CONTRACTID));
 278         if (!entry)
 279             return NS_ERROR_OUT_OF_MEMORY;
 280
 281         rv = entry->Init(nsIStandardURL::URLTYPE_NO_AUTHORITY, -1,
 282                          aSpec, mCharsetHint.get(), otherJAR->mJAREntry);
 283         if (NS_FAILED(rv))
 284             return rv;
 285
 286         mJAREntry = do_QueryInterface(entry);
 287         if (!mJAREntry)
 288             return NS_NOINTERFACE;
 289
 290         return NS_OK;
 291     }
 292
 293     NS_ENSURE_TRUE(scheme.EqualsLiteral("jar"), NS_ERROR_MALFORMED_URI);
 294
 295     nsACString::const_iterator begin, end;
 296     aSpec.BeginReading(begin);
 297     aSpec.EndReading(end);
 298
 299     while (begin != end && *begin != ':')
 300         ++begin;
 301
 302     ++begin; // now we're past the "jar:"
 303
 304     // Search backward from the end for the "!/" delimiter. Remember, jar URLs
 305     // can nest, e.g.:
 306     //    jar:jar:http://www.foo.com/bar.jar!/a.jar!/b.html
 307     // This gets the b.html document from out of the a.jar file, that's
 308     // contained within the bar.jar file.
 309     // Also, the outermost "inner" URI may be a relative URI:
 310     //   jar:../relative.jar!/a.html
 311
 312     nsACString::const_iterator delim_begin (begin),
 313                                delim_end   (end);
 314
 315     if (!RFindInReadable(NS_JAR_DELIMITER, delim_begin, delim_end))
 316         return NS_ERROR_MALFORMED_URI;
 317
 318     rv = ioServ->NewURI(Substring(begin, delim_begin), mCharsetHint.get(),
 319                         aBaseURL, getter_AddRefs(mJARFile));
 320     if (NS_FAILED(rv)) return rv;
 321
 322     NS_TryToSetImmutable(mJARFile);
 323
 324     // skip over any extra '/' chars
 325     while (*delim_end == '/')
 326         ++delim_end;
 327
 328     return SetJAREntry(Substring(delim_end, end));
 329 }
 330
 331 NS_IMETHODIMP
 332 nsJARURI::GetPrePath(nsACString &prePath)
 333 {
 334     prePath = NS_JAR_SCHEME;
 335     return NS_OK;
 336 }
 337
 338 NS_IMETHODIMP
 339 nsJARURI::GetScheme(nsACString &aScheme)
 340 {
 341     aScheme = "jar";
 342     return NS_OK;
 343 }
 344
 345 NS_IMETHODIMP
 346 nsJARURI::SetScheme(const nsACString &aScheme)
 347 {
 348     // doesn't make sense to set the scheme of a jar: URL
 349     return NS_ERROR_FAILURE;
 350 }
 351
 352 NS_IMETHODIMP
 353 nsJARURI::GetUserPass(nsACString &aUserPass)
 354 {
 355     return NS_ERROR_FAILURE;
 356 }
 357
 358 NS_IMETHODIMP
 359 nsJARURI::SetUserPass(const nsACString &aUserPass)
 360 {
 361     return NS_ERROR_FAILURE;
 362 }
 363
 364 NS_IMETHODIMP
 365 nsJARURI::GetUsername(nsACString &aUsername)
 366 {
 367     return NS_ERROR_FAILURE;
 368 }
 369
 370 NS_IMETHODIMP
 371 nsJARURI::SetUsername(const nsACString &aUsername)
 372 {
 373     return NS_ERROR_FAILURE;
 374 }
 375
 376 NS_IMETHODIMP
 377 nsJARURI::GetPassword(nsACString &aPassword)
 378 {
 379     return NS_ERROR_FAILURE;
 380 }
 381
 382 NS_IMETHODIMP
 383 nsJARURI::SetPassword(const nsACString &aPassword)
 384 {
 385     return NS_ERROR_FAILURE;
 386 }
 387
 388 NS_IMETHODIMP
 389 nsJARURI::GetHostPort(nsACString &aHostPort)
 390 {
 391     return NS_ERROR_FAILURE;
 392 }
 393
 394 NS_IMETHODIMP
 395 nsJARURI::SetHostPort(const nsACString &aHostPort)
 396 {
 397     return NS_ERROR_FAILURE;
 398 }
 399
 400 NS_IMETHODIMP
 401 nsJARURI::GetHost(nsACString &aHost)
 402 {
 403     return NS_ERROR_FAILURE;
 404 }
 405
 406 NS_IMETHODIMP
 407 nsJARURI::SetHost(const nsACString &aHost)
 408 {
 409     return NS_ERROR_FAILURE;
 410 }
 411
 412 NS_IMETHODIMP
 413 nsJARURI::GetPort(PRInt32 *aPort)
 414 {
 415     return NS_ERROR_FAILURE;
 416 }
 417
 418 NS_IMETHODIMP
 419 nsJARURI::SetPort(PRInt32 aPort)
 420 {
 421     return NS_ERROR_FAILURE;
 422 }
 423
 424 NS_IMETHODIMP
 425 nsJARURI::GetPath(nsACString &aPath)
 426 {
 427     nsCAutoString entrySpec;
 428     mJAREntry->GetSpec(entrySpec);
 429     return FormatSpec(entrySpec, aPath, PR_FALSE);
 430 }
 431
 432 NS_IMETHODIMP
 433 nsJARURI::SetPath(const nsACString &aPath)
 434 {
 435     return NS_ERROR_FAILURE;
 436 }
 437
 438 NS_IMETHODIMP
 439 nsJARURI::GetAsciiSpec(nsACString &aSpec)
 440 {
 441     // XXX Shouldn't this like... make sure it returns ASCII or something?
 442     return GetSpec(aSpec);
 443 }
 444
 445 NS_IMETHODIMP
 446 nsJARURI::GetAsciiHost(nsACString &aHost)
 447 {
 448     return NS_ERROR_FAILURE;
 449 }
 450
 451 NS_IMETHODIMP
 452 nsJARURI::GetOriginCharset(nsACString &aOriginCharset)
 453 {
 454     aOriginCharset = mCharsetHint;
 455     return NS_OK;
 456 }
 457
 458 NS_IMETHODIMP
 459 nsJARURI::Equals(nsIURI *other, PRBool *result)
 460 {
 461     nsresult rv;
 462
 463     *result = PR_FALSE;
 464
 465     if (other == nsnull)
 466         return NS_OK;   // not equal
 467
 468     nsRefPtr<nsJARURI> otherJAR;
 469     other->QueryInterface(NS_GET_IID(nsJARURI), getter_AddRefs(otherJAR));
 470     if (!otherJAR)
 471         return NS_OK;   // not equal
 472
 473     PRBool equal;
 474     rv = mJARFile->Equals(otherJAR->mJARFile, &equal);
 475     if (NS_FAILED(rv) || !equal) {
 476         return rv;   // not equal
 477     }
 478
 479     rv = mJAREntry->Equals(otherJAR->mJAREntry, result);
 480     return rv;
 481 }
 482
 483 NS_IMETHODIMP
 484 nsJARURI::SchemeIs(const char *i_Scheme, PRBool *o_Equals)
 485 {
 486     NS_ENSURE_ARG_POINTER(o_Equals);
 487     if (!i_Scheme) return NS_ERROR_INVALID_ARG;
 488
 489     if (*i_Scheme == 'j' || *i_Scheme == 'J') {
 490         *o_Equals = PL_strcasecmp("jar", i_Scheme) ? PR_FALSE : PR_TRUE;
 491     } else {
 492         *o_Equals = PR_FALSE;
 493     }
 494     return NS_OK;
 495 }
 496
 497 NS_IMETHODIMP
 498 nsJARURI::Clone(nsIURI **result)
 499 {
 500     nsresult rv;
 501
 502     nsCOMPtr<nsIJARURI> uri;
 503     rv = CloneWithJARFile(mJARFile, getter_AddRefs(uri));
 504     if (NS_FAILED(rv)) return rv;
 505
 506     return CallQueryInterface(uri, result);
 507 }
 508
 509 NS_IMETHODIMP
 510 nsJARURI::Resolve(const nsACString &relativePath, nsACString &result)
 511 {
 512     nsresult rv;
 513
 514     nsCOMPtr<nsIIOService> ioServ(do_GetIOService(&rv));
 515     if (NS_FAILED(rv))
 516       return rv;
 517
 518     nsCAutoString scheme;
 519     rv = ioServ->ExtractScheme(relativePath, scheme);
 520     if (NS_SUCCEEDED(rv)) {
 521         // then aSpec is absolute
 522         result = relativePath;
 523         return NS_OK;
 524     }
 525
 526     nsCAutoString resolvedPath;
 527     mJAREntry->Resolve(relativePath, resolvedPath);
 528
 529     return FormatSpec(resolvedPath, result);
 530 }
 531
 532 ////////////////////////////////////////////////////////////////////////////////
 533 // nsIURL methods:
 534
 535 NS_IMETHODIMP
 536 nsJARURI::GetFilePath(nsACString& filePath)
 537 {
 538     return mJAREntry->GetFilePath(filePath);
 539 }
 540
 541 NS_IMETHODIMP
 542 nsJARURI::SetFilePath(const nsACString& filePath)
 543 {
 544     return mJAREntry->SetFilePath(filePath);
 545 }
 546
 547 NS_IMETHODIMP
 548 nsJARURI::GetParam(nsACString& param)
 549 {
 550     param.Truncate();
 551     return NS_OK;
 552 }
 553
 554 NS_IMETHODIMP
 555 nsJARURI::SetParam(const nsACString& param)
 556 {
 557     return NS_ERROR_NOT_AVAILABLE;
 558 }
 559
 560 NS_IMETHODIMP
 561 nsJARURI::GetQuery(nsACString& query)
 562 {
 563     return mJAREntry->GetQuery(query);
 564 }
 565
 566 NS_IMETHODIMP
 567 nsJARURI::SetQuery(const nsACString& query)
 568 {
 569     return mJAREntry->SetQuery(query);
 570 }
 571
 572 NS_IMETHODIMP
 573 nsJARURI::GetRef(nsACString& ref)
 574 {
 575     return mJAREntry->GetRef(ref);
 576 }
 577
 578 NS_IMETHODIMP
 579 nsJARURI::SetRef(const nsACString& ref)
 580 {
 581     return mJAREntry->SetRef(ref);
 582 }
 583
 584 NS_IMETHODIMP
 585 nsJARURI::GetDirectory(nsACString& directory)
 586 {
 587     return mJAREntry->GetDirectory(directory);
 588 }
 589
 590 NS_IMETHODIMP
 591 nsJARURI::SetDirectory(const nsACString& directory)
 592 {
 593     return mJAREntry->SetDirectory(directory);
 594 }
 595
 596 NS_IMETHODIMP
 597 nsJARURI::GetFileName(nsACString& fileName)
 598 {
 599     return mJAREntry->GetFileName(fileName);
 600 }
 601
 602 NS_IMETHODIMP
 603 nsJARURI::SetFileName(const nsACString& fileName)
 604 {
 605     return mJAREntry->SetFileName(fileName);
 606 }
 607
 608 NS_IMETHODIMP
 609 nsJARURI::GetFileBaseName(nsACString& fileBaseName)
 610 {
 611     return mJAREntry->GetFileBaseName(fileBaseName);
 612 }
 613
 614 NS_IMETHODIMP
 615 nsJARURI::SetFileBaseName(const nsACString& fileBaseName)
 616 {
 617     return mJAREntry->SetFileBaseName(fileBaseName);
 618 }
 619
 620 NS_IMETHODIMP
 621 nsJARURI::GetFileExtension(nsACString& fileExtension)
 622 {
 623     return mJAREntry->GetFileExtension(fileExtension);
 624 }
 625
 626 NS_IMETHODIMP
 627 nsJARURI::SetFileExtension(const nsACString& fileExtension)
 628 {
 629     return mJAREntry->SetFileExtension(fileExtension);
 630 }
 631
 632 NS_IMETHODIMP
 633 nsJARURI::GetCommonBaseSpec(nsIURI* uriToCompare, nsACString& commonSpec)
 634 {
 635     commonSpec.Truncate();
 636
 637     NS_ENSURE_ARG_POINTER(uriToCompare);
 638
 639     commonSpec.Truncate();
 640     nsCOMPtr<nsIJARURI> otherJARURI(do_QueryInterface(uriToCompare));
 641     if (!otherJARURI) {
 642         // Nothing in common
 643         return NS_OK;
 644     }
 645
 646     nsCOMPtr<nsIURI> otherJARFile;
 647     nsresult rv = otherJARURI->GetJARFile(getter_AddRefs(otherJARFile));
 648     if (NS_FAILED(rv)) return rv;
 649
 650     PRBool equal;
 651     rv = mJARFile->Equals(otherJARFile, &equal);
 652     if (NS_FAILED(rv)) return rv;
 653
 654     if (!equal) {
 655         // See what the JAR file URIs have in common
 656         nsCOMPtr<nsIURL> ourJARFileURL(do_QueryInterface(mJARFile));
 657         if (!ourJARFileURL) {
 658             // Not a URL, so nothing in common
 659             return NS_OK;
 660         }
 661         nsCAutoString common;
 662         rv = ourJARFileURL->GetCommonBaseSpec(otherJARFile, common);
 663         if (NS_FAILED(rv)) return rv;
 664
 665         commonSpec = NS_JAR_SCHEME + common;
 666         return NS_OK;
 667
 668     }
 669
 670     // At this point we have the same JAR file.  Compare the JAREntrys
 671     nsCAutoString otherEntry;
 672     rv = otherJARURI->GetJAREntry(otherEntry);
 673     if (NS_FAILED(rv)) return rv;
 674
 675     nsCAutoString otherCharset;
 676     rv = uriToCompare->GetOriginCharset(otherCharset);
 677     if (NS_FAILED(rv)) return rv;
 678
 679     nsCOMPtr<nsIURL> url;
 680     rv = CreateEntryURL(otherEntry, otherCharset.get(), getter_AddRefs(url));
 681     if (NS_FAILED(rv)) return rv;
 682
 683     nsCAutoString common;
 684     rv = mJAREntry->GetCommonBaseSpec(url, common);
 685     if (NS_FAILED(rv)) return rv;
 686
 687     rv = FormatSpec(common, commonSpec);
 688     return rv;
 689 }
 690
 691 NS_IMETHODIMP
 692 nsJARURI::GetRelativeSpec(nsIURI* uriToCompare, nsACString& relativeSpec)
 693 {
 694     GetSpec(relativeSpec);
 695
 696     NS_ENSURE_ARG_POINTER(uriToCompare);
 697
 698     nsCOMPtr<nsIJARURI> otherJARURI(do_QueryInterface(uriToCompare));
 699     if (!otherJARURI) {
 700         // Nothing in common
 701         return NS_OK;
 702     }
 703
 704     nsCOMPtr<nsIURI> otherJARFile;
 705     nsresult rv = otherJARURI->GetJARFile(getter_AddRefs(otherJARFile));
 706     if (NS_FAILED(rv)) return rv;
 707
 708     PRBool equal;
 709     rv = mJARFile->Equals(otherJARFile, &equal);
 710     if (NS_FAILED(rv)) return rv;
 711
 712     if (!equal) {
 713         // We live in different JAR files.  Nothing in common.
 714         return rv;
 715     }
 716
 717     // Same JAR file.  Compare the JAREntrys
 718     nsCAutoString otherEntry;
 719     rv = otherJARURI->GetJAREntry(otherEntry);
 720     if (NS_FAILED(rv)) return rv;
 721
 722     nsCAutoString otherCharset;
 723     rv = uriToCompare->GetOriginCharset(otherCharset);
 724     if (NS_FAILED(rv)) return rv;
 725
 726     nsCOMPtr<nsIURL> url;
 727     rv = CreateEntryURL(otherEntry, otherCharset.get(), getter_AddRefs(url));
 728     if (NS_FAILED(rv)) return rv;
 729
 730     nsCAutoString relativeEntrySpec;
 731     rv = mJAREntry->GetRelativeSpec(url, relativeEntrySpec);
 732     if (NS_FAILED(rv)) return rv;
 733
 734     if (!StringBeginsWith(relativeEntrySpec, NS_BOGUS_ENTRY_SCHEME)) {
 735         // An actual relative spec!
 736         relativeSpec = relativeEntrySpec;
 737     }
 738     return rv;
 739 }
 740
 741 ////////////////////////////////////////////////////////////////////////////////
 742 // nsIJARURI methods:
 743
 744 NS_IMETHODIMP
 745 nsJARURI::GetJARFile(nsIURI* *jarFile)
 746 {
 747     return GetInnerURI(jarFile);
 748 }
 749
 750 NS_IMETHODIMP
 751 nsJARURI::GetJAREntry(nsACString &entryPath)
 752 {
 753     nsCAutoString filePath;
 754     mJAREntry->GetFilePath(filePath);
 755     NS_ASSERTION(filePath.Length() > 0, "path should never be empty!");
 756     // Trim off the leading '/'
 757     entryPath = Substring(filePath, 1, filePath.Length() - 1);
 758     return NS_OK;
 759 }
 760
 761 NS_IMETHODIMP
 762 nsJARURI::SetJAREntry(const nsACString &entryPath)
 763 {
 764     return CreateEntryURL(entryPath, mCharsetHint.get(),
 765                           getter_AddRefs(mJAREntry));
 766 }
 767
 768 NS_IMETHODIMP
 769 nsJARURI::CloneWithJARFile(nsIURI *jarFile, nsIJARURI **result)
 770 {
 771     if (!jarFile) {
 772         return NS_ERROR_INVALID_ARG;
 773     }
 774
 775     nsresult rv;
 776
 777     nsCOMPtr<nsIURI> newJARFile;
 778     rv = jarFile->Clone(getter_AddRefs(newJARFile));
 779     if (NS_FAILED(rv)) return rv;
 780
 781     NS_TryToSetImmutable(newJARFile);
 782
 783     nsCOMPtr<nsIURI> newJAREntryURI;
 784     rv = mJAREntry->Clone(getter_AddRefs(newJAREntryURI));
 785     if (NS_FAILED(rv)) return rv;
 786
 787     nsCOMPtr<nsIURL> newJAREntry(do_QueryInterface(newJAREntryURI));
 788     NS_ASSERTION(newJAREntry, "This had better QI to nsIURL!");
 789
 790     nsJARURI* uri = new nsJARURI();
 791     if (uri) {
 792         NS_ADDREF(uri);
 793         uri->mJARFile = newJARFile;
 794         uri->mJAREntry = newJAREntry;
 795         *result = uri;
 796         rv = NS_OK;
 797     } else {
 798         rv = NS_ERROR_OUT_OF_MEMORY;
 799     }
 800
 801     return rv;
 802 }
 803
 804 ////////////////////////////////////////////////////////////////////////////////
 805
 806 NS_IMETHODIMP
 807 nsJARURI::GetInnerURI(nsIURI **uri)
 808 {
 809     return NS_EnsureSafeToReturn(mJARFile, uri);
 810 }
 811
 812 NS_IMETHODIMP
 813 nsJARURI::GetInnermostURI(nsIURI** uri)
 814 {
 815     return NS_ImplGetInnermostURI(this, uri);
 816 }
 817