embedding/qa/jstests/networking/nsIIOService.js

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3
   4  The contents of this file are subject to the Mozilla Public License Version
   5  1.1 (the "License"); you may not use this file except in compliance with
   6  the License. You may obtain a copy of the License at
   7  http://www.mozilla.org/MPL/
   8
   9  Software distributed under the License is distributed on an "AS IS" basis,
  10  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  for the specific language governing rights and limitations under the
  12  License.
  13
  14  The Original Code is mozilla.org code.
  15
  16  The Initial Developer of the Original Code is
  17  Netscape Communications Corporation.
  18  Portions created by the Initial Developer are Copyright (C) 1998
  19  the Initial Developer. All Rights Reserved.
  20
  21  Contributor(s):
  22    Ashish Bhatt <ashishbhatt@netscape.com> Original Author
  23
  24  Alternatively, the contents of this file may be used under the terms of
  25  either the GNU General Public License Version 2 or later (the "GPL"), or
  26  the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  in which case the provisions of the GPL or the LGPL are applicable instead
  28  of those above. If you wish to allow use of your version of this file only
  29  under the terms of either the GPL or the LGPL, and not to allow others to
  30  use your version of this file under the terms of the MPL, indicate your
  31  decision by deleting the provisions above and replace them with the notice
  32  and other provisions required by the GPL or the LGPL. If you do not delete
  33  the provisions above, a recipient may use your version of this file under
  34  the terms of any one of the MPL, the GPL or the LGPL.
  35
  36  ***** END LICENSE BLOCK ***** */
  37
  38
  39 const nsIIOService =
  40      Components.interfaces.nsIIOService
  41 const IO_SERVICE_CTRID =
  42       "@mozilla.org/network/io-service;1" ;
  43
  44
  45 function IOService()
  46 {
  47
  48    try{
  49         netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
  50         netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
  51
  52
  53        this.service  = Components.classes[IO_SERVICE_CTRID].getService(nsIIOService);
  54        if (!this.service)
  55            return null ;
  56        return this ;
  57    }
  58    catch(e)
  59    {
  60      this.exception = e ;
  61      return null;
  62    }
  63 }
  64
  65
  66 IOService.prototype.service =  null ;
  67 IOService.prototype.success =  null ;
  68 IOService.prototype.exception =  null ;
  69 IOService.prototype.returnvalue =  null ;
  70
  71
  72 IOService.prototype.getProtocolHandler = function(aScheme)
  73 {
  74
  75          /**
  76           * Returns a protocol handler for a given URI scheme.
  77           *
  78           * @param aScheme the URI scheme
  79           * @return reference to corresponding nsIProtocolHandler
  80           *
  81           * nsIProtocolHandler getProtocolHandler(in string aScheme)
  82           */
  83
  84           try{
  85
  86                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
  87                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
  88
  89                 this.returnvalue  = this.service.getProtocolHandler(aScheme) ;
  90
  91                 if (this.returnvalue)
  92                   this.success = true
  93                 else
  94                   this.success = false;
  95          }
  96          catch(e){
  97                 this.success = false;
  98                 this.exception = e ;
  99           }
 100 }
 101
 102 IOService.prototype.getProtocolFlags= function(aScheme)
 103 {
 104          /**
 105           * Returns the protocol flags for a given scheme.
 106           *
 107           * @param aScheme the URI scheme
 108           * @return value of corresponding nsIProtocolHandler::protocolFlags
 109           *
 110           * unsigned long getProtocolFlags(in string aScheme);
 111           */
 112
 113
 114           try{
 115
 116                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 117                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 118
 119                 this.returnvalue  = this.service.getProtocolFlags(aScheme) ;
 120                 if (this.returnvalue>=0)
 121                   this.success = true
 122                 else
 123                   this.success = false;
 124          }
 125          catch(e){
 126                 this.success = false;
 127                 this.exception = e ;
 128           }
 129 }
 130
 131 IOService.prototype.newURI =  function(aSpec,aOriginCharset,aBaseURI)
 132 {
 133          /**
 134           * This method constructs a new URI by determining the scheme of the
 135           * URI spec, and then delegating the construction of the URI to the
 136           * protocol handler for that scheme. QueryInterface can be used on
 137           * the resulting URI object to obtain a more specific type of URI.
 138           *
 139           * @see nsIProtocolHandler::newURI
 140           *
 141           * nsIURI newURI(in AUTF8String aSpec,
 142           *                        in string aOriginCharset,
 143           *                        in nsIURI aBaseURI);
 144           */
 145
 146           try{
 147
 148                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 149                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 150
 151                 this.returnvalue  = this.service.newURI(aSpec,aOriginCharset,aBaseURI) ;
 152
 153                 if (this.returnvalue)
 154                   this.success = true
 155                 else
 156                   this.success = false;
 157          }
 158          catch(e){
 159                 this.success = false;
 160                 this.exception = e ;
 161           }
 162 }
 163
 164
 165 IOService.prototype.newFileURI= function(file)
 166 {
 167          /**
 168           * This method constructs a new URI from a nsIFile.
 169           *
 170           * @param aFile specifies the file path
 171           * @return reference to a new nsIURI object
 172           *
 173           * nsIURI newFileURI(in nsIFile aFile);
 174           */
 175
 176           try{
 177
 178                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 179                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 180
 181                 this.returnvalue  = this.service.newFileURI(file) ;
 182
 183                 if (this.returnvalue)
 184                   this.success = true
 185                 else
 186                   this.success = false;
 187          }
 188          catch(e){
 189                 this.success = false;
 190                 this.exception = e ;
 191           }
 192
 193 }
 194
 195
 196 IOService.prototype.newChannelFromURI = function(aURI)
 197 {
 198          /**
 199           * Creates a channel for a given URI.
 200           *
 201           * @param aURI nsIURI from which to make a channel
 202           * @return reference to the new nsIChannel object
 203           *
 204           * nsIChannel newChannelFromURI(in nsIURI aURI);
 205           */
 206
 207           try{
 208
 209                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 210                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 211
 212                 this.returnvalue  = this.service.newChannelFromURI(aURI) ;
 213
 214                 if (this.returnvalue)
 215                   this.success = true
 216                 else
 217                   this.success = false;
 218          }
 219          catch(e){
 220                 this.success = false;
 221                 this.exception = e ;
 222           }
 223
 224 }
 225
 226
 227 IOService.prototype.newChannel = function(aSpec,aOriginCharset,aBaseURI)
 228 {
 229          /**
 230           * Equivalent to newChannelFromURI(newURI(...))
 231           *
 232           * nsIChannel newChannel(in AUTF8String aSpec,
 233           *                                        in string aOriginCharset,
 234           *                                        in nsIURI aBaseURI);
 235           */
 236
 237           try{
 238
 239                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 240                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 241
 242                 this.returnvalue  = this.service.newChannel(aSpec,aOriginCharset,aBaseURI) ;
 243
 244                 if (this.returnvalue)
 245                   this.success = true
 246                 else
 247                   this.success = false;
 248          }
 249          catch(e){
 250                 this.success = false;
 251                 this.exception = e ;
 252           }
 253
 254 }
 255
 256 IOService.prototype.Getoffline = function()
 257 {
 258
 259          /**
 260           * Returns true if networking is in "offline" mode. When in offline mode,
 261           * attempts to access the network will fail (although this does not
 262           * necessarily correlate with whether there is actually a network
 263           * available -- that's hard to detect without causing the dialer to
 264           * come up).
 265           *
 266           *     attribute boolean offline;
 267           */
 268
 269           try{
 270
 271                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 272                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 273
 274                 this.returnvalue  = this.service.offline ;
 275                 this.success = true;
 276          }
 277          catch(e){
 278                 this.success = false;
 279                 this.exception = e ;
 280           }
 281
 282 }
 283
 284 IOService.prototype. Setoffline = function(aOffline)
 285 {
 286          /**
 287           * Returns true if networking is in "offline" mode. When in offline mode,
 288           * attempts to access the network will fail (although this does not
 289           * necessarily correlate with whether there is actually a network
 290           * available -- that's hard to detect without causing the dialer to
 291           * come up).
 292           *
 293           *     attribute boolean offline;
 294           */
 295
 296           try{
 297
 298                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 299                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 300
 301                 this.service.offline  = aOffline ;
 302                 this.returnvalue  = this.service.offline
 303                 this.success = true;
 304          }
 305          catch(e){
 306                 this.success = false;
 307                 this.exception = e ;
 308           }
 309
 310 }
 311
 312 IOService.prototype.allowPort= function(aPort, aScheme)
 313 {
 314          /**
 315           * Checks if a port number is banned. This involves consulting a list of
 316           * unsafe ports, corresponding to network services that may be easily
 317           * exploitable. If the given port is considered unsafe, then the protocol
 318           * handler (corresponding to aScheme) will be asked whether it wishes to
 319           * override the IO service's decision to block the port. This gives the
 320           * protocol handler ultimate control over its own security policy while
 321           * ensuring reasonable, default protection.
 322           *
 323           * @see nsIProtocolHandler::allowPort
 324           *
 325           * boolean allowPort(in long aPort, in string aScheme);
 326           */
 327
 328
 329           try{
 330
 331                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 332                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 333
 334                 this.returnvalue  = this.service.allowPort(aPort, aScheme) ;
 335
 336                 if (this.returnvalue)
 337                   this.success = true
 338                 else
 339                   this.success = false;
 340          }
 341          catch(e){
 342                 this.success = false;
 343                 this.exception = e ;
 344           }
 345
 346 }
 347
 348 IOService.prototype.extractScheme = function(urlString)
 349 {
 350          /**
 351           * Utility to extract the scheme from a URL string, consistently and
 352           * according to spec (see RFC 2396).
 353           *
 354           * NOTE: Most URL parsing is done via nsIURI, and in fact the scheme
 355           * can also be extracted from a URL string via nsIURI.  This method
 356           * is provided purely as an optimization.
 357           *
 358           * @param aSpec the URL string to parse
 359           * @return URL scheme
 360           *
 361           * @throws NS_ERROR_MALFORMED_URI if URL string is not of the right form.
 362           *
 363           * ACString extractScheme(in AUTF8String urlString);
 364           */
 365
 366           try
 367           {
 368
 369                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
 370                 netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 371
 372                 this.returnvalue  = this.service.extractScheme(urlString) ;
 373
 374                 if (this.returnvalue)
 375                   this.success = true
 376                 else
 377                   this.success = false;
 378          }
 379          catch(e)
 380          {
 381                 this.success = false;
 382                 this.exception = e ;
 383          }
 384
 385 }