[mirrors/Programs.git] / plugins / firefox-extensions / test / skeleton / chrome / content / connection-xpcom.js

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-\r
 *\r
 * ***** BEGIN LICENSE BLOCK *****\r
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1\r
 *\r
 * The contents of this file are subject to the Mozilla Public License Version\r
 * 1.1 (the "License"); you may not use this file except in compliance with\r
 * the License. You may obtain a copy of the License at\r
 * http://www.mozilla.org/MPL/\r
 *\r
 * Software distributed under the License is distributed on an "AS IS" basis,\r
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License\r
 * for the specific language governing rights and limitations under the\r
 * License.\r
 *\r
 * The Original Code is JSIRC Library.\r
 *\r
 * The Initial Developer of the Original Code is\r
 * New Dimensions Consulting, Inc.\r
 * Portions created by the Initial Developer are Copyright (C) 1999\r
 * the Initial Developer. All Rights Reserved.\r
 *\r
 * Contributor(s):\r
 *   Robert Ginda, rginda@ndcico.com, original author\r
 *   Peter Van der Beken, peter.vanderbeken@pandora.be, necko-only version\r
 *\r
 * Alternatively, the contents of this file may be used under the terms of\r
 * either the GNU General Public License Version 2 or later (the "GPL"), or\r
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),\r
 * in which case the provisions of the GPL or the LGPL are applicable instead\r
 * of those above. If you wish to allow use of your version of this file only\r
 * under the terms of either the GPL or the LGPL, and not to allow others to\r
 * use your version of this file under the terms of the MPL, indicate your\r
 * decision by deleting the provisions above and replace them with the notice\r
 * and other provisions required by the GPL or the LGPL. If you do not delete\r
 * the provisions above, a recipient may use your version of this file under\r
 * the terms of any one of the MPL, the GPL or the LGPL.\r
 *\r
 * ***** END LICENSE BLOCK ***** */\r
\r
const NS_ERROR_MODULE_NETWORK = 2152398848;\r
\r
const NS_ERROR_UNKNOWN_HOST = NS_ERROR_MODULE_NETWORK + 30;\r
const NS_ERROR_CONNECTION_REFUSED = NS_ERROR_MODULE_NETWORK + 13;\r
const NS_ERROR_NET_TIMEOUT = NS_ERROR_MODULE_NETWORK + 14;\r
const NS_ERROR_NET_RESET = NS_ERROR_MODULE_NETWORK + 20;\r
const NS_ERROR_UNKNOWN_PROXY_HOST = NS_ERROR_MODULE_NETWORK + 42;\r
const NS_ERROR_PROXY_CONNECTION_REFUSED = NS_ERROR_MODULE_NETWORK + 72;\r
\r
// Offline error constants:\r
const NS_ERROR_BINDING_ABORTED = NS_ERROR_MODULE_NETWORK + 2;\r
const NS_ERROR_ABORT = 0x80004004;\r
\r
const NS_NET_STATUS_RESOLVING_HOST = NS_ERROR_MODULE_NETWORK + 3;\r
const NS_NET_STATUS_CONNECTED_TO = NS_ERROR_MODULE_NETWORK + 4;\r
const NS_NET_STATUS_SENDING_TO = NS_ERROR_MODULE_NETWORK + 5;\r
const NS_NET_STATUS_RECEIVING_FROM = NS_ERROR_MODULE_NETWORK + 6;\r
const NS_NET_STATUS_CONNECTING_TO = NS_ERROR_MODULE_NETWORK + 7;\r
\r
// Security Constants.\r
const STATE_IS_BROKEN = 1;\r
const STATE_IS_SECURE = 2;\r
const STATE_IS_INSECURE = 3;\r
\r
const STATE_SECURE_LOW = 1;\r
const STATE_SECURE_HIGH = 2;\r
\r
const nsIScriptableInputStream = Components.interfaces.nsIScriptableInputStream;\r
\r
const nsIBinaryInputStream = Components.interfaces.nsIBinaryInputStream;\r
const nsIBinaryOutputStream = Components.interfaces.nsIBinaryOutputStream;\r
\r
function toSInputStream(stream, binary)\r
{\r
    var sstream;\r
\r
    if (binary)\r
    {\r
        sstream = Components.classes["@mozilla.org/binaryinputstream;1"];\r
        sstream = sstream.createInstance(nsIBinaryInputStream);\r
        sstream.setInputStream(stream);\r
    }\r
    else\r
    {\r
        sstream = Components.classes["@mozilla.org/scriptableinputstream;1"];\r
        sstream = sstream.createInstance(nsIScriptableInputStream);\r
        sstream.init(stream);\r
    }\r
\r
    return sstream;\r
}\r
\r
function toSOutputStream(stream, binary)\r
{\r
    var sstream;\r
\r
    if (binary)\r
    {\r
        sstream = Components.classes["@mozilla.org/binaryoutputstream;1"];\r
        sstream = sstream.createInstance(Components.interfaces.nsIBinaryOutputStream);\r
        sstream.setOutputStream(stream);\r
    }\r
    else\r
    {\r
        sstream = stream;\r
    }\r
\r
    return sstream;\r
}\r
\r
function CBSConnection (binary)\r
{\r
    /* Since 2003-01-17 18:14, Mozilla has had this contract ID for the STS.\r
     * Prior to that it didn't have one, so we also include the CID for the\r
     * STS back then - DO NOT UPDATE THE ID if it changes in Mozilla.\r
     */\r
    const sockClassByName =\r
        Components.classes["@mozilla.org/network/socket-transport-service;1"];\r
    const sockClassByID =\r
        Components.classesByID["{c07e81e0-ef12-11d2-92b6-00105a1b0d64}"];\r
\r
    var sockServiceClass = (sockClassByName || sockClassByID);\r
\r
    if (!sockServiceClass)\r
        throw ("Couldn't get socket service class.");\r
\r
    var sockService = sockServiceClass.getService();\r
    if (!sockService)\r
        throw ("Couldn't get socket service.");\r
\r
    this._sockService = sockService.QueryInterface\r
        (Components.interfaces.nsISocketTransportService);\r
\r
    /* Note: as part of the mess from bug 315288 and bug 316178, ChatZilla now\r
     *       uses the *binary* stream interfaces for all network\r
     *       communications.\r
     *\r
     *       However, these interfaces do not exist prior to 1999-11-05. To\r
     *       make matters worse, an incompatible change to the "readBytes"\r
     *       method of this interface was made on 2003-03-13; luckly, this\r
     *       change also added a "readByteArray" method, which we will check\r
     *       for below, to determin if we can use the binary streams.\r
     */\r
\r
    // We want to check for working binary streams only the first time.\r
    if (CBSConnection.prototype.workingBinaryStreams == -1)\r
    {\r
        CBSConnection.prototype.workingBinaryStreams = false;\r
\r
        if (typeof nsIBinaryInputStream != "undefined")\r
        {\r
            var isCls = Components.classes["@mozilla.org/binaryinputstream;1"];\r
            var inputStream = isCls.createInstance(nsIBinaryInputStream);\r
            if ("readByteArray" in inputStream)\r
                CBSConnection.prototype.workingBinaryStreams = true;\r
        }\r
    }\r
\r
    this.wrappedJSObject = this;\r
    if (typeof binary != "undefined")\r
        this.binaryMode = binary;\r
    else\r
        this.binaryMode = this.workingBinaryStreams;\r
\r
    if (!ASSERT(!this.binaryMode || this.workingBinaryStreams,\r
                "Unable to use binary streams in this build."))\r
    {\r
        throw ("Unable to use binary streams in this build.");\r
    }\r
}\r
\r
CBSConnection.prototype.workingBinaryStreams = -1;\r
\r
CBSConnection.prototype.connect =\r
function bc_connect(host, port, config, observer)\r
{\r
    this.host = host.toLowerCase();\r
    this.port = port;\r
\r
    if (typeof config != "object")\r
        config = {};\r
\r
    // Lets get a transportInfo for this\r
    var pps = getService("@mozilla.org/network/protocol-proxy-service;1",\r
                         "nsIProtocolProxyService");\r
    if (!pps)\r
        throw ("Couldn't get protocol proxy service");\r
\r
    var ios = getService("@mozilla.org/network/io-service;1", "nsIIOService");\r
\r
    function getProxyFor(uri)\r
    {\r
        uri = ios.newURI(uri, null, null);\r
        // As of 2005-03-25, 'examineForProxy' was replaced by 'resolve'.\r
        if ("resolve" in pps)\r
            return pps.resolve(uri, 0);\r
        if ("examineForProxy" in pps)\r
            return pps.examineForProxy(uri);\r
        return null;\r
    };\r
\r
    var proxyInfo = null;\r
    var usingHTTPCONNECT = false;\r
    if ("proxy" in config)\r
    {\r
        /* Force Necko to supply the HTTP proxy info if desired. For none,\r
         * force no proxy. Other values will get default treatment.\r
         */\r
        if (config.proxy == "http")\r
            proxyInfo = getProxyFor("http://" + host + ":" + port);\r
        else if (config.proxy != "none")\r
            proxyInfo = getProxyFor("irc://" + host + ":" + port);\r
\r
        /* Since the proxy info is opaque, we need to check that we got\r
         * something for our HTTP proxy - we can't just check proxyInfo.type.\r
         */\r
        usingHTTPCONNECT = ((config.proxy == "http") && proxyInfo);\r
    }\r
    else\r
    {\r
        proxyInfo = getProxyFor("irc://" + host + ":" + port);\r
    }\r
\r
    if (jsenv.HAS_STREAM_PROVIDER)\r
    {\r
        if (("isSecure" in config) && config.isSecure)\r
        {\r
            this._transport = this._sockService.\r
                              createTransportOfType("ssl", host, port,\r
                                                    proxyInfo, 0, 0);\r
        }\r
        else\r
        {\r
            this._transport = this._sockService.\r
                              createTransport(host, port, proxyInfo, 0, 0);\r
        }\r
        if (!this._transport)\r
            throw ("Error creating transport.");\r
\r
        if (jsenv.HAS_NSPR_EVENTQ)\r
        {   /* we've got an event queue, so start up an async write */\r
            this._streamProvider = new StreamProvider (observer);\r
            this._write_req =\r
                this._transport.asyncWrite (this._streamProvider, this,\r
                                            0, -1, 0);\r
        }\r
        else\r
        {\r
            /* no nspr event queues in this environment, we can't use async\r
             * calls, so set up the streams. */\r
            this._outputStream = this._transport.openOutputStream(0, -1, 0);\r
            if (!this._outputStream)\r
                throw "Error getting output stream.";\r
            this._sOutputStream = toSOutputStream(this._outputStream,\r
                                                  this.binaryMode);\r
\r
            this._inputStream = this._transport.openInputStream(0, -1, 0);\r
            if (!this._inputStream)\r
                throw "Error getting input stream.";\r
            this._sInputStream = toSInputStream(this._inputStream,\r
                                                this.binaryMode);\r
        }\r
    }\r
    else\r
    {\r
        /* use new necko interfaces */\r
        if (("isSecure" in config) && config.isSecure)\r
        {\r
            this._transport = this._sockService.\r
                              createTransport(["ssl"], 1, host, port,\r
                                              proxyInfo);\r
        }\r
        else\r
        {\r
            this._transport = this._sockService.\r
                              createTransport(null, 0, host, port, proxyInfo);\r
        }\r
        if (!this._transport)\r
            throw ("Error creating transport.");\r
\r
        /* if we don't have an event queue, then all i/o must be blocking */\r
        var openFlags;\r
        if (jsenv.HAS_NSPR_EVENTQ)\r
            openFlags = 0;\r
        else\r
            openFlags = Components.interfaces.nsITransport.OPEN_BLOCKING;\r
\r
        /* no limit on the output stream buffer */\r
        this._outputStream =\r
            this._transport.openOutputStream(openFlags, 4096, -1);\r
        if (!this._outputStream)\r
            throw "Error getting output stream.";\r
        this._sOutputStream = toSOutputStream(this._outputStream,\r
                                              this.binaryMode);\r
\r
        this._inputStream = this._transport.openInputStream(openFlags, 0, 0);\r
        if (!this._inputStream)\r
            throw "Error getting input stream.";\r
        this._sInputStream = toSInputStream(this._inputStream,\r
                                            this.binaryMode);\r
    }\r
\r
    this.connectDate = new Date();\r
    this.isConnected = true;\r
\r
    // Bootstrap the connection if we're proxying via an HTTP proxy.\r
    if (usingHTTPCONNECT)\r
    {\r
        this.sendData("CONNECT " + host + ":" + port + " HTTP/1.1\r\n\r\n");\r
    }\r
\r
    return this.isConnected;\r
\r
}\r
\r
CBSConnection.prototype.listen =\r
function bc_listen(port, observer)\r
{\r
    var serverSockClass =\r
        Components.classes["@mozilla.org/network/server-socket;1"];\r
\r
    if (!serverSockClass)\r
        throw ("Couldn't get server socket class.");\r
\r
    var serverSock = serverSockClass.createInstance();\r
    if (!serverSock)\r
        throw ("Couldn't get server socket.");\r
\r
    this._serverSock = serverSock.QueryInterface\r
        (Components.interfaces.nsIServerSocket);\r
\r
    this._serverSock.init(port, false, -1);\r
\r
    this._serverSockListener = new SocketListener(this, observer);\r
\r
    this._serverSock.asyncListen(this._serverSockListener);\r
\r
    this.port = this._serverSock.port;\r
\r
    return true;\r
}\r
\r
CBSConnection.prototype.accept =\r
function bc_accept(transport, observer)\r
{\r
    this._transport = transport;\r
    this.host = this._transport.host.toLowerCase();\r
    this.port = this._transport.port;\r
\r
    if (jsenv.HAS_STREAM_PROVIDER)\r
    {\r
        if (jsenv.HAS_NSPR_EVENTQ)\r
        {   /* we've got an event queue, so start up an async write */\r
            this._streamProvider = new StreamProvider (observer);\r
            this._write_req =\r
                this._transport.asyncWrite (this._streamProvider, this,\r
                                            0, -1, 0);\r
        }\r
        else\r
        {\r
            /* no nspr event queues in this environment, we can't use async\r
             * calls, so set up the streams. */\r
            this._outputStream = this._transport.openOutputStream(0, -1, 0);\r
            if (!this._outputStream)\r
                throw "Error getting output stream.";\r
            this._sOutputStream = toSOutputStream(this._outputStream,\r
                                                  this.binaryMode);\r
\r
            //this._scriptableInputStream =\r
            this._inputStream = this._transport.openInputStream(0, -1, 0);\r
            if (!this._inputStream)\r
                throw "Error getting input stream.";\r
            this._sInputStream = toSInputStream(this._inputStream,\r
                                                this.binaryMode);\r
        }\r
    }\r
    else\r
    {\r
        /* if we don't have an event queue, then all i/o must be blocking */\r
        var openFlags;\r
        if (jsenv.HAS_NSPR_EVENTQ)\r
            openFlags = 0;\r
        else\r
            openFlags = Components.interfaces.nsITransport.OPEN_BLOCKING;\r
\r
        /* no limit on the output stream buffer */\r
        this._outputStream =\r
            this._transport.openOutputStream(openFlags, 4096, -1);\r
        if (!this._outputStream)\r
            throw "Error getting output stream.";\r
        this._sOutputStream = toSOutputStream(this._outputStream,\r
                                              this.binaryMode);\r
\r
        this._inputStream = this._transport.openInputStream(openFlags, 0, 0);\r
        if (!this._inputStream)\r
            throw "Error getting input stream.";\r
        this._sInputStream = toSInputStream(this._inputStream,\r
                                            this.binaryMode);\r
    }\r
\r
    this.connectDate = new Date();\r
    this.isConnected = true;\r
\r
    // Clean up listening socket.\r
    this.close();\r
\r
    return this.isConnected;\r
}\r
\r
CBSConnection.prototype.close =\r
function bc_close()\r
{\r
    if ("_serverSock" in this && this._serverSock)\r
        this._serverSock.close();\r
}\r
\r
CBSConnection.prototype.disconnect =\r
function bc_disconnect()\r
{\r
    if ("_inputStream" in this && this._inputStream)\r
        this._inputStream.close();\r
    if ("_outputStream" in this && this._outputStream)\r
        this._outputStream.close();\r
    this.isConnected = false;\r
    /*\r
    this._streamProvider.close();\r
    if (this._streamProvider.isBlocked)\r
      this._write_req.resume();\r
    */\r
}\r
\r
CBSConnection.prototype.sendData =\r
function bc_senddata(str)\r
{\r
    if (!this.isConnected)\r
        throw "Not Connected.";\r
\r
    if (jsenv.HAS_NSPR_EVENTQ && jsenv.HAS_STREAM_PROVIDER)\r
        this.asyncWrite (str);\r
    else\r
        this.sendDataNow (str);\r
}\r
\r
CBSConnection.prototype.readData =\r
function bc_readdata(timeout, count)\r
{\r
    if (!this.isConnected)\r
        throw "Not Connected.";\r
\r
    var rv;\r
\r
    if (!("_sInputStream" in this)) {\r
        this._sInputStream = toSInputStream(this._inputStream);\r
        dump("OMG, setting up _sInputStream!\n");\r
    }\r
\r
    try\r
    {\r
        // XPCshell h4x\r
        if (typeof count == "undefined")\r
            count = this._sInputStream.available();\r
        if (this.binaryMode)\r
            rv = this._sInputStream.readBytes(count);\r
        else\r
            rv = this._sInputStream.read(count);\r
    }\r
    catch (ex)\r
    {\r
        dd ("*** Caught " + ex + " while reading.");\r
        this.disconnect();\r
        throw (ex);\r
    }\r
\r
    return rv;\r
}\r
\r
CBSConnection.prototype.startAsyncRead =\r
function bc_saread (observer)\r
{\r
    if (jsenv.HAS_STREAM_PROVIDER)\r
    {\r
        this._transport.asyncRead (new StreamListener (observer),\r
                                   this, 0, -1, 0);\r
    }\r
    else\r
    {\r
        var cls = Components.classes["@mozilla.org/network/input-stream-pump;1"];\r
        var pump = cls.createInstance(Components.interfaces.nsIInputStreamPump);\r
        pump.init(this._inputStream, -1, -1, 0, 0, false);\r
        pump.asyncRead(new StreamListener(observer), this);\r
    }\r
}\r
\r
CBSConnection.prototype.asyncWrite =\r
function bc_awrite (str)\r
{\r
    this._streamProvider.pendingData += str;\r
    if (this._streamProvider.isBlocked)\r
    {\r
        this._write_req.resume();\r
        this._streamProvider.isBlocked = false;\r
    }\r
}\r
\r
CBSConnection.prototype.hasPendingWrite =\r
function bc_haspwrite ()\r
{\r
    if (jsenv.HAS_STREAM_PROVIDER)\r
        return (this._streamProvider.pendingData != "");\r
    else\r
        return false; /* data already pushed to necko */\r
}\r
\r
CBSConnection.prototype.sendDataNow =\r
function bc_senddatanow(str)\r
{\r
    var rv = false;\r
\r
    try\r
    {\r
        if (this.binaryMode)\r
            this._sOutputStream.writeBytes(str, str.length);\r
        else\r
            this._sOutputStream.write(str, str.length);\r
        rv = true;\r
    }\r
    catch (ex)\r
    {\r
        dd ("*** Caught " + ex + " while sending.");\r
        this.disconnect();\r
        throw (ex);\r
    }\r
\r
    return rv;\r
}\r
\r
/* getSecurityState returns an array containing information about the security\r
 * of the connection. The array always has at least one item, which contains a\r
 * value from the STATE_IS_* enumeration at the top of this file. Iff this is\r
 * STATE_IS_SECURE, the array has a second item indicating the level of\r
 * security - a value from the STATE_SECURE_* enumeration.\r
 *\r
 * STATE_IS_BROKEN is returned if any errors occur, and STATE_IS_INSECURE is\r
 * returned for disconnected sockets.\r
 */\r
CBSConnection.prototype.getSecurityState =\r
function bc_getsecuritystate()\r
{\r
    if (!this.isConnected || !this._transport.securityInfo)\r
        return [STATE_IS_INSECURE];\r
\r
    try\r
    {\r
        var sslSp = Components.interfaces.nsISSLStatusProvider;\r
        var sslStatus = Components.interfaces.nsISSLStatus;\r
\r
        // Get the actual SSL Status\r
        sslSp = this._transport.securityInfo.QueryInterface(sslSp);\r
        sslStatus = sslSp.SSLStatus.QueryInterface(sslStatus);\r
        // Store appropriate status\r
        if (!("keyLength" in sslStatus) || !sslStatus.keyLength)\r
            return [STATE_IS_BROKEN];\r
        else if (sslStatus.keyLength >= 90)\r
            return [STATE_IS_SECURE, STATE_SECURE_HIGH];\r
        else\r
            return [STATE_IS_SECURE, STATE_SECURE_LOW];\r
    }\r
    catch (ex)\r
    {\r
        // Something goes wrong -> broken security icon\r
        dd("Exception getting certificate for connection: " + ex.message);\r
        return [STATE_IS_BROKEN];\r
    }\r
}\r
\r
CBSConnection.prototype.getCertificate =\r
function bc_getcertificate()\r
{\r
    if (!this.isConnected || !this._transport.securityInfo)\r
        return null;\r
\r
    var sslSp = Components.interfaces.nsISSLStatusProvider;\r
    var sslStatus = Components.interfaces.nsISSLStatus;\r
\r
    // Get the actual SSL Status\r
    sslSp = this._transport.securityInfo.QueryInterface(sslSp);\r
    sslStatus = sslSp.SSLStatus.QueryInterface(sslStatus);\r
\r
    // return the certificate\r
    return sslStatus.serverCert;\r
}\r
\r
function _notimpl ()\r
{\r
    throw "Not Implemented.";\r
}\r
\r
if (!jsenv.HAS_NSPR_EVENTQ)\r
{\r
    CBSConnection.prototype.startAsyncRead = _notimpl;\r
    CBSConnection.prototype.asyncWrite = _notimpl;\r
}\r
else if (jsenv.HAS_STREAM_PROVIDER)\r
{\r
    CBSConnection.prototype.sendDataNow = _notimpl;\r
}\r
else\r
{\r
    CBSConnection.prototype.asyncWrite = _notimpl;\r
}\r
\r
delete _notimpl;\r
\r
function StreamProvider(observer)\r
{\r
    this._observer = observer;\r
}\r
\r
StreamProvider.prototype.pendingData = "";\r
StreamProvider.prototype.isBlocked = true;\r
\r
StreamProvider.prototype.close =\r
function sp_close ()\r
{\r
    this.isClosed = true;\r
}\r
\r
StreamProvider.prototype.onDataWritable =\r
function sp_datawrite (request, ctxt, ostream, offset, count)\r
{\r
    //dd ("StreamProvider.prototype.onDataWritable");\r
\r
    if ("isClosed" in this && this.isClosed)\r
        throw Components.results.NS_BASE_STREAM_CLOSED;\r
\r
    if (!this.pendingData)\r
    {\r
        this.isBlocked = true;\r
\r
        /* this is here to support pre-XPCDOM builds (0.9.0 era), which\r
         * don't have this result code mapped. */\r
        if (!Components.results.NS_BASE_STREAM_WOULD_BLOCK)\r
            throw 2152136711;\r
\r
        throw Components.results.NS_BASE_STREAM_WOULD_BLOCK;\r
    }\r
\r
    var len = ostream.write (this.pendingData, this.pendingData.length);\r
    this.pendingData = this.pendingData.substr (len);\r
}\r
\r
StreamProvider.prototype.onStartRequest =\r
function sp_startreq (request, ctxt)\r
{\r
    //dd ("StreamProvider::onStartRequest: " + request + ", " + ctxt);\r
}\r
\r
\r
StreamProvider.prototype.onStopRequest =\r
function sp_stopreq (request, ctxt, status)\r
{\r
    //dd ("StreamProvider::onStopRequest: " + request + ", " + ctxt + ", " +\r
    //    status);\r
    if (this._observer)\r
        this._observer.onStreamClose(status);\r
}\r
\r
function StreamListener(observer)\r
{\r
    this._observer = observer;\r
}\r
\r
StreamListener.prototype.onStartRequest =\r
function sl_startreq (request, ctxt)\r
{\r
    //dd ("StreamListener::onStartRequest: " + request + ", " + ctxt);\r
}\r
\r
StreamListener.prototype.onStopRequest =\r
function sl_stopreq (request, ctxt, status)\r
{\r
    //dd ("StreamListener::onStopRequest: " + request + ", " + ctxt + ", " +\r
    //status);\r
    if (this._observer)\r
        this._observer.onStreamClose(status);\r
}\r
\r
StreamListener.prototype.onDataAvailable =\r
function sl_dataavail (request, ctxt, inStr, sourceOffset, count)\r
{\r
    ctxt = ctxt.wrappedJSObject;\r
    if (!ctxt)\r
    {\r
        dd ("*** Can't get wrappedJSObject from ctxt in " +\r
            "StreamListener.onDataAvailable ***");\r
        return;\r
    }\r
\r
    if (!("_sInputStream" in ctxt))\r
        ctxt._sInputStream = toSInputStream(inStr, false);\r
\r
    if (this._observer)\r
        this._observer.onStreamDataAvailable(request, inStr, sourceOffset,\r
                                             count);\r
}\r
\r
function SocketListener(connection, observer)\r
{\r
    this._connection = connection;\r
    this._observer = observer;\r
}\r
\r
SocketListener.prototype.onSocketAccepted =\r
function sl_onSocketAccepted(socket, transport)\r
{\r
    this._observer.onSocketAccepted(socket, transport);\r
}\r
SocketListener.prototype.onStopListening =\r
function sl_onStopListening(socket, status)\r
{\r
    delete this._connection._serverSockListener;\r
    delete this._connection._serverSock;\r
}\r