gecko/dom/network/TCPServerSocket.js

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

const Cc = Components.classes;
const Ci = Components.interfaces;
const Cu = Components.utils;
const Cr = Components.results;
const CC = Components.Constructor;

Cu.import("resource://gre/modules/XPCOMUtils.jsm");

const ServerSocket = CC(
        '@mozilla.org/network/server-socket;1', 'nsIServerSocket', 'init'),
      TCPSocketInternal = Cc[
        '@mozilla.org/tcp-socket;1'].createInstance(Ci.nsITCPSocketInternal);

/*
 * Debug logging function
 */

let debug = true;
function LOG(msg) {
  if (debug) {
    dump("TCPServerSocket: " + msg + "\n");
  }
}

/*
 * nsIDOMTCPServerSocket object
 */

function TCPServerSocket() {
  this._localPort = 0;
  this._binaryType = null;

  this._onconnect = null;
  this._onerror = null;

  this._inChild = false;
  this._neckoTCPServerSocket = null;
  this._serverBridge = null;
  this.useWin = null;
}

TCPServerSocket.prototype = {
  __exposedProps__: {
    port: 'r',
    onconnect: 'rw',
    onerror: 'rw'
  },
  get localPort() {
    return this._localPort;
  },
  get onconnect() {
    return this._onconnect;
  },
  set onconnect(f) {
    this._onconnect = f;
  },
  get onerror() {
    return this._onerror;
  },
  set onerror(f) {
    this._onerror = f;
  },

  _callListenerAcceptCommon: function tss_callListenerAcceptCommon(socket) {
    if (this._onconnect) {
      try {
        this["onconnect"].call(null, socket);
      } catch (e) {
        socket.close();
      }      
    }
    else {
      socket.close();
      dump("Received unexpected connection!");
    }
  },
  init: function tss_init(aWindowObj) {
    this.useWin = aWindowObj;
  },

  /* nsITCPServerSocketInternal method */
  listen: function tss_listen(localPort, options, backlog) {
    this._inChild = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime)
                       .processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
    this._binaryType = options.binaryType;

    if (this._inChild) {
      if (this._serverBridge == null) {
        this._serverBridge = Cc["@mozilla.org/tcp-server-socket-child;1"]
                                .createInstance(Ci.nsITCPServerSocketChild);
        this._serverBridge.listen(this, localPort, backlog, options.binaryType);
      }
      else {
        throw new Error("Child TCPServerSocket has already listening. \n");
      }
    }
    else {
      if (this._neckoTCPServerSocket == null) {
        this._neckoTCPServerSocket = new ServerSocket(localPort, false, backlog);
        this._localPort = this._neckoTCPServerSocket.port;
        this._neckoTCPServerSocket.asyncListen(this);
      }
      else {
        throw new Error("Parent TCPServerSocket has already listening. \n");
      }
    }
  },

  callListenerAccept: function tss_callListenerSocket(socketChild) {
    // this method is called at child process when the socket is accepted at parent process.
    let socket = TCPSocketInternal.createAcceptedChild(socketChild, this._binaryType, this.useWin);
    this._callListenerAcceptCommon(socket);
  },

  callListenerError: function tss_callListenerError(message, filename, lineNumber, columnNumber) {
    if (this._onerror) {
      var type = "error";
      var error = new Error(message, filename, lineNumber, columnNumber);

      this["onerror"].call(null, new TCPSocketEvent(type, this, error));
    }    
  },
  /* end nsITCPServerSocketInternal method */

  close: function tss_close() {
    if (this._inChild) {
      this._serverBridge.close();
      return;
    }

    /*　Close ServerSocket　*/
    if (this._neckoTCPServerSocket) {
      this._neckoTCPServerSocket.close();
    }
  },

  // nsIServerSocketListener (Triggered by _neckoTCPServerSocket.asyncListen)
  onSocketAccepted: function tss_onSocketAccepted(server, trans) {
    // precondition: this._inChild == false
    try {
      let that = TCPSocketInternal.createAcceptedParent(trans, this._binaryType);
      this._callListenerAcceptCommon(that);
    }
    catch(e) {
      trans.close(Cr.NS_BINDING_ABORTED);
    }
  },

  // nsIServerSocketListener (Triggered by _neckoTCPServerSocket.asyncListen)
  onStopListening: function tss_onStopListening(server, status) {
    if (status != Cr.NS_BINDING_ABORTED) {
      throw new Error("Server socket was closed by unexpected reason.");
    }
    this._neckoTCPServerSocket = null;
  },

  classID: Components.ID("{73065eae-27dc-11e2-895a-000c29987aa2}"),

  classInfo: XPCOMUtils.generateCI({
    classID: Components.ID("{73065eae-27dc-11e2-895a-000c29987aa2}"),
    classDescription: "Server TCP Socket",
    interfaces: [
      Ci.nsIDOMTCPServerSocket,
      Ci.nsISupportsWeakReference
    ],
    flags: Ci.nsIClassInfo.DOM_OBJECT,
  }),

  QueryInterface: XPCOMUtils.generateQI([
    Ci.nsIDOMTCPServerSocket,
    Ci.nsITCPServerSocketInternal,
    Ci.nsISupportsWeakReference
  ])
}

this.NSGetFactory = XPCOMUtils.generateNSGetFactory([TCPServerSocket]);