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