/* 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/. */ /** * MozTCPSocket exposes a TCP client and server sockets * to highly privileged apps. It provides a buffered, non-blocking * interface for sending. For receiving, it uses an asynchronous, * event handler based interface. */ #include "domstubs.idl" #include "nsIDOMEvent.idl" #include "nsITCPSocketChild.idl" #include "nsIDOMTCPServerSocket.idl" interface nsISocketTransport; // Bug 731746 - Allow chrome JS object to implement nsIDOMEventTarget // nsITCPSocket should be an nsIEventTarget but js objects // cannot be an nsIEventTarget yet // #include "nsIEventTarget.idl" // Bug 723206 - Constructors implemented in JS from IDL should be // allowed to have arguments // // Once bug 723206 will be fixed, this method could be replaced by // arguments when instantiating a TCPSocket object. For example it will // be possible to do (similarly to the WebSocket API): // var s = new MozTCPSocket(host, port); // Bug 797561 - Expose a server tcp socket API to web applications [scriptable, uuid(65f6d2c8-4be6-4695-958d-0735e8935289)] interface nsIDOMTCPSocket : nsISupports { /** * Create and return a socket object which will attempt to connect to * the given host and port. * * @param host The hostname of the server to connect to. * @param port The port to connect to. * @param options An object specifying one or more parameters which * determine the details of the socket. * * useSecureTransport: true to create an SSL socket. Defaults to false. * * binaryType: "arraybuffer" to use ArrayBuffer * instances in the ondata callback and as the argument * to send. Defaults to "string", to use JavaScript strings. * * @return The new TCPSocket instance. */ nsIDOMTCPSocket open(in DOMString host, in unsigned short port, [optional] in jsval options); /** * Listen on a port * * @param localPort The port of the server socket. Pass -1 to indicate no preference, * and a port will be selected automatically. * @param options An object specifying one or more parameters which * determine the details of the socket. * * binaryType: "arraybuffer" to use ArrayBuffer * instances in the ondata callback and as the argument * to send. Defaults to "string", to use JavaScript strings. * @param backlog The maximum length the queue of pending connections may grow to. * This parameter may be silently limited by the operating system. * Pass -1 to use the default value. * * @return The new TCPServerSocket instance. */ nsIDOMTCPServerSocket listen(in unsigned short localPort, [optional] in jsval options, [optional] in unsigned short backlog); /** * Enable secure on channel. */ void upgradeToSecure(); /** * The host of this socket object. */ readonly attribute DOMString host; /** * The port of this socket object. */ readonly attribute unsigned short port; /** * True if this socket object is an SSL socket. */ readonly attribute boolean ssl; /** * The number of bytes which have previously been buffered by calls to * send on this socket. */ readonly attribute unsigned long bufferedAmount; /** * Pause reading incoming data and invocations of the ondata handler until * resume is called. */ void suspend(); /** * Resume reading incoming data and invoking ondata as usual. */ void resume(); /** * Close the socket. */ void close(); /** * Write data to the socket. * * @param data The data to write to the socket. If * binaryType: "arraybuffer" was passed in the options * object, then this object should be an ArrayBuffer instance. * If binaryType: "string" was passed, or if no binaryType * option was specified, then this object should be an * ordinary JavaScript string. * @param byteOffset The offset within the data from which to begin writing. * Has no effect on non-ArrayBuffer data. * @param byteLength The number of bytes to write. Has no effect on * non-ArrayBuffer data. * * @return Send returns true or false as a hint to the caller that * they may either continue sending more data immediately, or * may want to wait until the other side has read some of the * data which has already been written to the socket before * buffering more. If send returns true, then less than 64k * has been buffered and it's safe to immediately write more. * If send returns false, then more than 64k has been buffered, * and the caller may wish to wait until the ondrain event * handler has been called before buffering more data by more * calls to send. */ boolean send(in jsval data, [optional] in unsigned long byteOffset, [optional] in unsigned long byteLength); /** * The readyState attribute indicates which state the socket is currently * in. The state will be either "connecting", "open", "closing", or "closed". */ readonly attribute DOMString readyState; /** * The binaryType attribute indicates which mode this socket uses for * sending and receiving data. If the binaryType: "arraybuffer" option * was passed to the open method that created this socket, binaryType * will be "arraybuffer". Otherwise, it will be "string". */ readonly attribute DOMString binaryType; /** * The onopen event handler is called when the connection to the server * has been established. If the connection is refused, onerror will be * called, instead. */ attribute jsval onopen; /** * After send has buffered more than 64k of data, it returns false to * indicate that the client should pause before sending more data, to * avoid accumulating large buffers. This is only advisory, and the client * is free to ignore it and buffer as much data as desired, but if reducing * the size of buffers is important (especially for a streaming application) * ondrain will be called once the previously-buffered data has been written * to the network, at which point the client can resume calling send again. */ attribute jsval ondrain; /** * The ondata handler will be called repeatedly and asynchronously after * onopen has been called, every time some data was available from the server * and was read. If binaryType: "arraybuffer" was passed to open, the data * attribute of the event object will be an ArrayBuffer. If not, it will be a * normal JavaScript string. * * At any time, the client may choose to pause reading and receiving ondata * callbacks, by calling the socket's suspend() method. Further invocations * of ondata will be paused until resume() is called. */ attribute jsval ondata; /** * The onerror handler will be called when there is an error. The data * attribute of the event passed to the onerror handler will have a * description of the kind of error. * * If onerror is called before onopen, the error was connection refused, * and onclose will not be called. If onerror is called after onopen, * the connection was lost, and onclose will be called after onerror. */ attribute jsval onerror; /** * The onclose handler is called once the underlying network socket * has been closed, either by the server, or by the client calling * close. * * If onerror was not called before onclose, then either side cleanly * closed the connection. */ attribute jsval onclose; }; /* * Internal interfaces for use in cross-process socket implementation. * Needed to account for multiple possible types that can be provided to * the socket callbacks as arguments. */ [scriptable, uuid(0baa1be1-6a88-4f85-a6c8-29e95f35c122)] interface nsITCPSocketInternal : nsISupports { // Trigger the callback for |type| and provide a DOMError() object with the given data void callListenerError(in DOMString type, in DOMString name); // Trigger the callback for |type| and provide a string argument void callListenerData(in DOMString type, in DOMString data); // Trigger the callback for |type| and provide an ArrayBuffer argument void callListenerArrayBuffer(in DOMString type, in jsval data); // Trigger the callback for |type| with no argument void callListenerVoid(in DOMString type); // Update the DOM object's readyState and bufferedAmount values with the provided data void updateReadyStateAndBuffered(in DOMString readyState, in uint32_t bufferedAmount); // Create a socket object on the parent side. // This is called in accepting any open request on the parent side. // // @param transport // The accepted socket transport. // @param binaryType // "arraybuffer" to use ArrayBuffer instances // in the ondata callback and as the argument to send. nsIDOMTCPSocket createAcceptedParent(in nsISocketTransport transport, in DOMString binaryType); // Create a DOM socket on the child side // This is called when the socket is accepted on the parent side. // // @param socketChild // The socket child object for the IPC implementation. // @param binaryType // "arraybuffer" to use ArrayBuffer instances // in the ondata callback and as the argument to send. // @param window // An object to create ArrayBuffer for this window. See Bug 831107. nsIDOMTCPSocket createAcceptedChild(in nsITCPSocketChild socketChild, in DOMString binaryType, in nsIDOMWindow window); }; /** * nsITCPSocketEvent is the event object which is passed as the * first argument to all the event handler callbacks. It contains * the socket that was associated with the event, the type of event, * and the data associated with the event (if any). */ [scriptable, uuid(0f2abcca-b483-4539-a3e8-345707f75c44)] interface nsITCPSocketEvent : nsISupports { /** * The socket object which produced this event. */ readonly attribute nsIDOMTCPSocket target; /** * The type of this event. One of: * * open * error * data * drain * close */ readonly attribute DOMString type; /** * The data related to this event, if any. In the ondata callback, * data will be the bytes read from the network; if the binaryType * of the socket was "arraybuffer", this value will be of type ArrayBuffer; * otherwise, it will be a normal JavaScript string. * * In the onerror callback, data will be a string with a description * of the error. * * In the other callbacks, data will be an empty string. */ readonly attribute jsval data; };