uriloader/exthandler/nsMIMEInfoImpl.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et: */
   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 of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or 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 "nsMIMEInfoImpl.h"
  40 #include "nsXPIDLString.h"
  41 #include "nsReadableUtils.h"
  42 #include "nsStringEnumerator.h"
  43 #include "nsIProcess.h"
  44 #include "nsILocalFile.h"
  45 #include "nsIFileURL.h"
  46 #include "nsEscape.h"
  47 #include "nsNetUtil.h"
  48 #include "nsIURILoader.h"
  49 #include "nsCURILoader.h"
  50
  51 // nsISupports methods
  52 NS_IMPL_THREADSAFE_ADDREF(nsMIMEInfoBase)
  53 NS_IMPL_THREADSAFE_RELEASE(nsMIMEInfoBase)
  54
  55 NS_INTERFACE_MAP_BEGIN(nsMIMEInfoBase)
  56     NS_INTERFACE_MAP_ENTRY(nsIHandlerInfo)
  57     // This is only an nsIMIMEInfo if it's a MIME handler.
  58     NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIMIMEInfo, mClass == eMIMEInfo)
  59     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIHandlerInfo)
  60 NS_INTERFACE_MAP_END_THREADSAFE
  61
  62 // nsMIMEInfoImpl methods
  63
  64 // Constructors for a MIME handler.
  65 nsMIMEInfoBase::nsMIMEInfoBase(const char *aMIMEType) :
  66     mMacType(0),
  67     mMacCreator(0),
  68     mType(aMIMEType),
  69     mClass(eMIMEInfo),
  70     mPreferredAction(nsIMIMEInfo::saveToDisk),
  71     mAlwaysAskBeforeHandling(PR_TRUE)
  72 {
  73 }
  74
  75 nsMIMEInfoBase::nsMIMEInfoBase(const nsACString& aMIMEType) :
  76     mMacType(0),
  77     mMacCreator(0),
  78     mType(aMIMEType),
  79     mClass(eMIMEInfo),
  80     mPreferredAction(nsIMIMEInfo::saveToDisk),
  81     mAlwaysAskBeforeHandling(PR_TRUE)
  82 {
  83 }
  84
  85 // Constructor for a handler that lets the caller specify whether this is a
  86 // MIME handler or a protocol handler.  In the long run, these will be distinct
  87 // classes (f.e. nsMIMEInfo and nsProtocolInfo), but for now we reuse this class
  88 // for both and distinguish between the two kinds of handlers via the aClass
  89 // argument to this method, which can be either eMIMEInfo or eProtocolInfo.
  90 nsMIMEInfoBase::nsMIMEInfoBase(const nsACString& aType, HandlerClass aClass) :
  91     mMacType(0),
  92     mMacCreator(0),
  93     mType(aType),
  94     mClass(aClass),
  95     mPreferredAction(nsIMIMEInfo::saveToDisk),
  96     mAlwaysAskBeforeHandling(PR_TRUE)
  97 {
  98 }
  99
 100 nsMIMEInfoBase::~nsMIMEInfoBase()
 101 {
 102 }
 103
 104 NS_IMETHODIMP
 105 nsMIMEInfoBase::GetFileExtensions(nsIUTF8StringEnumerator** aResult)
 106 {
 107   return NS_NewUTF8StringEnumerator(aResult, &mExtensions, this);
 108 }
 109
 110 NS_IMETHODIMP
 111 nsMIMEInfoBase::ExtensionExists(const nsACString& aExtension, PRBool *_retval)
 112 {
 113     NS_ASSERTION(!aExtension.IsEmpty(), "no extension");
 114     PRBool found = PR_FALSE;
 115     PRUint32 extCount = mExtensions.Count();
 116     if (extCount < 1) return NS_OK;
 117
 118     for (PRUint8 i=0; i < extCount; i++) {
 119         nsCString* ext = (nsCString*)mExtensions.CStringAt(i);
 120         if (ext->Equals(aExtension, nsCaseInsensitiveCStringComparator())) {
 121             found = PR_TRUE;
 122             break;
 123         }
 124     }
 125
 126     *_retval = found;
 127     return NS_OK;
 128 }
 129
 130 NS_IMETHODIMP
 131 nsMIMEInfoBase::GetPrimaryExtension(nsACString& _retval)
 132 {
 133     PRUint32 extCount = mExtensions.Count();
 134     if (extCount < 1) return NS_ERROR_NOT_INITIALIZED;
 135
 136     _retval = *(mExtensions.CStringAt(0));
 137     return NS_OK;
 138 }
 139
 140 NS_IMETHODIMP
 141 nsMIMEInfoBase::SetPrimaryExtension(const nsACString& aExtension)
 142 {
 143   NS_ASSERTION(!aExtension.IsEmpty(), "no extension");
 144   PRUint32 extCount = mExtensions.Count();
 145   PRUint8 i;
 146   PRBool found = PR_FALSE;
 147   for (i=0; i < extCount; i++) {
 148     nsCString* ext = (nsCString*)mExtensions.CStringAt(i);
 149     if (ext->Equals(aExtension, nsCaseInsensitiveCStringComparator())) {
 150       found = PR_TRUE;
 151       break;
 152     }
 153   }
 154   if (found) {
 155     mExtensions.RemoveCStringAt(i);
 156   }
 157
 158   mExtensions.InsertCStringAt(aExtension, 0);
 159
 160   return NS_OK;
 161 }
 162
 163 NS_IMETHODIMP
 164 nsMIMEInfoBase::AppendExtension(const nsACString& aExtension)
 165 {
 166   mExtensions.AppendCString(aExtension);
 167   return NS_OK;
 168 }
 169
 170 NS_IMETHODIMP
 171 nsMIMEInfoBase::GetType(nsACString& aType)
 172 {
 173     if (mType.IsEmpty())
 174         return NS_ERROR_NOT_INITIALIZED;
 175
 176     aType = mType;
 177     return NS_OK;
 178 }
 179
 180 NS_IMETHODIMP
 181 nsMIMEInfoBase::GetMIMEType(nsACString& aMIMEType)
 182 {
 183     if (mType.IsEmpty())
 184         return NS_ERROR_NOT_INITIALIZED;
 185
 186     aMIMEType = mType;
 187     return NS_OK;
 188 }
 189
 190 NS_IMETHODIMP
 191 nsMIMEInfoBase::GetDescription(nsAString& aDescription)
 192 {
 193     aDescription = mDescription;
 194     return NS_OK;
 195 }
 196
 197 NS_IMETHODIMP
 198 nsMIMEInfoBase::SetDescription(const nsAString& aDescription)
 199 {
 200     mDescription = aDescription;
 201     return NS_OK;
 202 }
 203
 204 NS_IMETHODIMP
 205 nsMIMEInfoBase::Equals(nsIMIMEInfo *aMIMEInfo, PRBool *_retval)
 206 {
 207     if (!aMIMEInfo) return NS_ERROR_NULL_POINTER;
 208
 209     nsCAutoString type;
 210     nsresult rv = aMIMEInfo->GetMIMEType(type);
 211     if (NS_FAILED(rv)) return rv;
 212
 213     *_retval = mType.Equals(type);
 214
 215     return NS_OK;
 216 }
 217
 218 NS_IMETHODIMP
 219 nsMIMEInfoBase::GetMacType(PRUint32 *aMacType)
 220 {
 221     *aMacType = mMacType;
 222
 223     if (!mMacType)
 224         return NS_ERROR_NOT_INITIALIZED;
 225
 226     return NS_OK;
 227 }
 228
 229 NS_IMETHODIMP
 230 nsMIMEInfoBase::SetMacType(PRUint32 aMacType)
 231 {
 232     mMacType = aMacType;
 233     return NS_OK;
 234 }
 235
 236 NS_IMETHODIMP
 237 nsMIMEInfoBase::GetMacCreator(PRUint32 *aMacCreator)
 238 {
 239     *aMacCreator = mMacCreator;
 240
 241     if (!mMacCreator)
 242         return NS_ERROR_NOT_INITIALIZED;
 243
 244     return NS_OK;
 245 }
 246
 247 NS_IMETHODIMP
 248 nsMIMEInfoBase::SetMacCreator(PRUint32 aMacCreator)
 249 {
 250     mMacCreator = aMacCreator;
 251     return NS_OK;
 252 }
 253
 254 NS_IMETHODIMP
 255 nsMIMEInfoBase::SetFileExtensions(const nsACString& aExtensions)
 256 {
 257     mExtensions.Clear();
 258     nsCString extList( aExtensions );
 259
 260     PRInt32 breakLocation = -1;
 261     while ( (breakLocation= extList.FindChar(',') )!= -1)
 262     {
 263         mExtensions.AppendCString(Substring(extList.get(), extList.get() + breakLocation));
 264         extList.Cut(0, breakLocation+1 );
 265     }
 266     if ( !extList.IsEmpty() )
 267         mExtensions.AppendCString( extList );
 268     return NS_OK;
 269 }
 270
 271 NS_IMETHODIMP
 272 nsMIMEInfoBase::GetDefaultDescription(nsAString& aDefaultDescription)
 273 {
 274   aDefaultDescription = mDefaultAppDescription;
 275   return NS_OK;
 276 }
 277
 278 NS_IMETHODIMP
 279 nsMIMEInfoBase::GetPreferredApplicationHandler(nsIHandlerApp ** aPreferredAppHandler)
 280 {
 281   *aPreferredAppHandler = mPreferredApplication;
 282   NS_IF_ADDREF(*aPreferredAppHandler);
 283   return NS_OK;
 284 }
 285
 286 NS_IMETHODIMP
 287 nsMIMEInfoBase::SetPreferredApplicationHandler(nsIHandlerApp * aPreferredAppHandler)
 288 {
 289   mPreferredApplication = aPreferredAppHandler;
 290   return NS_OK;
 291 }
 292
 293 NS_IMETHODIMP
 294 nsMIMEInfoBase::GetPossibleApplicationHandlers(nsIMutableArray ** aPossibleAppHandlers)
 295 {
 296   if (!mPossibleApplications)
 297     mPossibleApplications = do_CreateInstance(NS_ARRAY_CONTRACTID);
 298
 299   if (!mPossibleApplications)
 300     return NS_ERROR_OUT_OF_MEMORY;
 301
 302   *aPossibleAppHandlers = mPossibleApplications;
 303   NS_IF_ADDREF(*aPossibleAppHandlers);
 304   return NS_OK;
 305 }
 306
 307 NS_IMETHODIMP
 308 nsMIMEInfoBase::GetPreferredAction(nsHandlerInfoAction * aPreferredAction)
 309 {
 310   *aPreferredAction = mPreferredAction;
 311   return NS_OK;
 312 }
 313
 314 NS_IMETHODIMP
 315 nsMIMEInfoBase::SetPreferredAction(nsHandlerInfoAction aPreferredAction)
 316 {
 317   mPreferredAction = aPreferredAction;
 318   return NS_OK;
 319 }
 320
 321 NS_IMETHODIMP
 322 nsMIMEInfoBase::GetAlwaysAskBeforeHandling(PRBool * aAlwaysAsk)
 323 {
 324   *aAlwaysAsk = mAlwaysAskBeforeHandling;
 325
 326   return NS_OK;
 327 }
 328
 329 NS_IMETHODIMP
 330 nsMIMEInfoBase::SetAlwaysAskBeforeHandling(PRBool aAlwaysAsk)
 331 {
 332   mAlwaysAskBeforeHandling = aAlwaysAsk;
 333   return NS_OK;
 334 }
 335
 336 /* static */
 337 nsresult
 338 nsMIMEInfoBase::GetLocalFileFromURI(nsIURI *aURI, nsILocalFile **aFile)
 339 {
 340   nsresult rv;
 341
 342   nsCOMPtr<nsIFileURL> fileUrl = do_QueryInterface(aURI, &rv);
 343   if (NS_FAILED(rv)) return rv;
 344
 345   nsCOMPtr<nsIFile> file;
 346   rv = fileUrl->GetFile(getter_AddRefs(file));
 347   if (NS_FAILED(rv)) return rv;
 348
 349   return CallQueryInterface(file, aFile);
 350 }
 351
 352 NS_IMETHODIMP
 353 nsMIMEInfoBase::LaunchWithFile(nsIFile* aFile)
 354 {
 355   nsresult rv;
 356
 357   // it doesn't make any sense to call this on protocol handlers
 358   NS_ASSERTION(mClass == eMIMEInfo,
 359                "nsMIMEInfoBase should have mClass == eMIMEInfo");
 360
 361   if (mPreferredAction == useSystemDefault) {
 362     return LaunchDefaultWithFile(aFile);
 363   }
 364
 365   if (mPreferredAction == useHelperApp) {
 366     if (!mPreferredApplication)
 367       return NS_ERROR_FILE_NOT_FOUND;
 368
 369     // at the moment, we only know how to hand files off to local handlers
 370     nsCOMPtr<nsILocalHandlerApp> localHandler =
 371       do_QueryInterface(mPreferredApplication, &rv);
 372     NS_ENSURE_SUCCESS(rv, rv);
 373
 374     nsCOMPtr<nsIFile> executable;
 375     rv = localHandler->GetExecutable(getter_AddRefs(executable));
 376     NS_ENSURE_SUCCESS(rv, rv);
 377
 378     nsCAutoString path;
 379     aFile->GetNativePath(path);
 380     return LaunchWithIProcess(executable, path);
 381   }
 382
 383   return NS_ERROR_INVALID_ARG;
 384 }
 385
 386 NS_IMETHODIMP
 387 nsMIMEInfoBase::LaunchWithURI(nsIURI* aURI,
 388                               nsIInterfaceRequestor* aWindowContext)
 389 {
 390   // for now, this is only being called with protocol handlers; that
 391   // will change once we get to more general registerContentHandler
 392   // support
 393   NS_ASSERTION(mClass == eProtocolInfo,
 394                "nsMIMEInfoBase should be a protocol handler");
 395
 396   if (mPreferredAction == useSystemDefault) {
 397     return LoadUriInternal(aURI);
 398   }
 399
 400   if (mPreferredAction == useHelperApp) {
 401     if (!mPreferredApplication)
 402       return NS_ERROR_FILE_NOT_FOUND;
 403
 404     return mPreferredApplication->LaunchWithURI(aURI, aWindowContext);
 405   }
 406
 407   return NS_ERROR_INVALID_ARG;
 408 }
 409
 410 void
 411 nsMIMEInfoBase::CopyBasicDataTo(nsMIMEInfoBase* aOther)
 412 {
 413   aOther->mType = mType;
 414   aOther->mDefaultAppDescription = mDefaultAppDescription;
 415   aOther->mExtensions = mExtensions;
 416
 417   aOther->mMacType = mMacType;
 418   aOther->mMacCreator = mMacCreator;
 419 }
 420
 421 /* static */
 422 nsresult
 423 nsMIMEInfoBase::LaunchWithIProcess(nsIFile* aApp, const nsCString& aArg)
 424 {
 425   NS_ASSERTION(aApp, "Unexpected null pointer, fix caller");
 426
 427   nsresult rv;
 428   nsCOMPtr<nsIProcess> process = do_CreateInstance(NS_PROCESS_CONTRACTID, &rv);
 429   if (NS_FAILED(rv))
 430     return rv;
 431
 432   if (NS_FAILED(rv = process->Init(aApp)))
 433     return rv;
 434
 435   const char *string = aArg.get();
 436
 437   PRUint32 pid;
 438   return process->Run(PR_FALSE, &string, 1, &pid);
 439 }
 440
 441 // nsMIMEInfoImpl implementation
 442 NS_IMETHODIMP
 443 nsMIMEInfoImpl::GetDefaultDescription(nsAString& aDefaultDescription)
 444 {
 445   if (mDefaultAppDescription.IsEmpty() && mDefaultApplication) {
 446     // Don't want to cache this, just in case someone resets the app
 447     // without changing the description....
 448     mDefaultApplication->GetLeafName(aDefaultDescription);
 449   } else {
 450     aDefaultDescription = mDefaultAppDescription;
 451   }
 452
 453   return NS_OK;
 454 }
 455
 456 NS_IMETHODIMP
 457 nsMIMEInfoImpl::GetHasDefaultHandler(PRBool * _retval)
 458 {
 459   *_retval = !mDefaultAppDescription.IsEmpty();
 460   if (mDefaultApplication) {
 461     PRBool exists;
 462     *_retval = NS_SUCCEEDED(mDefaultApplication->Exists(&exists)) && exists;
 463   }
 464   return NS_OK;
 465 }
 466
 467 nsresult
 468 nsMIMEInfoImpl::LaunchDefaultWithFile(nsIFile* aFile)
 469 {
 470   if (!mDefaultApplication)
 471     return NS_ERROR_FILE_NOT_FOUND;
 472
 473   nsCAutoString nativePath;
 474   aFile->GetNativePath(nativePath);
 475
 476   return LaunchWithIProcess(mDefaultApplication, nativePath);
 477 }
 478
 479 NS_IMETHODIMP
 480 nsMIMEInfoBase::GetPossibleLocalHandlers(nsIArray **_retval)
 481 {
 482   return NS_ERROR_NOT_IMPLEMENTED;
 483 }