uriloader/exthandler/nsExternalProtocolHandler.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim:set ts=2 sts=2 sw=2 et cin:
   3  *
   4  * ***** BEGIN LICENSE BLOCK *****
   5  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version
   8  * 1.1 (the "License"); you may not use this file except in compliance with
   9  * the License. You may obtain a copy of the License at
  10  * http://www.mozilla.org/MPL/
  11  *
  12  * Software distributed under the License is distributed on an "AS IS" basis,
  13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14  * for the specific language governing rights and limitations under the
  15  * License.
  16  *
  17  * The Original Code is mozilla.org Code.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 1998
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *   Scott MacGregor <mscott@netscape.com>
  26  *   Dan Mosedale <dmose@mozilla.org>
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * either of the GNU General Public License Version 2 or later (the "GPL"),
  30  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  31  * in which case the provisions of the GPL or the LGPL are applicable instead
  32  * of those above. If you wish to allow use of your version of this file only
  33  * under the terms of either the GPL or the LGPL, and not to allow others to
  34  * use your version of this file under the terms of the MPL, indicate your
  35  * decision by deleting the provisions above and replace them with the notice
  36  * and other provisions required by the GPL or the LGPL. If you do not delete
  37  * the provisions above, a recipient may use your version of this file under
  38  * the terms of any one of the MPL, the GPL or the LGPL.
  39  *
  40  * ***** END LICENSE BLOCK ***** */
  41
  42 #include "nsIURI.h"
  43 #include "nsIURL.h"
  44 #include "nsExternalProtocolHandler.h"
  45 #include "nsXPIDLString.h"
  46 #include "nsReadableUtils.h"
  47 #include "nsCOMPtr.h"
  48 #include "nsIServiceManager.h"
  49 #include "nsServiceManagerUtils.h"
  50 #include "nsIInterfaceRequestor.h"
  51 #include "nsIInterfaceRequestorUtils.h"
  52 #include "nsIStringBundle.h"
  53 #include "nsIPrefService.h"
  54 #include "nsIPrompt.h"
  55 #include "nsNetUtil.h"
  56 #include "nsExternalHelperAppService.h"
  57
  58 // used to dispatch urls to default protocol handlers
  59 #include "nsCExternalHandlerService.h"
  60 #include "nsIExternalProtocolService.h"
  61
  62 ////////////////////////////////////////////////////////////////////////
  63 // a stub channel implemenation which will map calls to AsyncRead and OpenInputStream
  64 // to calls in the OS for loading the url.
  65 ////////////////////////////////////////////////////////////////////////
  66
  67 class nsExtProtocolChannel : public nsIChannel
  68 {
  69 public:
  70     NS_DECL_ISUPPORTS
  71     NS_DECL_NSICHANNEL
  72     NS_DECL_NSIREQUEST
  73
  74     nsExtProtocolChannel();
  75     virtual ~nsExtProtocolChannel();
  76
  77     nsresult SetURI(nsIURI*);
  78
  79 private:
  80     nsresult OpenURL();
  81     void Finish(nsresult aResult);
  82
  83     nsCOMPtr<nsIURI> mUrl;
  84     nsCOMPtr<nsIURI> mOriginalURI;
  85     nsresult mStatus;
  86     nsLoadFlags mLoadFlags;
  87     PRBool mWasOpened;
  88
  89     nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
  90     nsCOMPtr<nsILoadGroup> mLoadGroup;
  91 };
  92
  93 NS_IMPL_THREADSAFE_ADDREF(nsExtProtocolChannel)
  94 NS_IMPL_THREADSAFE_RELEASE(nsExtProtocolChannel)
  95
  96 NS_INTERFACE_MAP_BEGIN(nsExtProtocolChannel)
  97    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIChannel)
  98    NS_INTERFACE_MAP_ENTRY(nsIChannel)
  99    NS_INTERFACE_MAP_ENTRY(nsIRequest)
 100 NS_INTERFACE_MAP_END_THREADSAFE
 101
 102 nsExtProtocolChannel::nsExtProtocolChannel() : mStatus(NS_OK),
 103                                                mWasOpened(PR_FALSE)
 104 {
 105 }
 106
 107 nsExtProtocolChannel::~nsExtProtocolChannel()
 108 {}
 109
 110 NS_IMETHODIMP nsExtProtocolChannel::GetLoadGroup(nsILoadGroup * *aLoadGroup)
 111 {
 112   NS_IF_ADDREF(*aLoadGroup = mLoadGroup);
 113   return NS_OK;
 114 }
 115
 116 NS_IMETHODIMP nsExtProtocolChannel::SetLoadGroup(nsILoadGroup * aLoadGroup)
 117 {
 118   mLoadGroup = aLoadGroup;
 119   return NS_OK;
 120 }
 121
 122 NS_IMETHODIMP nsExtProtocolChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aCallbacks)
 123 {
 124   NS_IF_ADDREF(*aCallbacks = mCallbacks);
 125   return NS_OK;
 126 }
 127
 128 NS_IMETHODIMP nsExtProtocolChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aCallbacks)
 129 {
 130   mCallbacks = aCallbacks;
 131   return NS_OK;
 132 }
 133
 134 NS_IMETHODIMP
 135 nsExtProtocolChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
 136 {
 137   *aSecurityInfo = nsnull;
 138   return NS_OK;
 139 }
 140
 141 NS_IMETHODIMP nsExtProtocolChannel::GetOriginalURI(nsIURI* *aURI)
 142 {
 143   NS_ADDREF(*aURI = mOriginalURI);
 144   return NS_OK;
 145 }
 146
 147 NS_IMETHODIMP nsExtProtocolChannel::SetOriginalURI(nsIURI* aURI)
 148 {
 149   NS_ENSURE_ARG_POINTER(aURI);
 150   mOriginalURI = aURI;
 151   return NS_OK;
 152 }
 153
 154 NS_IMETHODIMP nsExtProtocolChannel::GetURI(nsIURI* *aURI)
 155 {
 156   *aURI = mUrl;
 157   NS_IF_ADDREF(*aURI);
 158   return NS_OK;
 159 }
 160
 161 nsresult nsExtProtocolChannel::SetURI(nsIURI* aURI)
 162 {
 163   mUrl = aURI;
 164   return NS_OK;
 165 }
 166
 167 nsresult nsExtProtocolChannel::OpenURL()
 168 {
 169   nsresult rv = NS_ERROR_FAILURE;
 170   nsCOMPtr<nsIExternalProtocolService> extProtService (do_GetService(NS_EXTERNALPROTOCOLSERVICE_CONTRACTID));
 171
 172   if (extProtService)
 173   {
 174 #ifdef DEBUG
 175     nsCAutoString urlScheme;
 176     mUrl->GetScheme(urlScheme);
 177     PRBool haveHandler = PR_FALSE;
 178     extProtService->ExternalProtocolHandlerExists(urlScheme.get(), &haveHandler);
 179     NS_ASSERTION(haveHandler, "Why do we have a channel for this url if we don't support the protocol?");
 180 #endif
 181
 182     nsCOMPtr<nsIInterfaceRequestor> aggCallbacks;
 183     rv = NS_NewNotificationCallbacksAggregation(mCallbacks, mLoadGroup,
 184                                                 getter_AddRefs(aggCallbacks));
 185     if (NS_FAILED(rv)) {
 186       goto finish;
 187     }
 188
 189     rv = extProtService->LoadURI(mUrl, aggCallbacks);
 190     if (NS_SUCCEEDED(rv)) {
 191         // despite success, we need to abort this channel, at the very least
 192         // to make it clear to the caller that no on{Start,Stop}Request
 193         // should be expected.
 194         rv = NS_ERROR_NO_CONTENT;
 195     }
 196   }
 197
 198 finish:
 199   mCallbacks = 0;
 200   return rv;
 201 }
 202
 203 NS_IMETHODIMP nsExtProtocolChannel::Open(nsIInputStream **_retval)
 204 {
 205   return OpenURL();
 206 }
 207
 208 NS_IMETHODIMP nsExtProtocolChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
 209 {
 210   NS_ENSURE_ARG_POINTER(listener);
 211   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
 212
 213   mWasOpened = PR_TRUE;
 214
 215   return OpenURL();
 216 }
 217
 218 NS_IMETHODIMP nsExtProtocolChannel::GetLoadFlags(nsLoadFlags *aLoadFlags)
 219 {
 220   *aLoadFlags = mLoadFlags;
 221   return NS_OK;
 222 }
 223
 224 NS_IMETHODIMP nsExtProtocolChannel::SetLoadFlags(nsLoadFlags aLoadFlags)
 225 {
 226   mLoadFlags = aLoadFlags;
 227   return NS_OK;
 228 }
 229
 230 NS_IMETHODIMP nsExtProtocolChannel::GetContentType(nsACString &aContentType)
 231 {
 232   return NS_ERROR_NOT_IMPLEMENTED;
 233 }
 234
 235 NS_IMETHODIMP nsExtProtocolChannel::SetContentType(const nsACString &aContentType)
 236 {
 237   return NS_ERROR_FAILURE;
 238 }
 239
 240 NS_IMETHODIMP nsExtProtocolChannel::GetContentCharset(nsACString &aContentCharset)
 241 {
 242   return NS_ERROR_NOT_IMPLEMENTED;
 243 }
 244
 245 NS_IMETHODIMP nsExtProtocolChannel::SetContentCharset(const nsACString &aContentCharset)
 246 {
 247   return NS_ERROR_NOT_IMPLEMENTED;
 248 }
 249
 250 NS_IMETHODIMP nsExtProtocolChannel::GetContentLength(PRInt32 * aContentLength)
 251 {
 252   *aContentLength = -1;
 253   return NS_OK;
 254 }
 255
 256 NS_IMETHODIMP
 257 nsExtProtocolChannel::SetContentLength(PRInt32 aContentLength)
 258 {
 259   NS_NOTREACHED("SetContentLength");
 260   return NS_ERROR_NOT_IMPLEMENTED;
 261 }
 262
 263 NS_IMETHODIMP nsExtProtocolChannel::GetOwner(nsISupports * *aPrincipal)
 264 {
 265   NS_NOTREACHED("GetOwner");
 266   return NS_ERROR_NOT_IMPLEMENTED;
 267 }
 268
 269 NS_IMETHODIMP nsExtProtocolChannel::SetOwner(nsISupports * aPrincipal)
 270 {
 271   NS_NOTREACHED("SetOwner");
 272   return NS_ERROR_NOT_IMPLEMENTED;
 273 }
 274
 275 ////////////////////////////////////////////////////////////////////////////////
 276 // From nsIRequest
 277 ////////////////////////////////////////////////////////////////////////////////
 278
 279 NS_IMETHODIMP nsExtProtocolChannel::GetName(nsACString &result)
 280 {
 281   return mUrl->GetSpec(result);
 282 }
 283
 284 NS_IMETHODIMP nsExtProtocolChannel::IsPending(PRBool *result)
 285 {
 286   *result = PR_FALSE;
 287   return NS_OK;
 288 }
 289
 290 NS_IMETHODIMP nsExtProtocolChannel::GetStatus(nsresult *status)
 291 {
 292   *status = mStatus;
 293   return NS_OK;
 294 }
 295
 296 NS_IMETHODIMP nsExtProtocolChannel::Cancel(nsresult status)
 297 {
 298   mStatus = status;
 299   return NS_OK;
 300 }
 301
 302 NS_IMETHODIMP nsExtProtocolChannel::Suspend()
 303 {
 304   NS_NOTREACHED("Suspend");
 305   return NS_ERROR_NOT_IMPLEMENTED;
 306 }
 307
 308 NS_IMETHODIMP nsExtProtocolChannel::Resume()
 309 {
 310   NS_NOTREACHED("Resume");
 311   return NS_ERROR_NOT_IMPLEMENTED;
 312 }
 313
 314 ///////////////////////////////////////////////////////////////////////
 315 // the default protocol handler implementation
 316 //////////////////////////////////////////////////////////////////////
 317
 318 nsExternalProtocolHandler::nsExternalProtocolHandler()
 319 {
 320   m_schemeName = "default";
 321 }
 322
 323
 324 nsExternalProtocolHandler::~nsExternalProtocolHandler()
 325 {}
 326
 327 NS_IMPL_THREADSAFE_ADDREF(nsExternalProtocolHandler)
 328 NS_IMPL_THREADSAFE_RELEASE(nsExternalProtocolHandler)
 329
 330 NS_INTERFACE_MAP_BEGIN(nsExternalProtocolHandler)
 331    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIProtocolHandler)
 332    NS_INTERFACE_MAP_ENTRY(nsIProtocolHandler)
 333    NS_INTERFACE_MAP_ENTRY(nsIExternalProtocolHandler)
 334    NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 335 NS_INTERFACE_MAP_END_THREADSAFE
 336
 337 NS_IMETHODIMP nsExternalProtocolHandler::GetScheme(nsACString &aScheme)
 338 {
 339   aScheme = m_schemeName;
 340   return NS_OK;
 341 }
 342
 343 NS_IMETHODIMP nsExternalProtocolHandler::GetDefaultPort(PRInt32 *aDefaultPort)
 344 {
 345   *aDefaultPort = 0;
 346     return NS_OK;
 347 }
 348
 349 NS_IMETHODIMP
 350 nsExternalProtocolHandler::AllowPort(PRInt32 port, const char *scheme, PRBool *_retval)
 351 {
 352     // don't override anything.
 353     *_retval = PR_FALSE;
 354     return NS_OK;
 355 }
 356 // returns TRUE if the OS can handle this protocol scheme and false otherwise.
 357 PRBool nsExternalProtocolHandler::HaveExternalProtocolHandler(nsIURI * aURI)
 358 {
 359   PRBool haveHandler = PR_FALSE;
 360   if (aURI)
 361   {
 362     nsCAutoString scheme;
 363     aURI->GetScheme(scheme);
 364     if (gExtProtSvc)
 365       gExtProtSvc->ExternalProtocolHandlerExists(scheme.get(), &haveHandler);
 366   }
 367
 368   return haveHandler;
 369 }
 370
 371 NS_IMETHODIMP nsExternalProtocolHandler::GetProtocolFlags(PRUint32 *aUritype)
 372 {
 373     // Make it norelative since it is a simple uri
 374     *aUritype = URI_NORELATIVE | URI_NOAUTH | URI_LOADABLE_BY_ANYONE |
 375         URI_NON_PERSISTABLE | URI_DOES_NOT_RETURN_DATA;
 376     return NS_OK;
 377 }
 378
 379 NS_IMETHODIMP nsExternalProtocolHandler::NewURI(const nsACString &aSpec,
 380                                                 const char *aCharset, // ignore charset info
 381                                                 nsIURI *aBaseURI,
 382                                                 nsIURI **_retval)
 383 {
 384   nsresult rv;
 385   nsCOMPtr<nsIURI> uri = do_CreateInstance(NS_SIMPLEURI_CONTRACTID, &rv);
 386   NS_ENSURE_SUCCESS(rv, rv);
 387
 388   rv = uri->SetSpec(aSpec);
 389   NS_ENSURE_SUCCESS(rv, rv);
 390
 391   NS_ADDREF(*_retval = uri);
 392   return NS_OK;
 393 }
 394
 395 NS_IMETHODIMP nsExternalProtocolHandler::NewChannel(nsIURI *aURI, nsIChannel **_retval)
 396 {
 397   // Only try to return a channel if we have a protocol handler for the url.
 398   // nsOSHelperAppService::LoadUriInternal relies on this to check trustedness
 399   // for some platforms at least.  (win uses ::ShellExecute and unix uses
 400   // gnome_url_show.)
 401   PRBool haveExternalHandler = HaveExternalProtocolHandler(aURI);
 402   if (haveExternalHandler)
 403   {
 404     nsCOMPtr<nsIChannel> channel = new nsExtProtocolChannel();
 405     if (!channel) return NS_ERROR_OUT_OF_MEMORY;
 406
 407     ((nsExtProtocolChannel*) channel.get())->SetURI(aURI);
 408     channel->SetOriginalURI(aURI);
 409
 410     if (_retval)
 411     {
 412       *_retval = channel;
 413       NS_IF_ADDREF(*_retval);
 414       return NS_OK;
 415     }
 416   }
 417
 418   return NS_ERROR_UNKNOWN_PROTOCOL;
 419 }
 420
 421 ///////////////////////////////////////////////////////////////////////
 422 // External protocol handler interface implementation
 423 //////////////////////////////////////////////////////////////////////
 424 NS_IMETHODIMP nsExternalProtocolHandler::ExternalAppExistsForScheme(const nsACString& aScheme, PRBool *_retval)
 425 {
 426   if (gExtProtSvc)
 427     return gExtProtSvc->ExternalProtocolHandlerExists(
 428       PromiseFlatCString(aScheme).get(), _retval);
 429
 430   // In case we don't have external protocol service.
 431   *_retval = PR_FALSE;
 432   return NS_OK;
 433 }