2009-08-05 20:19:01 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
* vim: sw=4 ts=4 sts=4 et filetype=javascript
|
2009-05-07 19:21:54 +00:00
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is Mozilla code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
2010-08-27 19:42:51 +00:00
|
|
|
* Mozilla Foundation.
|
2009-05-07 19:21:54 +00:00
|
|
|
* Portions created by the Initial Developer are Copyright (C) 2009
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* Boris Zbarsky <bzbarsky@mit.edu> (original author)
|
2009-09-02 20:24:49 +00:00
|
|
|
* Shawn Wilsher <me@shawnwilsher.com>
|
2009-05-07 19:21:54 +00:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
2009-08-05 20:19:01 +00:00
|
|
|
let EXPORTED_SYMBOLS = [
|
|
|
|
"NetUtil",
|
|
|
|
];
|
|
|
|
|
2009-05-07 21:00:06 +00:00
|
|
|
/**
|
2009-05-07 19:21:54 +00:00
|
|
|
* Necko utilities
|
|
|
|
*/
|
|
|
|
|
2009-09-02 20:24:49 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//// Constants
|
|
|
|
|
2009-05-07 19:21:54 +00:00
|
|
|
const Ci = Components.interfaces;
|
|
|
|
const Cc = Components.classes;
|
2009-09-02 20:24:49 +00:00
|
|
|
const Cr = Components.results;
|
2010-07-23 21:59:07 +00:00
|
|
|
const Cu = Components.utils;
|
2009-09-02 20:24:49 +00:00
|
|
|
|
2009-10-15 23:16:01 +00:00
|
|
|
const PR_UINT32_MAX = 0xffffffff;
|
|
|
|
|
2009-09-02 20:24:49 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//// NetUtil Object
|
2009-05-07 19:21:54 +00:00
|
|
|
|
2009-05-07 21:00:06 +00:00
|
|
|
const NetUtil = {
|
2009-05-07 19:21:54 +00:00
|
|
|
/**
|
|
|
|
* Function to perform simple async copying from aSource (an input stream)
|
|
|
|
* to aSink (an output stream). The copy will happen on some background
|
|
|
|
* thread. Both streams will be closed when the copy completes.
|
|
|
|
*
|
2009-09-02 20:24:49 +00:00
|
|
|
* @param aSource
|
|
|
|
* The input stream to read from
|
|
|
|
* @param aSink
|
|
|
|
* The output stream to write to
|
|
|
|
* @param aCallback [optional]
|
|
|
|
* A function that will be called at copy completion with a single
|
|
|
|
* argument: the nsresult status code for the copy operation.
|
2009-05-07 19:21:54 +00:00
|
|
|
*
|
2009-09-02 20:24:49 +00:00
|
|
|
* @return An nsIRequest representing the copy operation (for example, this
|
2009-05-07 19:21:54 +00:00
|
|
|
* can be used to cancel the copying). The consumer can ignore the
|
|
|
|
* return value if desired.
|
|
|
|
*/
|
2009-09-02 20:24:49 +00:00
|
|
|
asyncCopy: function NetUtil_asyncCopy(aSource, aSink, aCallback)
|
|
|
|
{
|
2009-05-07 19:21:54 +00:00
|
|
|
if (!aSource || !aSink) {
|
2009-09-02 20:24:49 +00:00
|
|
|
let exception = new Components.Exception(
|
|
|
|
"Must have a source and a sink",
|
|
|
|
Cr.NS_ERROR_INVALID_ARG,
|
|
|
|
Components.stack.caller
|
|
|
|
);
|
|
|
|
throw exception;
|
2009-05-07 19:21:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
var sourceBuffered = ioUtil.inputStreamIsBuffered(aSource);
|
|
|
|
var sinkBuffered = ioUtil.outputStreamIsBuffered(aSink);
|
|
|
|
|
2009-08-05 20:19:01 +00:00
|
|
|
var ostream = aSink;
|
2009-05-07 19:21:54 +00:00
|
|
|
if (!sourceBuffered && !sinkBuffered) {
|
|
|
|
// wrap the sink in a buffered stream.
|
2009-08-05 20:19:01 +00:00
|
|
|
ostream = Cc["@mozilla.org/network/buffered-output-stream;1"].
|
|
|
|
createInstance(Ci.nsIBufferedOutputStream);
|
|
|
|
ostream.init(aSink, 0x8000);
|
2009-05-07 19:21:54 +00:00
|
|
|
sinkBuffered = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// make a stream copier
|
|
|
|
var copier = Cc["@mozilla.org/network/async-stream-copier;1"].
|
|
|
|
createInstance(Ci.nsIAsyncStreamCopier);
|
|
|
|
|
|
|
|
// Initialize the copier. The 0x8000 should match the size of the
|
|
|
|
// buffer our buffered stream is using, for best performance. If we're
|
|
|
|
// not using our own buffered stream, that's ok too. But maybe we
|
|
|
|
// should just use the default net segment size here?
|
2009-08-05 20:19:01 +00:00
|
|
|
copier.init(aSource, ostream, null, sourceBuffered, sinkBuffered,
|
2009-05-07 19:21:54 +00:00
|
|
|
0x8000, true, true);
|
|
|
|
|
|
|
|
var observer;
|
|
|
|
if (aCallback) {
|
|
|
|
observer = {
|
2009-08-05 20:19:01 +00:00
|
|
|
onStartRequest: function(aRequest, aContext) {},
|
|
|
|
onStopRequest: function(aRequest, aContext, aStatusCode) {
|
|
|
|
aCallback(aStatusCode);
|
|
|
|
}
|
2009-05-07 19:21:54 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
observer = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// start the copying
|
|
|
|
copier.asyncCopy(observer, null);
|
|
|
|
return copier;
|
2009-09-02 20:24:49 +00:00
|
|
|
},
|
|
|
|
|
2009-10-15 23:16:01 +00:00
|
|
|
/**
|
2009-12-16 07:33:08 +00:00
|
|
|
* Asynchronously opens a source and fetches the response. A source can be
|
2011-03-31 17:24:42 +00:00
|
|
|
* an nsIURI, nsIFile, string spec, nsIChannel, or nsIInputStream. The
|
|
|
|
* provided callback will get an input stream containing the response, the
|
|
|
|
* result code, and a reference to the request.
|
2009-10-15 23:16:01 +00:00
|
|
|
*
|
2009-12-16 07:33:08 +00:00
|
|
|
* @param aSource
|
2011-03-31 17:24:42 +00:00
|
|
|
* The nsIURI, nsIFile, string spec, nsIChannel, or nsIInputStream
|
|
|
|
* to open.
|
2010-07-23 21:59:07 +00:00
|
|
|
* Note: If passing an nsIChannel whose notificationCallbacks is
|
|
|
|
* already set, callers are responsible for implementations
|
|
|
|
* of nsIBadCertListener/nsISSLErrorListener.
|
2009-10-15 23:16:01 +00:00
|
|
|
* @param aCallback
|
|
|
|
* The callback function that will be notified upon completion. It
|
|
|
|
* will get two arguments:
|
2011-03-31 17:24:42 +00:00
|
|
|
* 1) An nsIInputStream containing the data from aSource, if any.
|
2009-12-16 07:33:08 +00:00
|
|
|
* 2) The status code from opening the source.
|
2011-03-31 17:24:42 +00:00
|
|
|
* 3) Reference to the nsIRequest.
|
2009-10-15 23:16:01 +00:00
|
|
|
*/
|
2009-12-16 07:33:08 +00:00
|
|
|
asyncFetch: function NetUtil_asyncOpen(aSource, aCallback)
|
2009-10-15 23:16:01 +00:00
|
|
|
{
|
2009-12-16 07:33:08 +00:00
|
|
|
if (!aSource || !aCallback) {
|
2009-10-15 23:16:01 +00:00
|
|
|
let exception = new Components.Exception(
|
2009-12-16 07:33:08 +00:00
|
|
|
"Must have a source and a callback",
|
2009-10-15 23:16:01 +00:00
|
|
|
Cr.NS_ERROR_INVALID_ARG,
|
|
|
|
Components.stack.caller
|
|
|
|
);
|
|
|
|
throw exception;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a pipe that will create our output stream that we can use once
|
|
|
|
// we have gotten all the data.
|
|
|
|
let pipe = Cc["@mozilla.org/pipe;1"].
|
|
|
|
createInstance(Ci.nsIPipe);
|
2009-10-18 20:40:49 +00:00
|
|
|
pipe.init(true, true, 0, PR_UINT32_MAX, null);
|
2009-10-15 23:16:01 +00:00
|
|
|
|
|
|
|
// Create a listener that will give data to the pipe's output stream.
|
|
|
|
let listener = Cc["@mozilla.org/network/simple-stream-listener;1"].
|
|
|
|
createInstance(Ci.nsISimpleStreamListener);
|
|
|
|
listener.init(pipe.outputStream, {
|
|
|
|
onStartRequest: function(aRequest, aContext) {},
|
|
|
|
onStopRequest: function(aRequest, aContext, aStatusCode) {
|
2009-10-18 20:40:49 +00:00
|
|
|
pipe.outputStream.close();
|
2010-07-23 21:59:07 +00:00
|
|
|
aCallback(pipe.inputStream, aStatusCode, aRequest);
|
2009-10-15 23:16:01 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2011-03-31 17:24:42 +00:00
|
|
|
// Input streams are handled slightly differently from everything else.
|
|
|
|
if (aSource instanceof Ci.nsIInputStream) {
|
|
|
|
let pump = Cc["@mozilla.org/network/input-stream-pump;1"].
|
|
|
|
createInstance(Ci.nsIInputStreamPump);
|
|
|
|
pump.init(aSource, -1, -1, 0, 0, true);
|
|
|
|
pump.asyncRead(listener, null);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-12-16 07:33:08 +00:00
|
|
|
let channel = aSource;
|
|
|
|
if (!(channel instanceof Ci.nsIChannel)) {
|
|
|
|
channel = this.newChannel(aSource);
|
|
|
|
}
|
|
|
|
|
2010-07-23 21:59:07 +00:00
|
|
|
// Add a BadCertHandler to suppress SSL/cert error dialogs, but only if
|
|
|
|
// the channel doesn't already have a notificationCallbacks.
|
|
|
|
if (!channel.notificationCallbacks) {
|
|
|
|
// Pass true to avoid optional redirect-cert-checking behavior.
|
|
|
|
channel.notificationCallbacks = new BadCertHandler(true);
|
|
|
|
}
|
|
|
|
|
2009-12-16 07:33:08 +00:00
|
|
|
channel.asyncOpen(listener, null);
|
2009-10-15 23:16:01 +00:00
|
|
|
},
|
|
|
|
|
2009-09-02 20:24:49 +00:00
|
|
|
/**
|
2009-12-16 07:33:03 +00:00
|
|
|
* Constructs a new URI for the given spec, character set, and base URI, or
|
|
|
|
* an nsIFile.
|
2009-09-02 20:24:49 +00:00
|
|
|
*
|
2009-12-16 07:33:03 +00:00
|
|
|
* @param aTarget
|
|
|
|
* The string spec for the desired URI or an nsIFile.
|
2009-09-02 20:24:49 +00:00
|
|
|
* @param aOriginCharset [optional]
|
2009-12-16 07:33:03 +00:00
|
|
|
* The character set for the URI. Only used if aTarget is not an
|
|
|
|
* nsIFile.
|
2009-09-02 20:24:49 +00:00
|
|
|
* @param aBaseURI [optional]
|
2009-12-16 07:33:03 +00:00
|
|
|
* The base URI for the spec. Only used if aTarget is not an
|
|
|
|
* nsIFile.
|
2009-09-02 20:24:49 +00:00
|
|
|
*
|
|
|
|
* @return an nsIURI object.
|
|
|
|
*/
|
2009-12-16 07:33:03 +00:00
|
|
|
newURI: function NetUtil_newURI(aTarget, aOriginCharset, aBaseURI)
|
2009-09-02 20:24:49 +00:00
|
|
|
{
|
2009-12-16 07:33:03 +00:00
|
|
|
if (!aTarget) {
|
2009-09-02 20:24:49 +00:00
|
|
|
let exception = new Components.Exception(
|
2009-12-16 07:33:03 +00:00
|
|
|
"Must have a non-null string spec or nsIFile object",
|
2009-09-02 20:24:49 +00:00
|
|
|
Cr.NS_ERROR_INVALID_ARG,
|
|
|
|
Components.stack.caller
|
|
|
|
);
|
|
|
|
throw exception;
|
|
|
|
}
|
|
|
|
|
2009-12-16 07:33:03 +00:00
|
|
|
if (aTarget instanceof Ci.nsIFile) {
|
|
|
|
return this.ioService.newFileURI(aTarget);
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.ioService.newURI(aTarget, aOriginCharset, aBaseURI);
|
2009-10-03 05:11:20 +00:00
|
|
|
},
|
|
|
|
|
2009-12-16 07:33:06 +00:00
|
|
|
/**
|
|
|
|
* Constructs a new channel for the given spec, character set, and base URI,
|
|
|
|
* or nsIURI, or nsIFile.
|
|
|
|
*
|
|
|
|
* @param aWhatToLoad
|
|
|
|
* The string spec for the desired URI, an nsIURI, or an nsIFile.
|
|
|
|
* @param aOriginCharset [optional]
|
|
|
|
* The character set for the URI. Only used if aWhatToLoad is a
|
|
|
|
* string.
|
|
|
|
* @param aBaseURI [optional]
|
|
|
|
* The base URI for the spec. Only used if aWhatToLoad is a string.
|
|
|
|
*
|
|
|
|
* @return an nsIChannel object.
|
|
|
|
*/
|
|
|
|
newChannel: function NetUtil_newChannel(aWhatToLoad, aOriginCharset,
|
|
|
|
aBaseURI)
|
|
|
|
{
|
|
|
|
if (!aWhatToLoad) {
|
|
|
|
let exception = new Components.Exception(
|
|
|
|
"Must have a non-null string spec, nsIURI, or nsIFile object",
|
|
|
|
Cr.NS_ERROR_INVALID_ARG,
|
|
|
|
Components.stack.caller
|
|
|
|
);
|
|
|
|
throw exception;
|
|
|
|
}
|
|
|
|
|
|
|
|
let uri = aWhatToLoad;
|
|
|
|
if (!(aWhatToLoad instanceof Ci.nsIURI)) {
|
|
|
|
// We either have a string or an nsIFile that we'll need a URI for.
|
|
|
|
uri = this.newURI(aWhatToLoad, aOriginCharset, aBaseURI);
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.ioService.newChannelFromURI(uri);
|
|
|
|
},
|
|
|
|
|
2010-08-27 19:42:51 +00:00
|
|
|
/**
|
|
|
|
* Reads aCount bytes from aInputStream into a string.
|
|
|
|
*
|
|
|
|
* @param aInputStream
|
|
|
|
* The input stream to read from.
|
|
|
|
* @param aCount
|
|
|
|
* The number of bytes to read from the stream.
|
|
|
|
*
|
|
|
|
* @return the bytes from the input stream in string form.
|
|
|
|
*
|
|
|
|
* @throws NS_ERROR_INVALID_ARG if aInputStream is not an nsIInputStream.
|
|
|
|
* @throws NS_BASE_STREAM_WOULD_BLOCK if reading from aInputStream would
|
|
|
|
* block the calling thread (non-blocking mode only).
|
|
|
|
* @throws NS_ERROR_FAILURE if there are not enough bytes available to read
|
|
|
|
* aCount amount of data.
|
|
|
|
*/
|
|
|
|
readInputStreamToString: function NetUtil_readInputStreamToString(aInputStream,
|
|
|
|
aCount)
|
|
|
|
{
|
|
|
|
if (!(aInputStream instanceof Ci.nsIInputStream)) {
|
|
|
|
let exception = new Components.Exception(
|
|
|
|
"First argument should be an nsIInputStream",
|
|
|
|
Cr.NS_ERROR_INVALID_ARG,
|
|
|
|
Components.stack.caller
|
|
|
|
);
|
|
|
|
throw exception;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!aCount) {
|
|
|
|
let exception = new Components.Exception(
|
|
|
|
"Non-zero amount of bytes must be specified",
|
|
|
|
Cr.NS_ERROR_INVALID_ARG,
|
|
|
|
Components.stack.caller
|
|
|
|
);
|
|
|
|
throw exception;
|
|
|
|
}
|
|
|
|
|
|
|
|
let sis = Cc["@mozilla.org/scriptableinputstream;1"].
|
|
|
|
createInstance(Ci.nsIScriptableInputStream);
|
|
|
|
sis.init(aInputStream);
|
|
|
|
try {
|
|
|
|
return sis.readBytes(aCount);
|
|
|
|
}
|
|
|
|
catch (e) {
|
|
|
|
// Adjust the stack so it throws at the caller's location.
|
|
|
|
throw new Components.Exception(e.message, e.result,
|
|
|
|
Components.stack.caller, e.data);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2009-10-03 05:11:20 +00:00
|
|
|
/**
|
|
|
|
* Returns a reference to nsIIOService.
|
|
|
|
*
|
|
|
|
* @return a reference to nsIIOService.
|
|
|
|
*/
|
|
|
|
get ioService()
|
|
|
|
{
|
|
|
|
delete this.ioService;
|
|
|
|
return this.ioService = Cc["@mozilla.org/network/io-service;1"].
|
|
|
|
getService(Ci.nsIIOService);
|
2009-09-02 20:24:49 +00:00
|
|
|
},
|
2009-05-07 19:21:54 +00:00
|
|
|
};
|
2009-09-02 20:24:49 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//// Initialization
|
|
|
|
|
|
|
|
Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
|
|
|
|
// Define our lazy getters.
|
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "ioUtil", "@mozilla.org/io-util;1",
|
|
|
|
"nsIIOUtil");
|
2010-07-23 21:59:07 +00:00
|
|
|
|
2010-08-03 05:28:01 +00:00
|
|
|
XPCOMUtils.defineLazyGetter(this, "BadCertHandler", function () {
|
2010-07-23 21:59:07 +00:00
|
|
|
var obj = {};
|
|
|
|
Cu.import("resource://gre/modules/CertUtils.jsm", obj);
|
|
|
|
return obj.BadCertHandler;
|
|
|
|
});
|